23-05-24

pso 알고리즘을 구현하는데 bp 를 완전히 배제하는 방법으로 구현
model 디렉토리를 자동으로 생성하게 수정

mnist.py

@@ -0,0 +1,136 @@
+# %%
+import os
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+
+import tensorflow as tf
+# tf.random.set_seed(777)  # for reproducibility
+
+from tensorflow import keras
+from keras.datasets import mnist
+from keras.models import Sequential
+from keras.layers import Dense, Dropout, Flatten
+from keras.layers import Conv2D, MaxPooling2D
+from keras import backend as K
+
+from pso_tf import PSO
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+from datetime import date
+from tqdm import tqdm
+import json
+
+print(tf.__version__)
+print(tf.config.list_physical_devices())
+
+def get_data():
+    (x_train, y_train), (x_test, y_test) = mnist.load_data()
+
+    x_train, x_test = x_train / 255.0, x_test / 255.0
+    x_train = x_train.reshape((60000, 28 ,28, 1))
+    x_test = x_test.reshape((10000, 28 ,28, 1))
+
+    print(f"x_train : {x_train[0].shape} | y_train : {y_train[0].shape}")
+    print(f"x_test : {x_test[0].shape} | y_test : {y_test[0].shape}")
+    return x_train, y_train, x_test, y_test
+
+def make_model():
+    model = Sequential()
+    model.add(Conv2D(32, kernel_size=(5, 5), activation='relu', input_shape=(28,28,1)))
+    model.add(MaxPooling2D(pool_size=(3, 3)))
+    model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))
+    model.add(MaxPooling2D(pool_size=(2, 2)))
+    model.add(Dropout(0.25))
+    model.add(Flatten())
+    model.add(Dense(128, activation='relu'))
+    model.add(Dense(10, activation='softmax'))
+
+    # model.summary()
+
+    return model
+
+# %%
+'''
+optimizer parameter
+'''
+lr = 0.1
+momentun = 0.8
+decay = 1e-04
+nestrov = True
+
+'''
+pso parameter
+'''
+n_particles = 30
+maxiter = 50
+# epochs = 1
+w = 0.8
+c0 = 0.6
+c1 = 1.6
+
+def auto_tuning(n_particles=n_particles, maxiter=maxiter, c0=c0, c1=c1, w=w):
+    x_train, y_train, x_test, y_test = get_data()
+    model = make_model()
+
+    loss = keras.losses.MeanSquaredError()
+    optimizer = keras.optimizers.SGD(lr=lr, momentum=momentun, decay=decay, nesterov=nestrov)
+
+
+    pso_m = PSO(model=model, loss_method=loss, n_particles=n_particles, x_train=x_train, y_train=y_train)
+    # c0 : 지역 최적값 중요도
+    # c1 : 전역 최적값 중요도
+    # w : 관성 (현재 속도를 유지하는 정도)
+    best_weights, score = pso_m.optimize(x_train, y_train, x_test, y_test, maxiter=maxiter, c0=c0, c1=c1, w=w)
+    model.set_weights(best_weights)
+
+    score_ = model.evaluate(x_test, y_test, verbose=2)
+    print(f" Test loss: {score_}")
+    score = round(score_[1]*100, 2)
+
+    day = date.today().strftime("%Y-%m-%d")
+
+    os.makedirs(f'./model', exist_ok=True)
+    model.save(f'./model/{day}_{score}_mnist.h5')
+    json_save = {
+        "name" : f"{day}_{score}_mnist.h5",
+        "score" : score_,
+        "maxiter" : maxiter,
+        "c0" : c0,
+        "c1" : c1,
+        "w" : w    
+    }
+    with open(f'./model/{day}_{score}_pso_mnist.json', 'a') as f:
+        json.dump(json_save, f)
+        f.write(',\n')
+                    
+    return model
+
+# auto_tuning(n_particles=30, maxiter=1000, c0=0.5, c1=1.5, w=0.75)
+
+
+# %%
+# print(f"정답 > {y_test}")
+def get_score(model):
+    x_train, y_train, x_test, y_test = get_data()
+    
+    predicted_result = model.predict(x_test)
+    predicted_labels = np.argmax(predicted_result, axis=1)
+    not_correct = []
+    for i in tqdm(range(len(y_test)), desc="진행도"):
+        if predicted_labels[i] != y_test[i]:
+            not_correct.append(i)
+            # print(f"추론 > {predicted_labels[i]} | 정답 > {y_test[i]}")
+            
+    print(f"틀린 갯수 > {len(not_correct)}/{len(y_test)}")
+
+    # for i in range(3):
+        # plt.imshow(x_test[not_correct[i]].reshape(28,28), cmap='Greys')
+    # plt.show() 
+    
+get_score(auto_tuning(n_particles=30, maxiter=1000, c0=0.5, c1=1.5, w=0.75))
+
+# %%
+
+
+

pso_bp.py

