23-05-31

지역해에 조기수렴하는 문제를 줄이기 위해 일정 비율을 전역해에서 반대 방향의 1/2 만큼 속도를 가지도록 조정

iris.py

@@ -39,12 +39,9 @@ x_train, x_test, y_train, y_test = load_data()
 
 loss = 'categorical_crossentropy'
 
-pso_iris = Optimizer(model, loss=loss, n_particles=50, c0=0.5, c1=0.8, w_min=0.75, w_max=1.3)
+pso_iris = Optimizer(model, loss=loss, n_particles=50, c0=0.4, c1=0.8, w_min=0.7, w_max=1.0, random=0.2)
 
 weight, score = pso_iris.fit(
-    x_train, y_train, epochs=500, save=True, save_path="./result/iris", renewal="acc", empirical_balance=False, Dispersion=False, check_point=50)
+    x_train, y_train, epochs=500, save=True, save_path="./result/iris", renewal="acc", empirical_balance=False, Dispersion=False, check_point=25)
-
-pso_iris.model_save("./result/iris")
-pso_iris.save_info("./result/iris/")
 
 gc.collect()

mnist.py

@@ -79,10 +79,10 @@ loss = 'huber_loss'
 # loss = 'mean_squared_error'
 
 
-pso_mnist = Optimizer(model, loss=loss, n_particles=50, c0=0.4, c1=0.8, w_min=0.7, w_max=1.2, random=0.3)
+pso_mnist = Optimizer(model, loss=loss, n_particles=75, c0=0.4, c1=0.8, w_min=0.6, w_max=0.95, random=0.3)
 weight, score = pso_mnist.fit(
-    x_test, y_test, epochs=200, save=True, save_path="./result/mnist", renewal="acc", empirical_balance=False, Dispersion=False, check_point=10)
+    x_test, y_test, epochs=500, save=True, save_path="./result/mnist", renewal="acc", empirical_balance=False, Dispersion=False, check_point=10)
-pso_mnist.model_save("./result/mnist")
+# pso_mnist.model_save("./result/mnist")
-pso_mnist.save_info("./result/mnist")
+# pso_mnist.save_info("./result/mnist")
 
 gc.collect()

pso/optimizer.py

@@ -58,7 +58,7 @@ class Optimizer:
             m = keras.models.model_from_json(model.to_json())
             init_weights = m.get_weights()
             w_, sh_, len_ = self._encode(init_weights)
-            w_ = np.random.uniform(-3, 3, len(w_))
+            w_ = np.random.uniform(-1.5, 1.5, len(w_))
             m.set_weights(self._decode(w_, sh_, len_))
             m.compile(loss=self.loss, optimizer="sgd", metrics=["accuracy"])
             if i < random * self.n_particles:
@@ -249,8 +249,6 @@ class Optimizer:
                         min_score = score[1]
                     if score[1] > max_score:
                         max_score = score[1]
