23-06-03

tensorflow gpu 의 메모리 용량 제한을 추가
readme에 분류 문제별 해결 현황 추가

pso/optimizer.py

@@ -16,6 +16,13 @@ from copy import copy, deepcopy
 
 from pso.particle import Particle
 
+gpus = tf.config.experimental.list_physical_devices("GPU")
+if gpus:
+    try:
+        # tf.config.experimental.set_visible_devices(gpus[0], "GPU")
+        tf.config.experimental.set_memory_growth(gpus[0], True)
+    except RuntimeError as e:
+        print(e)
 
 class Optimizer:
     """
@@ -90,7 +97,6 @@ class Optimizer:
             w_gpu = np.append(w_gpu, w_)
 
         del weights
-        gc.collect()
         return w_gpu, shape, lenght
 
     """
@@ -116,7 +122,6 @@ class Optimizer:
         del weight
         del shape
         del lenght
-        gc.collect()
 
         return weights
 
@@ -124,8 +129,6 @@ class Optimizer:
         self.model.set_weights(weights)
         self.model.compile(loss=self.loss, optimizer="sgd", metrics=["accuracy"])
         score = self.model.evaluate(x, y, verbose=0)[1]
-
-        gc.collect()
         if score > 0:
             return 1 / (1 + score)
         else:
@@ -163,6 +166,7 @@ class Optimizer:
             self.g_best_score = 0
         elif renewal == "loss":
             self.g_best_score = np.inf
+
         try:
             if save:
                 if save_path is None:
@@ -175,9 +179,9 @@ class Optimizer:
         except ValueError as e:
             print(e)
             sys.exit(1)
-        # for i, p in enumerate(self.particles):
+            
         for i in tqdm(range(self.n_particles), desc="Initializing Particles"):
-            p = copy(self.particles[i])
+            p = self.particles[i]
             local_score = p.get_score(x, y, renewal=renewal)
 
             if renewal == "acc":
@@ -190,8 +194,24 @@ class Optimizer:
                     self.g_best_score = local_score[0]
                     self.g_best = p.get_best_weights()
                     self.g_best_ = p.get_best_weights()
+
+            if local_score[0] == None:
+                local_score[0] = np.inf
+
+            if local_score[1] == None:
+                local_score[1] = 0
+                
+            if save:
+                with open(
+                    f"./{save_path}/{self.day}_{self.n_particles}_{epochs}_{self.c0}_{self.c1}_{self.w_min}_{renewal}.csv",
+                    "a",
+                ) as f:
+                    f.write(f"{local_score[0]}, {local_score[1]}")
+                    if i != self.n_particles - 1:
+                        f.write(", ")
+                    else:
+                        f.write("\n")
             del local_score
-            del p
             gc.collect()
 
         print(f"initial g_best_score : {self.g_best_score}")
@@ -266,6 +286,10 @@ class Optimizer:
                             self.g_best_score = score[0]
                             self.g_best = self.particles[i].get_best_weights()
 
+                    if score[0] == None:
+                        score[0] = np.inf
+                    if score[1] == None:
+                        score[1] = 0
                     loss = loss + score[0]
                     acc = acc + score[1]
                     if score[0] < min_loss:
@@ -295,7 +319,6 @@ class Optimizer:
                     f"loss min : {round(min_loss, 4)} | acc max : {round(max_score, 4)} | Best {renewal} : {self.g_best_score}"
                 )
 
-                gc.collect()
 
                 if check_point is not None:
                     if _ % check_point == 0:
@@ -303,6 +326,8 @@ class Optimizer:
                         self._check_point_save(f"./{save_path}/{self.day}/ckpt-{_}")
                 self.avg_score = acc / self.n_particles
 
+                gc.collect()
+                
         except KeyboardInterrupt:
             print("Ctrl + C : Stop Training")
         except MemoryError:
@@ -315,7 +340,7 @@ class Optimizer:
             self.save_info(save_path)
             print("save info")
 
-            return self.g_best, self.g_best_score
+            return self.g_best_score
 
     def get_best_model(self):
         model = keras.models.model_from_json(self.model.to_json())

pso/particle.py

@@ -12,7 +12,7 @@ class Particle:
         self.loss = loss
         init_weights = self.model.get_weights()
         i_w_, s_, l_ = self._encode(init_weights)
-        i_w_ = np.random.rand(len(i_w_)) / 5 - 0.10
+        i_w_ = np.random.rand(len(i_w_)) / 2 - 0.25
         self.velocities = self._decode(i_w_, s_, l_)
         self.negative = negative
         self.best_score = 0
@@ -40,7 +40,7 @@ class Particle:
             lenght.append(len(w_))
             # w_gpu = cp.append(w_gpu, w_)
             w_gpu = np.append(w_gpu, w_)
-        gc.collect()
+
         return w_gpu, shape, lenght
 
     """
@@ -62,7 +62,7 @@ class Particle:
         del start, end, w_
         del shape, lenght
         del weight
-        gc.collect()
+
         return weights
 
     def get_score(self, x, y, renewal: str = "acc"):
@@ -77,7 +77,7 @@ class Particle:
             if score[0] < self.best_score:
                 self.best_score = score[0]
                 self.best_weights = self.model.get_weights()
-        gc.collect()
+
         return score
 
     def _update_velocity(self, local_rate, global_rate, w, g_best):
@@ -105,7 +105,6 @@ class Particle:
         del encode_p, p_sh, p_len
         del encode_g, g_sh, g_len
         del r0, r1
-        gc.collect()
 
     def _update_velocity_w(self, local_rate, global_rate, w, w_p, w_g, g_best):
         encode_w, w_sh, w_len = self._encode(weights=self.model.get_weights())
@@ -132,7 +131,6 @@ class Particle:
         del encode_p, p_sh, p_len
         del encode_g, g_sh, g_len
         del r0, r1
-        gc.collect()
 
     def _update_weights(self):
         encode_w, w_sh, w_len = self._encode(weights=self.model.get_weights())
@@ -141,12 +139,10 @@ class Particle:
         self.model.set_weights(self._decode(new_w, w_sh, w_len))
         del encode_w, w_sh, w_len
         del encode_v, v_sh, v_len
-        gc.collect()
 
     def f(self, x, y, weights):
         self.model.set_weights(weights)
         score = self.model.evaluate(x, y, verbose=0)[1]
-        gc.collect()
         if score > 0:
             return 1 / (1 + score)
         else:
@@ -155,7 +151,6 @@ class Particle:
     def step(self, x, y, local_rate, global_rate, w, g_best, renewal: str = "acc"):
         self._update_velocity(local_rate, global_rate, w, g_best)
         self._update_weights()
-        gc.collect()
         return self.get_score(x, y, renewal)
 
     def step_w(
@@ -163,7 +158,6 @@ class Particle:
     ):
         self._update_velocity_w(local_rate, global_rate, w, w_p, w_g, g_best)
         self._update_weights()
-        gc.collect()
         return self.get_score(x, y, renewal)
 
     def get_best_score(self):