@@ -0,0 +1,280 @@
+import numpy as np
+import tensorflow as tf
+from tensorflow import keras
+from tqdm import tqdm
+
+
+class PSO(object):
+    """
+    Class implementing PSO algorithm
+    """
+
+    def __init__(self, model: keras.models, loss_method=keras.losses.MeanSquaredError(), optimizer='adam', n_particles=5):
+        """
+        Initialize the key variables.
+
+        Args:
+            model : 학습할 모델 객체 (Sequential)
+            loss_method : 손실 함수
+            optimizer : 최적화 함수
+            n_particles(int) : 파티클의 개수
+        """
+        self.model = model                      # 모델
+        self.n_particles = n_particles          # 파티클의 개수
+        self.loss_method = loss_method          # 손실 함수
+        self.optimizer = optimizer              # 최적화 함수
+        self.model_structure = self.model.to_json()  # 모델의 구조
+        self.init_weights = self.model.get_weights()          # 검색할 차원
+        self.particle_depth = len(self.model.get_weights())    # 검색할 차원의 깊이
+        self.particles_weights = [None] * n_particles                 # 파티클의 위치
+        for _ in tqdm(range(self.n_particles), desc="init particles position"):
+            # particle_node = []
+            m = keras.models.model_from_json(self.model_structure)
+            m.compile(loss=self.loss_method,
+                      optimizer=self.optimizer, metrics=["accuracy"])
+            self.particles_weights[_] = m.get_weights()
+            # print(f"shape > {self.particles_weights[_][0]}")
+       
+
+            # self.particles_weights.append(particle_node)
+
+        # print(f"particles_weights > {self.particles_weights}")
+        # self.particles_weights = np.random.uniform(size=(n_particles, self.particle_depth)) \
+            # * self.init_pos
+        # 입력받은 파티클의 개수 * 검색할 차원의 크기 만큼의 균등한 위치를 생성
+        # self.velocities = [None] * self.n_particles
+        self.velocities = [
+            [0 for i in range(self.particle_depth)] for n in range(n_particles)]
+        for i in tqdm(range(n_particles), desc="init velocities"):
+            # print(i)
+            for index, layer in enumerate(self.init_weights):
+                # print(f"index > {index}")
+                # print(f"layer > {layer.shape}")
+                self.velocities[i][index] = np.random.rand(
+                    *layer.shape) / 5 - 0.10
+                # if layer.ndim == 1:
+                #     self.velocities[i][index] = np.random.uniform(
+                #         size=(layer.shape[0],))
+                # elif layer.ndim == 2:
+                #     self.velocities[i][index] = np.random.uniform(
+                #         size=(layer.shape[0], layer.shape[1]))
+                # elif layer.ndim == 3:
+                #     self.velocities[i][index] = np.random.uniform(
+                #         size=(layer.shape[0], layer.shape[1], layer.shape[2]))
+        # print(f"type > {type(self.velocities)}")
+        # print(f"velocities > {self.velocities}")
+
+        # print(f"velocities > {self.velocities}")
+        # for i, layer in enumerate(self.init_weights):
+        #     self.velocities[i] = np.random.rand(*layer.shape) / 5 - 0.10
+
+        # self.velocities = np.random.uniform(
+        #     size=(n_particles, self.particle_depth))
+        # 입력받은 파티클의 개수 * 검색할 차원의 크기 만큼의 속도를 무작위로 초기화
+        # 최대 사이즈로 전역 최적갑 저장 - global best
+        self.g_best = self.model.get_weights()      # 전역 최적값(최적의 가중치)
+        self.p_best = self.particles_weights            # 각 파티클의 최적값(최적의 가중치)
+        self.p_best_score = [0 for i in range(
+            n_particles)]  # 각 파티클의 최적값의 점수
+        self.g_best_score = 0                  # 전역 최적값의 점수(초기화 - 무한대)
+        self.g_history = []
+        self.g_best_score_history = []
+        self.history = []
+
+    def _update_weights(self, weights, v):
+        """
+        Update particle position
+
+        Args:
+            weights (array-like) : 파티클의 현재 가중치
+            v (array-like) : 가중치의 속도
+
+        Returns:
+            (array-like) : 파티클의 새로운 가중치(위치)
+        """
+        # w = np.array(w)  # 각 파티클의 위치
+        # v = np.array(v)  # 각 파티클의 속도(방향과 속력을 가짐)
+        # print(f"len(w) > {len(w)}")
+        # print(f"len(v) > {len(v)}")
+        new_weights = [0 for i in range(len(weights))]
+        for i in range(len(weights)):
+            # print(f"shape > w : {np.shape(w[i])}, v : {np.shape(v[i])}")
+            new_weights[i] = tf.add(weights[i], v[i])
+        # new_w = tf.add(w, v)   # 각 파티클을 랜덤한 속도만큼 진행
+        return new_weights    # 진행한 파티클들의 위치를 반환
+
+    def _update_velocity(self, weights, v, p_best, c0=0.5, c1=1.5, w=0.75):
+        """
+            Update particle velocity
+
+            Args:
+                weights (array-like) : 파티클의 현재 가중치
+                v (array-like) : 속도
+                p_best(array-like) : 각 파티클의 최적의 위치 (최적의 가중치)
+                c0 (float) : 인지 스케일링 상수 (가중치의 중요도 - 지역) - 지역 관성
+                c1 (float) : 사회 스케일링 상수 (가중치의 중요도 - 전역) - 전역 관성
+                w (float) : 관성 상수 (현재 속도의 중요도)
+
+            Returns:
+                (array-like) : 각 파티클의 새로운 속도
+        """
+        # x = np.array(x)
+        # v = np.array(v)
+        # assert np.shape(weights) == np.shape(v), "Position and velocity must have same shape."
+        # 두 데이터의 shape 이 같지 않으면 오류 출력
+        # 0에서 1사이의 숫자를 랜덤 생성
+        r0 = np.random.rand()
+        r1 = np.random.rand()
+        # print(f"type > weights : {type(weights)}")
+        # print(f"type > v : {type(v)}")
+        # print(
+        # f"shape > weights : {np.shape(weights[0])}, v : {np.shape(v[0])}")
+        # print(f"len > weights : {len(weights)}, v : {len(v)}")
+        # p_best = np.array(p_best)
+        # g_best = np.array(g_best)
+
+        # 가중치(상수)*속도 + \
+        # 스케일링 상수*랜덤 가중치*(나의 최적값 - 처음 위치) + \
+        # 전역 스케일링 상수*랜덤 가중치*(전체 최적값 - 처음 위치)
+        # for i, layer in enumerate(weights):
+        new_velocity = [None] * len(weights)
+        for i, layer in enumerate(weights):
+
+            new_v = w*v[i]
+            new_v = new_v + c0*r0*(p_best[i] - layer)
+            new_v = new_v + c1*r1*(self.g_best[i] - layer)
+            new_velocity[i] = new_v
+
+            # m2 = tf.multiply(tf.multiply(c0, r0),
+            #  tf.subtract(p_best[i], layer))
+            # m3 = tf.multiply(tf.multiply(c1, r1),
+            #  tf.subtract(g_best[i], layer))
+            # new_v[i] = tf.add(m1, tf.add(m2, m3))
+            # new_v[i] = tf.add_n([m1, m2, m3])
+            # new_v[i] = tf.add_n(
+            # tf.multiply(w, v[i]),
+            # tf.multiply(tf.multiply(c0, r0),
+            # tf.subtract(p_best[i], layer)),
+            # tf.multiply(tf.multiply(c1, r1),
+            # tf.subtract(g_best[i], layer)))
+        # new_v = w*v + c0*r0*(p_best - weights) + c1*r1*(g_best - weights)
+        return new_velocity
+
+    def _get_score(self, x, y):
+        """
+        Compute the score of the current position of the particles.
+
+        Args:
+            x (array-like): The current position of the particles
+            y (array-like): The current position of the particles
+        Returns:
+            (array-like) : 추론에 대한 점수
+        """
+        #  = self.model
+        # model.set_weights(weights)
+        score = self.model.evaluate(x, y, verbose=0)
+
+        return score
+
+    def optimize(self, x_train, y_train, x_test, y_test, maxiter=10, epochs=1, batch_size=32, c0=0.5, c1=1.5, w=0.75):
+        """
+        Run the PSO optimization process utill the stoping critera is met.
+        Cas for minization. The aim is to minimize the cost function
+
+        Args:
+            maxiter (int): the maximum number of iterations before stopping the optimization
+            파티클의 최종 위치를 위한 반복 횟수
+        Returns:
+            The best solution found (array-like)
+        """
+        for _ in range(maxiter):
+            loss = 0
+            acc = 1e-10
+            for i in tqdm(range(self.n_particles), desc=f"Iter {_}/{maxiter} | acc avg {round(acc/(_+1) ,4)}", ascii=True):
+                weights = self.particles_weights[i]  # 각 파티클 추출
+                v = self.velocities[i]    # 각 파티클의 다음 속도 추출
+                p_best = self.p_best[i]   # 결과치 저장할 변수 지정
+                # 2. 속도 계산
+                self.velocities[i] = self._update_velocity(
+                    weights, v, p_best, c0, c1, w)
+                # 다음에 움직일 속도 = 최초 위치, 현재 속도, 현재 위치, 최종 위치
+                # 3. 위치 업데이트
+                self.particles_weights[i] = self._update_weights(weights, v)
+                # 현재 위치 = 최초 위치 현재 속도
+                # Update the besst position for particle i
+                # 내 현재 위치가 내 위치의 최소치보다 작으면 갱신
+                self.model.set_weights(self.particles_weights[i].copy())
+                self.model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size,
+                   verbose=0, validation_data=(x_test, y_test))
+                self.particles_weights[i] = self.model.get_weights()
+                # 4. 평가
+                self.model.compile(loss=self.loss_method,
+                                   optimizer='adam', metrics=['accuracy'])
+                score = self._get_score(x_test, y_test)
+                # print(score)
+
+                # print(f"score : {score}")
+                # print(f"loss : {loss}")
+                # print(f"p_best_score : {self.p_best_score[i]}")
+
+                if score[1] > self.p_best_score[i]:
+                    self.p_best_score[i] = score[1]
+                    self.p_best[i] = self.particles_weights[i].copy()
+                    if score[1] > self.g_best_score:
+                        self.g_best_score = score[1]
+                        self.g_best = self.particles_weights[i].copy()
+                        self.g_history.append(self.g_best)
+                        self.g_best_score_history.append(
+                            self.g_best_score)
+
+                self.score = score[1]
+                loss = loss + score[0]
+                acc = acc + score[1]
+                # if self.func(self.particles_weights[i]) < self.func(p_best):
+                # self.p_best[i] = self.particles_weights[i]
+                # if self.
+                # Update the best position overall
+                # 내 현재 위치가 전체 위치 최소치보다 작으면 갱신
+                # if self.func(self.particles_weights[i]) < self.func(self.g_best):
+                # self.g_best = self.particles_weights[i]
+                # self.g_history.append(self.g_best)
+                # print(f"{i} particle score : {score[0]}")
+            print(
+                f"loss avg : {loss/self.n_particles} | acc avg : {acc/self.n_particles} | best loss : {self.g_best_score}")
+
+            # self.history.append(self.particles_weights.copy())
+
+        # 전체 최소 위치, 전체 최소 벡터
+        return self.g_best, self._get_score(x_test, y_test)
+
+    """
+    Returns:
+        현재 전체 위치
+    """
+
+    def position(self):
+        return self.particles_weights.copy()
+
+    """
+    Returns:
+        전체 위치 벡터 history
+    """
+
+    def position_history(self):
+        return self.history.copy()
+
+    """
+    Returns:
+        global best 의 갱신된 값의 변화를 반환
+    """
+
+    def global_history(self):
+        return self.g_history.copy()
+
+    """
+    Returns:
+        global best score 의 갱신된 값의 변화를 반환
+    """
+
+    def global_score_history(self):
+        return self.g_best_score_history.copy()