-                        
-                    gc.collect()
 
                     if save:
                         with open(
@@ -261,7 +259,6 @@ class Optimizer:
                             if i != self.n_particles - 1:
                                 f.write(", ")
                                 
-
                 TS = self.c0 + np.random.rand() * (self.c1 - self.c0)
                 g_, g_sh, g_len = self._encode(self.g_best)
                 decrement = (epochs - (_) + 1) / epochs
@@ -278,7 +275,7 @@ class Optimizer:
                 # print(f"loss min : {min_loss} | loss max : {max_loss} | acc min : {min_score} | acc max : {max_score}")
                 # print(f"loss avg : {loss/self.n_particles} | acc avg : {acc/self.n_particles} | Best {renewal} : {self.g_best_score}")
                 print(
-                    f"loss min : {min_loss} | acc max : {max_score} | Best {renewal} : {self.g_best_score}"
+                    f"loss min : {round(min_loss, 4)} | acc max : {round(max_score, 4)} | Best {renewal} : {self.g_best_score}"
                 )
 
                 gc.collect()
@@ -289,22 +286,16 @@ class Optimizer:
                         self._check_point_save(f"./{save_path}/{self.day}/ckpt-{_}")
                 self.avg_score = acc/self.n_particles
         except KeyboardInterrupt:
-            print("Keyboard Interrupt")
+            print("Ctrl + C : Stop Training")
-            self.model_save(save_path)
-            print("model saved")
-            self.save_info(save_path)
-            print("info saved")
-            sys.exit(0)
         except MemoryError:
-            print("Memory Error")
+            print("Memory Error : Stop Training")
+        except Exception as e:
+            print(e)
+        finally:
             self.model_save(save_path)
             print("model save")
             self.save_info(save_path)
             print("save info")
-            sys.exit(1)
-        except Exception as e:
-            print(e)
-        finally:
             return self.g_best, self.g_best_score
             
 

pso/particle.py

@@ -17,7 +17,6 @@ class Particle:
         self.best_score = 0
         self.best_weights = self.init_weights
 
-
     """
     Returns:
         (cupy array) : 가중치 - 1차원으로 풀어서 반환
@@ -35,7 +34,6 @@ class Particle:
             lenght.append(len(w_))
             # w_gpu = cp.append(w_gpu, w_)
             w_gpu = np.append(w_gpu, w_)
-        
         return w_gpu, shape, lenght
 
     """
@@ -95,11 +93,10 @@ class Particle:
         encode_w, w_sh, w_len = self._encode(weights = self.model.get_weights())
         encode_v, _, _ = self._encode(weights = self.velocities)
         if self.random:
-            encode_v = -1 * encode_v
+            encode_v = -0.5 * encode_v
         new_w = encode_w + encode_v
         self.model.set_weights(self._decode(new_w, w_sh, w_len))
 
-
     def f(self, x, y, weights):
         self.model.set_weights(weights)
         score = self.model.evaluate(x, y, verbose = 0)[1]
@@ -118,7 +115,6 @@ class Particle:
         self._update_weights()
         return self.get_score(x, y, renewal)
     
-    
     def get_best_score(self):
         return self.best_score
     

readme.md

@@ -13,12 +13,15 @@ pso 알고리즘을 사용하여 새로운 학습 방법을 찾는중 입니다
 
 다음 위치를 구하는 수식입니다
 
-> $$p_{id(t+1)} = \begin{cases} 
+> $$
-x_{id(t+1)} & \text{if } f(x_{id(t+1)}) < f(p_{id(t)}) 
+p_{id(t+1)} =
-\\ p_{id(t)} & \text{otherwise} 
+\begin{cases}
-\end{cases}$$
+x_{id(t+1)} & \text{if } f(x_{id(t+1)}) < f(p_{id(t)})\\
+p_{id(t)} & \text{otherwise}
+\end{cases}
+$$
 
-### 위치를 가장 최적값으로 변경(덮어쓰기)하면 안되는 이유
+### 위치를 현재 전역해로 변경(덮어쓰기)하면 안되는 이유
 
 위치를 가장 최적값으로 변경하면 지역 최적값에서 벗어나지 못합니다. 따라서 전역 최적값을 찾을 수 없습니다.
 
@@ -26,56 +29,65 @@ x_{id(t+1)} & \text{if } f(x_{id(t+1)}) < f(p_{id(t)})
 
 ## 1. PSO 알고리즘 구현
 
+### 파일 구조
+
 ```plain text
 |-- metacode   # pso 기본 코드
+|  |-- pso_bp.py # 오차역전파 함수를 최적화하는 PSO 알고리즘 구현 - 성능이 99% 이상으로 나오나 목적과 다름
+|  |-- pso_meta.py # PSO 기본 알고리즘 구현
+|  |-- pso_tf.py # tensorflow 모델을 이용가능한 PSO 알고리즘 구현
 |-- pso        # tensorflow 모델을 학습하기 위해 기본 pso 코드에서 수정 - (psokeras 코드 의 구조를 사용하여 만듬)
+|  |-- __init__.py  # pso 모듈을 사용하기 위한 초기화 파일
+|  |-- optimizer.py # pso 알고리즘 이용을 위한 기본 코드
+|  |-- particle.py  # 각 파티클의 정보 및 위치를 저장하는 코드
 |-- psokeras   # keras 모델을 이용가능한 PSO 알고리즘 - 다른 사람의 코드
+|  |-- ***
 |-- pyswarms   # pyswarms 라이브러리를 이용가능한 PSO 알고리즘 - 다른 사람의 코드
+|  |-- ***
 |-- examples.py # psokeras 코드를 이용한 예제
 |-- iris.py    # pso 코드를 이용한 iris 문제 풀이
 |-- mnist.py   # pso 코드를 이용한 mnist 문제 풀이
 |-- xor.ipynb     # pso 코드를 이용한 xor 문제 풀이
 |-- plt.ipynb     # pyplot 으로 학습 결과를 그래프로 표현
-
-pso_meta.py  # PSO 알고리즘 구현
-pso_tf.py # tensorflow 모델을 이용가능한 PSO 알고리즘 구현
-pso_bp.py # 오차역전파 함수를 최적화하는 PSO 알고리즘 구현 - 성능이 99% 이상으로 나오나 목적과 다름
-pso_tuning.py # pso 알고리즘의 하이퍼 파라미터를 자동으로 튜닝하는 파일
-
-xor.ipynb # xor 문제를 pso 알고리즘으로 풀이
-iris.ipynb # iris 문제를 pso 알고리즘으로 풀이
-mnist.ipynb # mnist 문제를 pso 알고리즘으로 풀이
-mnist.py # mnist 문제를 pso 알고리즘으로 풀이 - shell 실행용
 ```
 
+psokeras 및 pyswarms 라이브러리는 외부 라이브러리이기에 코드를 수정하지 않았습니다
+
+pso 라이브러리는 tensorflow 모델을 학습하기 위해 기본 ./metacode/pso_meta.py 코드에서 수정하였습니다
+
 ## 2. PSO 알고리즘을 이용한 최적화 문제 풀이
 
 pso 알고리즘을 이용하여 오차역전파 함수를 최적화 하는 방법을 찾는 중입니다
 
-### 임시 아이디어
+### 브레인스토밍
 
-1. 오차역전파 함수를 1~5회 실행하여 오차를 구합니다
+> 1. 오차역전파 함수를 1~5회 실행하여 오차를 구합니다
-2. 오차가 가장 적은 다른 노드(particle) 가중치로 유도합니다.
+> 2. 오차가 가장 적은 다른 노드(particle) 가중치로 유도합니다.
+>
+>> 2-1. 만약 오차가 가장 작은 다른 노드가 현재 노드보다 오차가 크다면, 현재 노드의 가중치를 유지합니다. - 현재의 가중치를 최적값으로 업로드합니다
+>>
+>> 2-2. 지역 최적값을 찾았다면, 전역 최적값을 찾을 때까지 1~2 과정을 반복합니다
+>
+> 3. 전역 최적값이 특정 임계치에서 변화율이 적다면 학습을 종료합니다 - 현재 결과가 정확도가 높지 않아서 이 기능은 추후에 추가할 예정입니다
 
-   2-1. 만약 오차가 가장 작은 다른 노드가 현재 노드보다 오차가 크다면, 현재 노드의 가중치를 유지합니다. - 현재의 가중치를 최적값으로 업로드합니다
+<br>
+위의 아이디어는 원래의 목표와 다른 방향으로 가고 있습니다. 따라서 다른 방법을 모색해야할 것 같습니다
+<br><br>
 
-   2-2. 지역 최적값을 찾았다면, 전역 최적값을 찾을 때까지 1~2 과정을 반복합니다
+### Trouble Shooting
 
-3. 전역 최적값이 특정 임계치에서 변화율이 적다면 학습을 종료합니다 - 현재 결과가 정확도가 높지 않아서 이 기능은 추후에 추가할 예정입니다
+> 1. 딥러닝 알고리즘 특성상 weights는 처음 컴파일시 무작위하게 생성된다. weights의 각 지점의 중요도는 매번 무작위로 정해지기에 전역 최적값으로 찾아갈 때 값이 높은 loss를 향해서 상승하는 현상이 나타난다.<br>
-
-### 현재 문제
-
-> 딥러닝 알고리즘 특성상 weights는 처음 컴파일시 무작위하게 생성된다. weights의 각 지점의 중요도는 매번 무작위로 정해지기에 전역 최적값으로 찾아갈 때 값이 높은 loss를 향해서 상승하는 현상이 나타난다.
-> <br>
 > 따라서 weights의 이동 방법을 더 탐구하거나, weights를 초기화 할때 random 중요도를 좀더 노이즈가 적게 생성하는 방향을 모색해야할 것 같다.
 
+-> 고르게 초기화 하기 위해 np.random.uniform 함수를 사용하였습니다
+
+> 2. 지역최적값에 계속 머무르는 조기 수렴 현상이 나타난다. - 30% 정도의 정확도를 가진다
+
 ### 개인적인 생각
 
 > 머신러닝 분류 방식에 존재하는 random forest 방식을 이용하여, 오차역전파 함수를 최적화 하는 방법이 있을것 같습니다
-> <br>
 >
 > > pso 와 random forest 방식이 매우 유사하다고 생각하여 학습할 때 뿐만 아니라 예측 할 때도 이러한 방식으로 사용할 수 있을 것 같습니다
 
-
 이곳의 코드를 참고하여 좀더 효율적인 코드로 수정하였습니다
-> https://github.com/mike-holcomb/PSOkeras
+> <https://github.com/mike-holcomb/PSOkeras>