pso_tf.py

@@ -9,7 +9,7 @@ class PSO(object):
     Class implementing PSO algorithm
     """
 
-    def __init__(self, model, loss_method=keras.losses.MeanSquaredError(), optimizer=keras.optimizers.SGD(), n_particles=5):
+    def __init__(self, model: keras.models, x_train, y_train, loss_method=keras.losses.MeanSquaredError(), n_particles=5):
         """
         Initialize the key variables.
 
@@ -22,7 +22,6 @@ class PSO(object):
         self.model = model                      # 모델
         self.n_particles = n_particles          # 파티클의 개수
         self.loss_method = loss_method          # 손실 함수
-        self.optimizer = optimizer              # 최적화 함수
         self.model_structure = self.model.to_json()  # 모델의 구조
         self.init_weights = self.model.get_weights()          # 검색할 차원
         self.particle_depth = len(self.model.get_weights())    # 검색할 차원의 깊이
@@ -30,9 +29,12 @@ class PSO(object):
         for _ in tqdm(range(self.n_particles), desc="init particles position"):
             # particle_node = []
             m = keras.models.model_from_json(self.model_structure)
-            m.compile(loss=self.loss_method, optimizer=self.optimizer)
+            m.compile(loss=self.loss_method,
-
+                      optimizer="adam", metrics=["accuracy"])
+            # m.fit(x_train, y_train, epochs=1, batch_size=32, verbose=0) # 결과가 너무 좋지 않아서 처음 초기화 할때 어느정도 위치를 수정
             self.particles_weights[_] = m.get_weights()
+            # print(f"shape > {self.particles_weights[_][0]}")
+       
 
             # self.particles_weights.append(particle_node)
 
@@ -72,10 +74,12 @@ class PSO(object):
         # 최대 사이즈로 전역 최적갑 저장 - global best
         self.g_best = self.model.get_weights()      # 전역 최적값(최적의 가중치)
         self.p_best = self.particles_weights            # 각 파티클의 최적값(최적의 가중치)
-        self.p_best_score = [np.inf for i in range(
+        self.p_best_score = [0 for i in range(
             n_particles)]  # 각 파티클의 최적값의 점수
-        self.g_best_score = np.inf                  # 전역 최적값의 점수(초기화 - 무한대)
+        self.g_best_score = 0                  # 전역 최적값의 점수(초기화 - 무한대)
         self.g_history = []
+        self.all_cost_history = [[] for i in range(n_particles)]
+        self.g_best_score_history = []
         self.history = []
 
     def _update_weights(self, weights, v):
@@ -139,12 +143,13 @@ class PSO(object):
 
             new_v = w*v[i]
             new_v = new_v + c0*r0*(p_best[i] - layer)
+            new_v = new_v + c1*r1*(self.g_best[i] - layer)
+            new_velocity[i] = new_v
+
             # m2 = tf.multiply(tf.multiply(c0, r0),
             #  tf.subtract(p_best[i], layer))
-            new_v = new_v + c1*r1*(self.g_best[i] - layer)
             # m3 = tf.multiply(tf.multiply(c1, r1),
             #  tf.subtract(g_best[i], layer))
-            new_velocity[i] = new_v
             # new_v[i] = tf.add(m1, tf.add(m2, m3))
             # new_v[i] = tf.add_n([m1, m2, m3])
             # new_v[i] = tf.add_n(
@@ -172,7 +177,7 @@ class PSO(object):
 
         return score
 
-    def optimize(self, x_train, y_train, x_test, y_test, maxiter=20, epoch=10, verbose=0):
+    def optimize(self, x_train, y_train, x_test, y_test, maxiter=10, c0=0.5, c1=1.5, w=0.75):
         """
         Run the PSO optimization process utill the stoping critera is met.
         Cas for minization. The aim is to minimize the cost function
@@ -186,40 +191,45 @@ class PSO(object):
         for _ in range(maxiter):
             loss = 0
             acc = 0
-            for i in tqdm(range(self.n_particles), desc=f"Iteration {_} / {maxiter}", ascii=True):
+            for i in tqdm(range(self.n_particles), desc=f"Iter {_}/{maxiter}", ascii=True):
                 weights = self.particles_weights[i]  # 각 파티클 추출
                 v = self.velocities[i]    # 각 파티클의 다음 속도 추출
                 p_best = self.p_best[i]   # 결과치 저장할 변수 지정
+                # 2. 속도 계산
                 self.velocities[i] = self._update_velocity(
-                    weights, v, p_best)
+                    weights, v, p_best, c0, c1, w)
                 # 다음에 움직일 속도 = 최초 위치, 현재 속도, 현재 위치, 최종 위치
+                # 3. 위치 업데이트
                 self.particles_weights[i] = self._update_weights(weights, v)
                 # 현재 위치 = 최초 위치 현재 속도
                 # Update the besst position for particle i
                 # 내 현재 위치가 내 위치의 최소치보다 작으면 갱신
-
+                self.model.set_weights(self.particles_weights[i].copy())
-                self.model.set_weights(self.particles_weights[i])
+                # self.model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size,
-                self.model.fit(x_train, y_train, epochs=epoch,
+                #    verbose=0, validation_data=(x_test, y_test))
-                               verbose=0, validation_data=(x_test, y_test))
+                # self.particles_weights[i] = self.model.get_weights()
-                self.particles_weights[i] = self.model.get_weights()
+                # 4. 평가
-
+                self.model.compile(loss=self.loss_method,
+                                   optimizer='adam', metrics=['accuracy'])
                 score = self._get_score(x_test, y_test)
+                # print(score)
 
                 # print(f"score : {score}")
                 # print(f"loss : {loss}")
                 # print(f"p_best_score : {self.p_best_score[i]}")
 
-                if score[0] < self.p_best_score[i]:
+                if score[1] > self.p_best_score[i]:
-                    self.p_best_score[i] = score[0]
+                    self.p_best_score[i] = score[1]
-                    self.p_best[i] = self.particles_weights[i]
+                    self.p_best[i] = self.particles_weights[i].copy()
-                    if score[0] < self.g_best_score:
+                    if score[1] > self.g_best_score:
-                        self.g_best_score = score[0]
+                        self.g_best_score = score[1]
                         self.g_best = self.particles_weights[i].copy()
-                        self.g_history.append(self.g_best.copy())
+                        self.g_history.append(self.g_best)
+                        self.g_best_score_history.append(
+                            self.g_best_score)
 
-                self.score = score[0]
+                self.score = score
-                loss = score[0]
+                self.all_cost_history[i].append(score)
-                acc = score[1]
                 # if self.func(self.particles_weights[i]) < self.func(p_best):
                 # self.p_best[i] = self.particles_weights[i]
                 # if self.
@@ -229,7 +239,8 @@ class PSO(object):
                 # self.g_best = self.particles_weights[i]
                 # self.g_history.append(self.g_best)
                 # print(f"{i} particle score : {score[0]}")
-            print(f"loss : {loss} | acc : {acc}")
+            print(
+                f"loss avg : {self.score[0]/self.n_particles} | acc avg : {self.score[1]/self.n_particles} | best loss : {self.g_best_score}")
 
             # self.history.append(self.particles_weights.copy())
 
@@ -259,3 +270,14 @@ class PSO(object):
 
     def global_history(self):
         return self.g_history.copy()
+
+    """
+    Returns:
+        global best score 의 갱신된 값의 변화를 반환
+    """
+
+    def global_score_history(self):
+        return self.g_best_score_history.copy()
+    
+    def all_cost(self):
+        return self.all_cost_history.copy()

pso_tuning.py

@@ -0,0 +1,155 @@
+# %%
+import json
+from tqdm import tqdm
+from datetime import date
+import matplotlib.pyplot as plt
+import numpy as np
+from PSO.pso_bp import PSO
+from keras import backend as K
+from keras.layers import Conv2D, MaxPooling2D
+from keras.layers import Dense, Dropout, Flatten
+from keras.models import Sequential
+from keras.datasets import mnist
+from tensorflow import keras
+import tensorflow as tf
+import os
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+
+tf.random.set_seed(777)  # for reproducibility
+
+
+print(tf.__version__)
+print(tf.config.list_physical_devices())
+
+
+def get_data():
+    (x_train, y_train), (x_test, y_test) = mnist.load_data()
+
+    x_train, x_test = x_train / 255.0, x_test / 255.0
+    x_train = x_train.reshape((60000, 28, 28, 1))
+    x_test = x_test.reshape((10000, 28, 28, 1))
+
+    print(f"x_train : {x_train[0].shape} | y_train : {y_train[0].shape}")
+    print(f"x_test : {x_test[0].shape} | y_test : {y_test[0].shape}")
+    return x_train, y_train, x_test, y_test
+
+
+def make_model():
+    model = Sequential()
+    model.add(Conv2D(32, kernel_size=(5, 5),
+              activation='relu', input_shape=(28, 28, 1)))
+    model.add(MaxPooling2D(pool_size=(3, 3)))
+    model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))
+    model.add(MaxPooling2D(pool_size=(2, 2)))
+    model.add(Dropout(0.25))
+    model.add(Flatten())
+    model.add(Dense(128, activation='relu'))
+    model.add(Dense(10, activation='softmax'))
+
+    model.compile(loss='sparse_categorical_crossentropy',
+                  optimizer='adam', metrics=['accuracy'])
+
+    # model.summary()
+
+    return model
+
+
+# %%
+'''
+optimizer parameter
+'''
+lr = 0.1
+momentun = 0.8
+decay = 1e-04
+nestrov = True
+
+'''
+pso parameter
+'''
+n_particles = 100
+maxiter = 500
+# epochs = 1
+w = 0.8
+c0 = 0.6
+c1 = 1.6
+
+def auto_tuning():
+    x_train, y_train, x_test, y_test = get_data()
+    model = make_model()
+
+    loss = keras.losses.MeanSquaredError()
+    optimizer = keras.optimizers.SGD(lr=lr, momentum=momentun, decay=decay, nesterov=nestrov)
+
+
+    pso_m = PSO(model=model, loss_method=loss, n_particles=n_particles)
+    # c0 : 지역 최적값 중요도
+    # c1 : 전역 최적값 중요도
+    # w : 관성 (현재 속도를 유지하는 정도)
+    best_weights, score = pso_m.optimize(x_train, y_train, x_test, y_test, maxiter=maxiter, c0=c0, c1=c1, w=w)
+    model.set_weights(best_weights)
+
+    score_ = model.evaluate(x_test, y_test, verbose=2)
+    print(f" Test loss: {score_}")
+    score = round(score_[0]*100, 2)
+
+    day = date.today().strftime("%Y-%m-%d")
+
+    model.save(f'./model/{day}_{score}_mnist.h5')
+    json_save = {
+        "name" : f"{day}_{score}_mnist.h5",
+        "score" : score_,
+        "maxiter" : maxiter,
+        "c0" : c0,
+        "c1" : c1,
+        "w" : w    
+    }
+    with open(f'./model/{day}_{score}_bp_mnist.json', 'a') as f:
+        json.dump(json_save, f)
+        f.write(',\n')
+                    
+    return model
+auto_tuning()
+
+
+# %%
+# print(f"정답 > {y_test}")
+def get_score(model):
+    x_train, y_train, x_test, y_test = get_data()
+
+    predicted_result = model.predict(x_test)
+    predicted_labels = np.argmax(predicted_result, axis=1)
+    not_correct = []
+    for i in tqdm(range(len(y_test)), desc="진행도"):
+        if predicted_labels[i] != y_test[i]:
+            not_correct.append(i)
+            # print(f"추론 > {predicted_labels[i]} | 정답 > {y_test[i]}")
+
+    print(f"틀린 갯수 > {len(not_correct)}/{len(y_test)}")
+
+    for i in range(3):
+        plt.imshow(x_test[not_correct[i]].reshape(28, 28), cmap='Greys')
+    plt.show()
+
+# %%
+
+
+def default_mnist(epochs=5):
+    x_train, y_train, x_test, y_test = get_data()
+    model = make_model()
+
+    hist = model.fit(x_train, y_train, epochs=epochs, batch_size=32, verbose=1)
+    print(hist.history['loss'][-1])
+    print(hist.history['accuracy'][-1])
+
+    predicted_result = model.predict(x_test)
+    predicted_labels = np.argmax(predicted_result, axis=1)
+    not_correct = []
+    for i in tqdm(range(len(y_test)), desc="진행도"):
+        if predicted_labels[i] != y_test[i]:
+            not_correct.append(i)
+            # print(f"추론 > {predicted_labels[i]} | 정답 > {y_test[i]}")
+
+    print(f"틀린 갯수 > {len(not_correct)}/{len(y_test)}")
+
+
+# %%

readme.md

@@ -24,11 +24,14 @@ pso 알고리즘을 사용하여 새로운 학습 방법을 찾는중 입니다
 ## 1. PSO 알고리즘 구현
 
 ```plain text
-pso.py  # PSO 알고리즘 구현
+pso_meta.py  # PSO 알고리즘 구현
 pso_tf.py # tensorflow 모델을 이용가능한 PSO 알고리즘 구현
+pso_bp.py # 오차역전파 함수를 최적화하는 PSO 알고리즘 구현 - 성능이 99% 이상으로 나오나 목적과 다름
+pso_tuning.py # pso 알고리즘의 하이퍼 파라미터를 자동으로 튜닝하는 파일
 
 xor.ipynb # xor 문제를 pso 알고리즘으로 풀이
 mnist.ipynb # mnist 문제를 pso 알고리즘으로 풀이
+mnist.py # mnist 문제를 pso 알고리즘으로 풀이 - shell 실행용
 ```
 
 ## 2. PSO 알고리즘을 이용한 최적화 문제 풀이
@@ -44,10 +47,17 @@ pso 알고리즘을 이용하여 오차역전파 함수를 최적화 하는 방
 
    2-2. 지역 최적값을 찾았다면, 전역 최적값을 찾을 때까지 1~2 과정을 반복합니다
 
-3. 전역 최적값이 특정 임계치에서 변화율이 적다면 학습을 종료합니다
+3. 전역 최적값이 특정 임계치에서 변화율이 적다면 학습을 종료합니다 - 현재 결과가 정확도가 높지 않아서 이 기능은 추후에 추가할 예정입니다
+
+### 현재 문제
+
+> 딥러닝 알고리즘 특성상 weights는 처음 컴파일시 무작위하게 생성된다. weights의 각 지점의 중요도는 매번 무작위로 정해지기에 전역 최적값으로 찾아갈 때 값이 높은 loss를 향해서 상승하는 현상이 나타난다.
+> <br>
+> 따라서 weights의 이동 방법을 더 탐구하거나, weights를 초기화 할때 random 중요도를 좀더 노이즈가 적게 생성하는 방향을 모색해야할 것 같다.
 
 ### 개인적인 생각
 
 > 머신러닝 분류 방식에 존재하는 random forest 방식을 이용하여, 오차역전파 함수를 최적화 하는 방법이 있을것 같습니다
+> <br>
 >
 > > pso 와 random forest 방식이 매우 유사하다고 생각하여 학습할 때 뿐만 아니라 예측 할 때도 이러한 방식으로 사용할 수 있을 것 같습니다

xor.ipynb

@@ -2,18 +2,11 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 13,
    "metadata": {
     "tags": []
    },
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-05-21 01:52:28.471404: E tensorflow/stream_executor/cuda/cuda_blas.cc:2981] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -55,7 +48,7 @@
     "    model = Sequential(leyer)\n",
     "\n",
     "    sgd = keras.optimizers.SGD(lr=0.1, momentum=1, decay=1e-05, nesterov=True)\n",
-    "    adam = keras.optimizers.Adam(lr=0.1, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.)\n",
+    "    # adam = keras.optimizers.Adam(lr=0.1, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.)\n",
     "    model.compile(loss='mse', optimizer=sgd, metrics=['accuracy'])\n",
     "\n",
     "    print(model.summary())\n",
@@ -65,238 +58,185 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Model: \"sequential\"\n",
+      "Model: \"sequential_11\"\n",
       "_________________________________________________________________\n",
       " Layer (type)                Output Shape              Param #   \n",
       "=================================================================\n",
-      " dense (Dense)               (None, 2)                 6         \n",
+      " dense_22 (Dense)            (None, 2)                 6         \n",
       "                                                                 \n",
-      " dense_1 (Dense)             (None, 1)                 3         \n",
+      " dense_23 (Dense)            (None, 1)                 3         \n",
       "                                                                 \n",
       "=================================================================\n",
       "Total params: 9\n",
       "Trainable params: 9\n",
       "Non-trainable params: 0\n",
-      "_________________________________________________________________\n"
+      "_________________________________________________________________\n",
+      "None\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/pieroot/miniconda3/envs/pso/lib/python3.8/site-packages/keras/optimizers/optimizer_v2/gradient_descent.py:111: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
+      "init particles position: 100%|██████████| 15/15 [00:00<00:00, 85.12it/s]\n",
-      "  super().__init__(name, **kwargs)\n",
+      "init velocities: 100%|██████████| 15/15 [00:00<00:00, 46465.70it/s]\n",
-      "/home/pieroot/miniconda3/envs/pso/lib/python3.8/site-packages/keras/optimizers/optimizer_v2/adam.py:114: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
+      "Iteration 0 / 10: 100%|##########| 15/15 [00:05<00:00,  2.63it/s]\n"
-      "  super().__init__(name, **kwargs)\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "None\n",
+      "loss : 0.2620863338311513 | acc : 0.5 | best loss : 0.24143654108047485\n"
-      "0 particle score : 0.24921603500843048\n",
+     ]
-      "1 particle score : 0.2509610056877136\n",
+    },
-      "2 particle score : 0.28712478280067444\n",
+    {
-      "3 particle score : 0.2665291726589203\n",
+     "name": "stderr",
-      "4 particle score : 0.2513682246208191\n",
+     "output_type": "stream",
-      "0 particle score : 0.26079031825065613\n",
+     "text": [
-      "1 particle score : 0.24931921064853668\n",
+      "Iteration 1 / 10: 100%|##########| 15/15 [00:05<00:00,  2.69it/s]\n"
-      "2 particle score : 0.2679133415222168\n",
+     ]
-      "3 particle score : 0.27925199270248413\n",
+    },
-      "4 particle score : 0.2605195641517639\n",
+    {
-      "0 particle score : 0.30758577585220337\n",
+     "name": "stdout",
-      "1 particle score : 0.26747316122055054\n",
+     "output_type": "stream",
-      "2 particle score : 0.36957648396492004\n",
+     "text": [
-      "3 particle score : 0.19372068345546722\n",
+      "loss : 0.24147300918896994 | acc : 0.6333333333333333 | best loss : 0.20360520482063293\n"
-      "4 particle score : 0.3671383857727051\n",
+     ]
-      "0 particle score : 0.24090810120105743\n",
+    },
-      "1 particle score : 0.3176509141921997\n",
+    {
-      "2 particle score : 0.23225924372673035\n",
+     "name": "stderr",
-      "3 particle score : 0.37263113260269165\n",
+     "output_type": "stream",
-      "4 particle score : 0.47822105884552\n",
+     "text": [
-      "0 particle score : 0.37611791491508484\n",
+      "Iteration 2 / 10: 100%|##########| 15/15 [00:05<00:00,  2.72it/s]\n"
-      "1 particle score : 0.27166277170181274\n",
+     ]
-      "2 particle score : 0.21416285634040833\n",
+    },
-      "3 particle score : 0.23324625194072723\n",
+    {
-      "4 particle score : 0.024583835154771805\n",
+     "name": "stdout",
-      "0 particle score : 0.05194556713104248\n",
+     "output_type": "stream",
-      "1 particle score : 0.3102635443210602\n",
+     "text": [
-      "2 particle score : 0.31894028186798096\n",
+      "loss : 0.211648628115654 | acc : 0.65 | best loss : 0.17383326590061188\n"
-      "3 particle score : 0.12679985165596008\n",
+     ]
-      "4 particle score : 0.012038745917379856\n",
+    },
-      "0 particle score : 0.004551469348371029\n",
+    {
-      "1 particle score : 0.03923884406685829\n",
+     "name": "stderr",
-      "2 particle score : 0.003701586974784732\n",
+     "output_type": "stream",
-      "3 particle score : 0.0026527238078415394\n",
+     "text": [
-      "4 particle score : 0.0430503748357296\n",
+      "Iteration 3 / 10: 100%|##########| 15/15 [00:05<00:00,  2.72it/s]\n"
-      "0 particle score : 0.000214503234019503\n",
+     ]
-      "1 particle score : 0.0025649480521678925\n",
+    },
-      "2 particle score : 0.008843829855322838\n",
+    {
-      "3 particle score : 0.23036976158618927\n",
+     "name": "stdout",
-      "4 particle score : 0.21686825156211853\n",
+     "output_type": "stream",
-      "0 particle score : 4.901693273495766e-07\n",
+     "text": [
-      "1 particle score : 0.003860481781885028\n",
+      "loss : 0.21790608167648315 | acc : 0.6833333333333333 | best loss : 0.16785581409931183\n"
-      "2 particle score : 0.00047884139348752797\n",
+     ]
-      "3 particle score : 0.1563722789287567\n",
+    },
-      "4 particle score : 1.1759411222556082e-07\n",
+    {
-      "0 particle score : 0.24969959259033203\n",
+     "name": "stderr",
-      "1 particle score : 2.8646991268033162e-05\n",
+     "output_type": "stream",
-      "2 particle score : 1.0552450024903237e-09\n",
+     "text": [
-      "3 particle score : 3.566808572941227e-07\n",
+      "Iteration 4 / 10: 100%|##########| 15/15 [00:05<00:00,  2.73it/s]\n"
-      "4 particle score : 8.882947003831243e-14\n",
+     ]
-      "0 particle score : 0.2497878521680832\n",
+    },
-      "1 particle score : 1.879385969766334e-12\n",
+    {
-      "2 particle score : 0.44945281744003296\n",
+     "name": "stdout",
-      "3 particle score : 2.485284791549705e-14\n",
+     "output_type": "stream",
-      "4 particle score : 2.431787924306583e-26\n",
+     "text": [
-      "0 particle score : 3.854774978241029e-18\n",
+      "loss : 0.20557119349638622 | acc : 0.7333333333333333 | best loss : 0.16668711602687836\n"
-      "1 particle score : 1.2515056546646974e-08\n",
+     ]
-      "2 particle score : 0.49999988079071045\n",
+    },
-      "3 particle score : 2.8881452344524906e-22\n",
+    {
-      "4 particle score : 4.162688806996304e-30\n",
+     "name": "stderr",
-      "0 particle score : 9.170106118851775e-37\n",
+     "output_type": "stream",
-      "1 particle score : 0.49933725595474243\n",
+     "text": [
-      "2 particle score : 0.43209874629974365\n",
+      "Iteration 5 / 10: 100%|##########| 15/15 [00:05<00:00,  2.68it/s]\n"
-      "3 particle score : 7.681456478781658e-30\n",
+     ]
-      "4 particle score : 1.1656278206215614e-33\n",
+    },
-      "0 particle score : 0.0\n",
+    {
-      "1 particle score : 0.49545660614967346\n",
+     "name": "stdout",
-      "2 particle score : 0.25\n",
+     "output_type": "stream",
-      "3 particle score : 0.0\n",
+     "text": [
-      "4 particle score : 0.0\n",
+      "loss : 0.20823073089122773 | acc : 0.7 | best loss : 0.16668711602687836\n"
-      "0 particle score : 0.0\n",
+     ]
-      "1 particle score : 0.25\n",
+    },
-      "2 particle score : 0.25\n",
+    {
-      "3 particle score : 0.25\n",
+     "name": "stderr",
-      "4 particle score : 0.25\n",
+     "output_type": "stream",
-      "0 particle score : 0.0\n",
+     "text": [
-      "1 particle score : 0.0\n",
+      "Iteration 6 / 10: 100%|##########| 15/15 [00:05<00:00,  2.53it/s]\n"
-      "2 particle score : 0.25\n",
+     ]
-      "3 particle score : 0.25\n",
+    },
-      "4 particle score : 0.25\n",
+    {
-      "0 particle score : 0.0\n",
+     "name": "stdout",
-      "1 particle score : 0.25\n",
+     "output_type": "stream",
-      "2 particle score : 0.25\n",
+     "text": [
-      "3 particle score : 0.25\n",
+      "loss : 0.21380058924357095 | acc : 0.7166666666666667 | best loss : 0.16668711602687836\n"
-      "4 particle score : 0.25\n",
+     ]
-      "0 particle score : 0.0\n",
+    },
-      "1 particle score : 0.0\n",
+    {
-      "2 particle score : 0.0\n",
+     "name": "stderr",
-      "3 particle score : 0.0\n",
+     "output_type": "stream",
-      "4 particle score : 0.5\n",
+     "text": [
-      "0 particle score : 1.2923532081356227e-22\n",
+      "Iteration 7 / 10: 100%|##########| 15/15 [00:06<00:00,  2.30it/s]\n"
-      "1 particle score : 0.5\n",
+     ]
-      "2 particle score : 0.25\n",
+    },
-      "3 particle score : 0.942779541015625\n",
+    {
-      "4 particle score : 0.5\n",
+     "name": "stdout",
-      "0 particle score : 0.4959273338317871\n",
+     "output_type": "stream",
-      "1 particle score : 0.5\n",
+     "text": [
-      "2 particle score : 0.5\n",
+      "loss : 0.2561836312214533 | acc : 0.6833333333333333 | best loss : 0.16667115688323975\n"
-      "3 particle score : 0.75\n",
+     ]
-      "4 particle score : 0.75\n",
+    },
-      "0 particle score : 0.23154164850711823\n",
+    {
-      "1 particle score : 0.5\n",
+     "name": "stderr",
-      "2 particle score : 0.5\n",
+     "output_type": "stream",
-      "3 particle score : 0.5\n",
+     "text": [
-      "4 particle score : 0.5\n",
+      "Iteration 8 / 10: 100%|##########| 15/15 [00:05<00:00,  2.55it/s]\n"
-      "0 particle score : 0.0\n",
+     ]
-      "1 particle score : 0.5\n",
+    },
-      "2 particle score : 0.25\n",
+    {
-      "3 particle score : 0.0\n",
+     "name": "stdout",
-      "4 particle score : 0.25\n",
+     "output_type": "stream",
-      "0 particle score : 0.0\n",
+     "text": [
-      "1 particle score : 0.5\n",
+      "loss : 0.30372582376003265 | acc : 0.65 | best loss : 0.16667115688323975\n"
-      "2 particle score : 0.25\n",
+     ]
-      "3 particle score : 0.25\n",
+    },
-      "4 particle score : 0.25\n",
+    {
-      "0 particle score : 0.25\n",
+     "name": "stderr",
-      "1 particle score : 0.25\n",
+     "output_type": "stream",
-      "2 particle score : 0.25\n",
+     "text": [
-      "3 particle score : 0.25\n",
+      "Iteration 9 / 10: 100%|##########| 15/15 [00:05<00:00,  2.65it/s]"
-      "4 particle score : 0.25\n",
+     ]
-      "0 particle score : 0.0\n",
+    },
-      "1 particle score : 0.25\n",
+    {
-      "2 particle score : 0.25\n",
+     "name": "stdout",
-      "3 particle score : 0.25\n",
+     "output_type": "stream",
-      "4 particle score : 0.25\n",
+     "text": [
-      "0 particle score : 0.5760642290115356\n",
+      "loss : 0.281868569056193 | acc : 0.7 | best loss : 0.16667115688323975\n",
-      "1 particle score : 0.25\n",
+      "1/1 [==============================] - 0s 26ms/step\n",
-      "2 particle score : 0.25000467896461487\n",
+      "[[0.        ]\n",
-      "3 particle score : 0.5\n",
+      " [0.66422266]\n",
-      "4 particle score : 0.5\n",
+      " [0.6642227 ]\n",
-      "0 particle score : 0.5\n",
+      " [0.6642227 ]]\n",
-      "1 particle score : 0.25\n",
-      "2 particle score : 0.4998854398727417\n",
-      "3 particle score : 0.5\n",
-      "4 particle score : 0.5\n",
-      "0 particle score : 0.5\n",
-      "1 particle score : 0.25\n",
-      "2 particle score : 0.5000014305114746\n",
-      "3 particle score : 0.5\n",
-      "4 particle score : 0.5\n",
-      "0 particle score : 0.5\n",
-      "1 particle score : 0.007790721021592617\n",
-      "2 particle score : 0.5\n",
-      "3 particle score : 0.75\n",
-      "4 particle score : 0.5\n",
-      "0 particle score : 0.25\n",
-      "1 particle score : 0.5\n",
-      "2 particle score : 0.5\n",
-      "3 particle score : 0.0\n",
-      "4 particle score : 0.5\n",
-      "1/1 [==============================] - 0s 40ms/step\n",
-      "[[1.8555788e-26]\n",
-      " [1.0000000e+00]\n",
-      " [1.0000000e+00]\n",
-      " [1.8555788e-26]]\n",
       "[[0]\n",
       " [1]\n",
       " [1]\n",
-      " [0]]\n",
+      " [0]]\n"
-      "history > [[array([[-0.9191145, -0.7256227],\n",
+     ]
-      "       [ 1.2947526,  1.0081983]], dtype=float32), array([ 0.01203067, -0.07866445], dtype=float32), array([[-0.72274315],\n",
+    },
-      "       [ 0.88691926]], dtype=float32), array([-0.08449478], dtype=float32)], [array([[-0.7327981, -2.120965 ],\n",
+    {
-      "       [ 3.5870228,  2.0618958]], dtype=float32), array([-0.06788628, -2.1460009 ], dtype=float32), array([[-1.8084345],\n",
+     "name": "stderr",
-      "       [ 3.2274616]], dtype=float32), array([0.40823892], dtype=float32)], [array([[-6.749437, -5.01979 ],\n",
+     "output_type": "stream",
-      "       [ 9.477569,  9.011221]], dtype=float32), array([ 1.0140182, -5.089527 ], dtype=float32), array([[-5.9527373],\n",
+     "text": [
-      "       [ 8.538484 ]], dtype=float32), array([0.8423419], dtype=float32)], [array([[-4.4376955, -7.542317 ],\n",
+      "\n"
-      "       [13.042126 ,  9.401183 ]], dtype=float32), array([ 1.7249748, -6.2829194], dtype=float32), array([[-4.6019  ],\n",
-      "       [12.654787]], dtype=float32), array([2.11288], dtype=float32)], [array([[-7.9655757, -8.855807 ],\n",
-      "       [14.27012  , 12.6986265]], dtype=float32), array([ 2.2102568, -7.4656196], dtype=float32), array([[-5.386531],\n",
-      "       [16.770058]], dtype=float32), array([2.2161639], dtype=float32)], [array([[-10.937471,  -9.346545],\n",
-      "       [ 15.040345,  13.547635]], dtype=float32), array([ 3.7305086, -8.93729  ], dtype=float32), array([[-9.661456],\n",
-      "       [14.314214]], dtype=float32), array([1.9838718], dtype=float32)], [array([[-7.618989 , -8.295806 ],\n",
-      "       [ 9.591193 ,  7.3881774]], dtype=float32), array([ 2.9443424, -6.85388  ], dtype=float32), array([[-6.120155],\n",
-      "       [ 9.558391]], dtype=float32), array([2.900807], dtype=float32)], [array([[-12.431582, -14.683373],\n",
-      "       [ 24.192898,  18.607504]], dtype=float32), array([  4.375762, -11.899742], dtype=float32), array([[-11.140665],\n",
-      "       [ 25.361753]], dtype=float32), array([3.5045836], dtype=float32)], [array([[-16.167437, -19.325432],\n",
-      "       [ 25.197618,  15.928284]], dtype=float32), array([  6.8536587, -14.406519 ], dtype=float32), array([[-16.149462],\n",
-      "       [ 21.955147]], dtype=float32), array([6.5853295], dtype=float32)], [array([[-20.64401 , -25.207134],\n",
-      "       [ 28.023142,  19.938404]], dtype=float32), array([  7.2551775, -17.74039  ], dtype=float32), array([[-15.623163],\n",
-      "       [ 30.90391 ]], dtype=float32), array([7.7026973], dtype=float32)], [array([[-27.585245, -28.003128],\n",
-      "       [ 46.606903,  34.010803]], dtype=float32), array([  9.391173, -25.379646], dtype=float32), array([[-27.2021 ],\n",
-      "       [ 44.79025]], dtype=float32), array([9.642486], dtype=float32)], [array([[-44.09209, -37.20285],\n",
-      "       [ 47.20231,  40.34598]], dtype=float32), array([ 13.101824, -25.8866  ], dtype=float32), array([[-33.470924],\n",
-      "       [ 47.784706]], dtype=float32), array([14.320648], dtype=float32)], [array([[-36.38443 , -39.23304 ],\n",
-      "       [ 52.953644,  38.646732]], dtype=float32), array([ 10.276208, -30.864595], dtype=float32), array([[-31.08338],\n",
-      "       [ 52.16088]], dtype=float32), array([15.342434], dtype=float32)], [array([[-62.84543 , -47.409748],\n",
-      "       [ 63.300335,  56.867214]], dtype=float32), array([ 17.78217, -33.01626], dtype=float32), array([[-48.512455],\n",
-      "       [ 61.87751 ]], dtype=float32), array([19.369736], dtype=float32)], [array([[-71.16499 , -57.702408],\n",
-      "       [ 80.223915,  69.13328 ]], dtype=float32), array([ 19.08833 , -41.566013], dtype=float32), array([[-57.950104],\n",
-      "       [ 76.35351 ]], dtype=float32), array([24.470982], dtype=float32)], [array([[-120.93972,  -92.38105],\n",
-      "       [ 107.01377,  110.19025]], dtype=float32), array([ 28.39684 , -59.285316], dtype=float32), array([[-75.1781 ],\n",
-      "       [129.59488]], dtype=float32), array([34.034805], dtype=float32)], [array([[-161.36476, -114.62916],\n",
-      "       [ 142.47905,  152.3887 ]], dtype=float32), array([ 36.139404, -74.1054  ], dtype=float32), array([[-101.517525],\n",
-      "       [ 171.30031 ]], dtype=float32), array([42.26851], dtype=float32)]]\n",
-      "score > [0.5, 0.5]\n"
      ]
     }
    ],
@@ -309,13 +249,12 @@
     "model = make_model()\n",
     "\n",
     "loss = keras.losses.MeanSquaredError()\n",
-    "optimizer = keras.optimizers.SGD(lr=0.1, momentum=1, decay=1e-05, nesterov=True)\n",
+    "optimizer = keras.optimizers.SGD(lr=0.1, momentum=0.9, decay=1e-05, nesterov=True)\n",
     "\n",
     "\n",
+    "pso_xor = PSO(model=model, loss_method=loss, optimizer=optimizer, n_particles=15)\n",
     "\n",
-    "pso_xor = PSO(model=model, loss=loss, optimizer=optimizer, n_particles=5)\n",
+    "best_weights, score = pso_xor.optimize(x, y, x_test, y_test, maxiter=10, epochs=20)\n",
-    "\n",
-    "best_weights, score = pso_xor.optimize(x, y, x_test, y_test, maxiter=30)\n",
     "\n",
     "model.set_weights(best_weights)\n",
     "\n",
@@ -330,6 +269,17 @@
     "# plt.plot(history)\n"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_test = np.array([[0, 1], [0, 0], [1, 1], [1, 0]])\n",
+    "y_pred = model.predict(x_test)\n",
+    "print(y_pred)"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -352,6 +302,26 @@
     "    return hist"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "predicted_result = model.predict(x_test)\n",
+    "predicted_labels = np.argmax(predicted_result, axis=1)\n",
+    "not_correct = []\n",
+    "for i in range(len(y_test)):\n",
+    "    if predicted_labels[i] != y_test[i]:\n",
+    "        not_correct.append(i)\n",
+    "        # print(f\"추론 > {predicted_labels[i]} | 정답 > {y_test[i]}\")\n",
+    "        \n",
+    "print(f\"틀린 것 갯수 > {len(not_correct)}\")\n",
+    "for i in range(3):\n",
+    "    plt.imshow(x_test[not_correct[i]].reshape(28,28), cmap='Greys')\n",
+    "plt.show()"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,