jung-geun/PSO
1
0
Fork 0
mirror of https://github.com/jung-geun/PSO.git synced 2025-12-20 04:50:45 +09:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #5 from jung-geun/jung-geun/issue2

Browse Source 
23-08-06
This commit is contained in:
jung-geun
2023-08-06 19:15:30 +09:00
committed by GitHub
parent f3b61e280f 8d558d0f26
commit e5f364c3b2
12 changed files with 201 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
README.md
View File

@@ -1,29 +1,41 @@
[![Python Package Index publish](https://github.com/jung-geun/PSO/actions/workflows/pypi.yml/badge.svg?event=push)](https://github.com/jung-geun/PSO/actions/workflows/pypi.yml) [![Python Package Index publish](https://github.com/jung-geun/PSO/actions/workflows/pypi.yml/badge.svg?event=push)](https://github.com/jung-geun/PSO/actions/workflows/pypi.yml)
### 목차
> [PSO 알고리즘 구현 및 새로운 시도](#pso-알고리즘-구현-및-새로운-시도)</br>
>
> [초기 세팅 및 사용 방법](#초기-세팅-및-사용-방법)</br>
>
> [구조 및 작동 방식](#구조-및-작동-방식)</br>
>
> [PSO 알고리즘을 이용하여 풀이한 문제들의 정확도](#pso-알고리즘을-이용하여-풀이한-문제들의-정확도)</br>
>
> [참고 자료](#참고-자료)</br>
# PSO 알고리즘 구현 및 새로운 시도 # PSO 알고리즘 구현 및 새로운 시도
pso 알고리즘을 사용하여 새로운 학습 방법을 찾는중 입니다 pso 알고리즘을 사용하여 새로운 학습 방법을 찾는중 입니다</br>
병렬처리로 사용하는 논문을 찾아보았지만 이보다 더 좋은 방법이 있을 것 같아서 찾아보고 있습니다 - \[1] 병렬처리로 사용하는 논문을 찾아보았지만 이보다 더 좋은 방법이 있을 것 같아서 찾아보고 있습니다 - [[1]](#참고-자료)</br>
기본 pso 알고리즘의 수식은 다음과 같습니다 기본 pso 알고리즘의 속도를 구하는 수식은 다음과 같습니다
> $$V_{id(t+1)} = W_{V_id(t)} + c_1 * r_1 (p_{id(t)} - x_{id(t)}) + c_2 * r_2(p_{gd(t)} - x_{id(t)})$$ > $$V_{t+1} = W_t + c_1 * r_1 * (Pbest_t - x_t) + c_2 * r_2 * (Gbest_t - x_t)$$
다음 속도을 구하는 수식입니다 다음 위치를 업데이트하는 수식입니다
> $$x_{id(t+1)} = x_{id(t)} + V_{id(t+1)}$$ > $$x_{t+1} = x_{t} + V_{t+1}$$
다음 위치를 구하는 수식입니다 다음과 같은 변수를 사용합니다
> $$ > $Pbest_t : 각 파티클의 지역 최적해$</br> $Gbest_t : 전역 최적해$</br> $W_t : 가중치$</br> $c_1, c_2 : 파라미터$</br> $r_1, r_2 : 랜덤 값$</br> $x_t : 현재 위치$</br> $V_{(t+1)} : 다음 속도$</br>
> p_{id(t+1)} =
> \begin{cases}
> x_{id(t+1)} & \text{if } f(x_{id(t+1)}) < f(p_{id(t)})\\
> p_{id(t)} & \text{otherwise}
> \end{cases}
> $$
# 초기 세팅 pso 알고리즘을 이용하여 keras 모델을 학습하는 방법을 탐구하고 있습니다</br>
현재는 xor, iris, mnist 문제를 풀어보았으며, xor 문제와 iris 문제는 100%의 정확도를 보이고 있습니다</br>
mnist 문제는 63%의 정확도를 보이고 있습니다</br>
[xor](#1-xor-문제) </br> [iris](#2-iris-문제) </br> [mnist](#3-mnist-문제)
# 초기 세팅 및 사용 방법
자동으로 conda 환경을 설정하기 위해서는 다음 명령어를 사용합니다 자동으로 conda 환경을 설정하기 위해서는 다음 명령어를 사용합니다
@@ -36,7 +48,7 @@ conda env create -f conda_env/environment.yaml
직접 설치하여 사용할 경우 pso2keras 패키지를 pypi 에서 다운로드 받아서 사용하시기 바랍니다 직접 설치하여 사용할 경우 pso2keras 패키지를 pypi 에서 다운로드 받아서 사용하시기 바랍니다
```shell ```shell
pip install pso2keras==0.1.4 pip install pso2keras
``` ```
위의 패키지를 사용하기 위해서는 tensorflow 와 tensorboard 가 설치되어 있어야 합니다 위의 패키지를 사용하기 위해서는 tensorflow 와 tensorboard 가 설치되어 있어야 합니다
@@ -52,11 +64,9 @@ pso_model.fit(...)
<a href="https://colab.research.google.com/github/jung-geun/PSO/blob/master/example/pso2mnist.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a> <a href="https://colab.research.google.com/github/jung-geun/PSO/blob/master/example/pso2mnist.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
# 현재 진행 상황 # 구조 및 작동 방식
## 1. PSO 알고리즘 구현 ## 파일 구조
### 파일 구조
```plain ```plain
|-- /conda_env # conda 환경 설정 파일 |-- /conda_env # conda 환경 설정 파일
@@ -79,22 +89,20 @@ pso_model.fit(...)
|-- requirements.txt # pypi 에서 다운로드 받을 패키지 목록 |-- requirements.txt # pypi 에서 다운로드 받을 패키지 목록
``` ```
pso 라이브러리는 tensorflow 모델을 학습하기 위해 기본 ./metacode/pso_meta.py 코드에서 수정하였습니다 [2] pso 라이브러리는 tensorflow 모델을 학습하기 위해 기본 ./metacode/pso_meta.py 코드에서 수정하였습니다 [[2]](#참고-자료)
## 2. PSO 알고리즘을 이용한 최적화 문제 풀이
pso 알고리즘을 이용하여 오차역전파 함수를 최적화 하는 방법을 찾는 중입니다 pso 알고리즘을 이용하여 오차역전파 함수를 최적화 하는 방법을 찾는 중입니다
### 알고리즘 작동 방식 ## 알고리즘 작동 방식
> 1. 파티클의 위치와 속도를 초기화 한다. > 1. 파티클의 위치와 속도를 초기화 한다.
> 2. 각 파티클의 점수를 계산한다. > 2. 각 파티클의 점수를 계산한다.
> 3. 각 파티클의 지역 최적해와 전역 최적해를 구한다. > 3. 각 파티클의 지역 최적해와 전역 최적해를 구한다.
> 4. 각 파티클의 속도를 업데이트 한다. > 4. 각 파티클의 속도를 업데이트 한다.
## 3. PSO 알고리즘을 이용하여 풀이한 문제들의 정확도 # PSO 알고리즘을 이용하여 풀이한 문제들의 정확도
### 1. xor 문제 ## 1. xor 문제
```python ```python
loss = 'mean_squared_error' loss = 'mean_squared_error'
@@ -129,7 +137,7 @@ best_score = pso_xor.fit(
위의 파라미터 기준 10 세대 근처부터 정확도가 100%가 나오는 것을 확인하였습니다 위의 파라미터 기준 10 세대 근처부터 정확도가 100%가 나오는 것을 확인하였습니다
![xor](./history_plt/xor_2_10.png) ![xor](./history_plt/xor_2_10.png)
2. iris 문제 ## 2. iris 문제
```python ```python
loss = 'mean_squared_error' loss = 'mean_squared_error'
@@ -166,7 +174,7 @@ best_score = pso_iris.fit(
위의 그래프를 보면 epochs 이 늘어나도 정확도와 loss 가 수렴하지 않는것을 보면 파라미터의 이동 속도가 너무 빠르다고 생각합니다 위의 그래프를 보면 epochs 이 늘어나도 정확도와 loss 가 수렴하지 않는것을 보면 파라미터의 이동 속도가 너무 빠르다고 생각합니다
3. mnist 문제 ## 3. mnist 문제
```python ```python
loss = 'mean_squared_error' loss = 'mean_squared_error'
@@ -174,11 +182,11 @@ loss = 'mean_squared_error'
pso_mnist = Optimizer( pso_mnist = Optimizer(
model, model,
loss=loss, loss=loss,
n_particles=100, n_particles=500,
c0=0.3, c0= 0.4,
c1=0.5, c1= 0.6,
w_min=0.4, w_min= 0.5,
w_max=0.7, w_max= 0.8,
negative_swarm=0.1, negative_swarm=0.1,
mutation_swarm=0.2, mutation_swarm=0.2,
particle_min=-5, particle_min=-5,
@@ -198,33 +206,35 @@ best_score = pso_mnist.fit(
) )
``` ```
위의 파라미터 기준 현재 정확도 51.84%를 보이고 있습니다 위의 파라미터 기준 현재 정확도 63.84%를 보이고 있습니다
![mnist_acc](./history_plt/mnist_51.74_acc.png) ![mnist_acc](./history_plt/mnist_63.84_acc.png)
![mnist_loss](./history_plt/mnist_51.74_loss.png) ![mnist_loss](./history_plt/mnist_63.84_loss.png)
### Trouble Shooting ## Trouble Shooting
> 1. 딥러닝 알고리즘 특성상 weights는 처음 컴파일시 무작위하게 생성된다. weights의 각 지점의 중요도는 매번 무작위로 정해지기에 전역 최적값으로 찾아갈 때 값이 높은 loss를 향해서 상승하는 현상이 나타난다.<br> > 1. 딥러닝 알고리즘 특성상 weights는 처음 컴파일시 무작위하게 생성된다. weights의 각 지점의 중요도는 매번 무작위로 정해지기에 전역 최적값으로 찾아갈 때 값이 높은 loss를 향해서 상승하는 현상이 나타난다.</br>
> 따라서 weights의 이동 방법을 더 탐구하거나, weights를 초기화 할때 random 중요도를 좀더 노이즈가 적게 생성하는 방향을 모색해야할 것 같다. > 따라서 weights의 이동 방법을 더 탐구하거나, weights를 초기화 할때 random 중요도를 좀더 노이즈가 적게 생성하는 방향을 모색해야할 것 같다.
-> 고르게 초기화 하기 위해 np.random.uniform 함수를 사용하였습니다 -> 고르게 초기화 하기 위해 np.random.uniform 함수를 사용하였습니다
> 2. 지역최적값에 계속 머무르는 조기 수렴 현상이 나타난다. - 30% 정도의 정확도를 가진다 > 2. 지역최적값에 계속 머무르는 조기 수렴 현상이 나타난다. - 30% 정도의 정확도를 가진다
-> 지역최적값에 머무르는 것을 방지하기 위해 negative_swarm, mutation_swarm 파라미터를 추가하였습니다 - 현재 51% 정도의 정확도를 보이고 있습니다 -> 지역최적값에 머무르는 것을 방지하기 위해 negative_swarm, mutation_swarm 파라미터를 추가하였습니다 - 현재 63% 정도의 정확도를 보이고 있습니다
> 3. 파티클의 수를 늘리면 전역 최적해에 좀더 가까워지는 현상을 발견하였다. 하지만 파티클의 수를 늘리면 메모리 사용량이 기하급수적으로 늘어난다. > 3. 파티클의 수를 늘리면 전역 최적해에 좀더 가까워지는 현상을 발견하였다. 하지만 파티클의 수를 늘리면 메모리 사용량이 기하급수적으로 늘어난다.
-> keras 모델을 사용할때 predict, evaluate 함수를 사용하면 메모리 누수가 발생하는 문제를 찾았습니다. 해결방법을 추가로 찾아보는중 입니다. -> keras 모델을 사용할때 predict, evaluate 함수를 사용하면 메모리 누수가 발생하는 문제를 찾았습니다. 해결방법을 추가로 찾아보는중 입니다. -> 메모리 누수를 획기적으로 줄여 현재는 파티클의 수를 500개에서 1000개까지 증가시켜도 문제가 없습니다.</br>
-> 추가로 파티클의 수가 적을때에도 전역 최적해를 쉽게 찾는 방법을 찾는중 입니다 -> 추가로 파티클의 수가 적을때에도 전역 최적해를 쉽게 찾는 방법을 찾는중 입니다</br>
> 4. 모델의 크기가 커지면 수렴이 늦어지고 정확도가 떨어지는 현상이 발견되었다. 모델의 크기에 맞는 파라미터를 찾아야할 것 같다.
> 5. EBPSO 의 방식을 추가로 적용을 하였으나 수식을 잘못 적용을 한것인지 기본 pso 보다 더 떨어지는 정확도를 보이고 있다. (현재 수정중)
### 개인적인 생각 ### 개인적인 생각
> 머신러닝 분류 방식에 존재하는 random forest 방식을 이용하여, 오차역전파 함수를 최적화 하는 방법이 있을것 같습니다 > 머신러닝 분류 방식에 존재하는 random forest 방식을 이용하여, 오차역전파 함수를 최적화 하는 방법이 있을것 같습니다
> >
> > pso 와 random forest 방식이 매우 유사하다고 생각하여 학습할 때 뿐만 아니라 예측 할 때도 이러한 방식으로 사용할 수 있을 것 같습니다 > > pso 와 random forest 방식이 매우 유사하다고 생각하여 학습할 때 뿐만 아니라 예측 할 때도 이러한 방식으로 사용할 수 있을 것 같습니다
>
> 각
# 참고 자료 # 참고 자료

BIN
history_plt/mnist_63.84_acc.png Executable file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 120 KiB

BIN
history_plt/mnist_63.84_loss.png Executable file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 122 KiB

6
iris.py
View File

@@ -11,7 +11,7 @@ from tensorflow import keras
from tensorflow.keras import layers from tensorflow.keras import layers
from tensorflow.keras.models import Sequential from tensorflow.keras.models import Sequential
from pso import Optimizer from pso import optimizer
def make_model(): def make_model():
@@ -42,7 +42,7 @@ x_train, x_test, y_train, y_test = load_data()
loss = ["categorical_crossentropy", "mean_squared_error"] loss = ["categorical_crossentropy", "mean_squared_error"]
pso_iris = Optimizer( pso_iris = optimizer(
model, model,
loss=loss[1], loss=loss[1],
n_particles=100, n_particles=100,
@@ -63,7 +63,7 @@ best_score = pso_iris.fit(
save_info=True, save_info=True,
log=2, log=2,
log_name="iris", log_name="iris",
save_path="./result/iris", save_path="result/iris",
renewal="acc", renewal="acc",
check_point=25, check_point=25,
) )

7
mnist.ipynb
View File

@@ -2,7 +2,7 @@
"cells": [ "cells": [
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 1, "execution_count": 2,
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
"source": [ "source": [
@@ -19,7 +19,7 @@
"from keras.models import Sequential\n", "from keras.models import Sequential\n",
"from tensorflow import keras\n", "from tensorflow import keras\n",
"\n", "\n",
"from pso import Optimizer\n", "from pso import optimizer\n",
"\n", "\n",
"\n", "\n",
"def get_data():\n", "def get_data():\n",
@@ -62,7 +62,6 @@
" model.add(Dense(128, activation=\"relu\"))\n", " model.add(Dense(128, activation=\"relu\"))\n",
" model.add(Dense(10, activation=\"softmax\"))\n", " model.add(Dense(10, activation=\"softmax\"))\n",
"\n", "\n",
"\n",
" return model" " return model"
] ]
}, },
@@ -187,7 +186,7 @@
"]\n", "]\n",
"\n", "\n",
"\n", "\n",
"pso_mnist = Optimizer(\n", "pso_mnist = optimizer(\n",
" model,\n", " model,\n",
" loss=loss[0],\n", " loss=loss[0],\n",
" n_particles=70,\n", " n_particles=70,\n",

37
mnist.py
View File

@@ -5,8 +5,6 @@ import sys
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2" os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
import gc
import numpy as np import numpy as np
import tensorflow as tf import tensorflow as tf
from keras.datasets import mnist from keras.datasets import mnist
@@ -14,7 +12,7 @@ from keras.layers import Conv2D, Dense, Dropout, Flatten, MaxPooling2D
from keras.models import Sequential from keras.models import Sequential
from tensorflow import keras from tensorflow import keras
from pso import Optimizer from pso import optimizer
def get_data(): def get_data():
@@ -40,10 +38,10 @@ def get_data_test():
x_test = x_test / 255.0 x_test = x_test / 255.0
x_test = x_test.reshape((10000, 28, 28, 1)) x_test = x_test.reshape((10000, 28, 28, 1))
y_test = tf.one_hot(y_test, 10) y_train, y_test = tf.one_hot(y_train, 10), tf.one_hot(y_test, 10)
x_test = tf.convert_to_tensor(x_test) x_train, x_test = tf.convert_to_tensor(x_train), tf.convert_to_tensor(x_test)
y_test = tf.convert_to_tensor(y_test) y_train, y_test = tf.convert_to_tensor(y_train), tf.convert_to_tensor(y_test)
print(f"x_test : {x_test[0].shape} | y_test : {y_test[0].shape}") print(f"x_test : {x_test[0].shape} | y_test : {y_test[0].shape}")
@@ -53,14 +51,14 @@ def get_data_test():
def make_model(): def make_model():
model = Sequential() model = Sequential()
model.add( model.add(
Conv2D(32, kernel_size=(5, 5), activation="relu", input_shape=(28, 28, 1)) Conv2D(32, kernel_size=(5, 5), activation="sigmoid", input_shape=(28, 28, 1))
) )
model.add(MaxPooling2D(pool_size=(3, 3))) model.add(MaxPooling2D(pool_size=(3, 3)))
model.add(Conv2D(64, kernel_size=(3, 3), activation="relu")) model.add(Conv2D(64, kernel_size=(3, 3), activation="sigmoid"))
model.add(MaxPooling2D(pool_size=(2, 2))) model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25)) model.add(Dropout(0.25))
model.add(Flatten()) model.add(Flatten())
model.add(Dense(128, activation="relu")) model.add(Dense(128, activation="sigmoid"))
model.add(Dense(10, activation="softmax")) model.add(Dense(10, activation="softmax"))
return model return model
@@ -101,33 +99,34 @@ loss = [
"mean_absolute_percentage_error", "mean_absolute_percentage_error",
] ]
rs = random_state() # rs = random_state()
pso_mnist = Optimizer( pso_mnist = optimizer(
model, model,
loss=loss[0], loss="mean_squared_error",
n_particles=500, n_particles=990,
c0=0.3, c0=0.2,
c1=0.5, c1=0.4,
w_min=0.4, w_min=0.3,
w_max=0.7, w_max=0.6,
negative_swarm=0.1, negative_swarm=0.1,
mutation_swarm=0.3, mutation_swarm=0.3,
particle_min=-4, particle_min=-4,
particle_max=4, particle_max=4,
random_state=rs,
) )
best_score = pso_mnist.fit( best_score = pso_mnist.fit(
x_train, x_train,
y_train, y_train,
epochs=250, epochs=200,
save_info=True, save_info=True,
log=2, log=2,
log_name="mnist", log_name="mnist",
save_path="./result/mnist", save_path="./result/mnist",
renewal="acc", renewal="acc",
check_point=25, check_point=25,
empirical_balance=False,
dispersion=False,
) )
print("Done!") print("Done!")

22
mnist_tf.py
View File

@@ -1,7 +1,7 @@
# %%
import os import os
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2" os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
import tensorflow as tf import tensorflow as tf
gpus = tf.config.experimental.list_physical_devices("GPU") gpus = tf.config.experimental.list_physical_devices("GPU")
@@ -17,8 +17,6 @@ from keras.datasets import mnist
from keras.layers import Conv2D, Dense, Dropout, Flatten, MaxPooling2D from keras.layers import Conv2D, Dense, Dropout, Flatten, MaxPooling2D
from keras.models import Sequential from keras.models import Sequential
from pso import Optimizer
def get_data(): def get_data():
(x_train, y_train), (x_test, y_test) = mnist.load_data() (x_train, y_train), (x_test, y_test) = mnist.load_data()
@@ -62,10 +60,6 @@ x_train, y_train, x_test, y_test = get_data()
y_train = tf.one_hot(y_train, 10) y_train = tf.one_hot(y_train, 10)
y_test = tf.one_hot(y_test, 10) y_test = tf.one_hot(y_test, 10)
# model.compile(
# optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"]
# )
model.compile(optimizer="adam", loss="mse", metrics=["accuracy"]) model.compile(optimizer="adam", loss="mse", metrics=["accuracy"])
print("Training model...") print("Training model...")
@@ -76,17 +70,3 @@ model.evaluate(x_test, y_test, verbose=1)
weights = model.get_weights() weights = model.get_weights()
for w in weights:
print(w.shape)
print(w)
print(w.min(), w.max())
model.save_weights("weights.h5")
# %%
for w in weights:
print(w.shape)
print(w)
print(w.min(), w.max())
# %%

8
pso/__init__.py
View File

@@ -1,9 +1,9 @@
from .optimizer import Optimizer from .optimizer import Optimizer as optimizer
from .particle import Particle from .particle import Particle as particle
__version__ = "0.1.6" __version__ = "0.1.6"
__all__ = [ __all__ = [
"Optimizer", "optimizer",
"Particle", "particle",
] ]

127
pso/optimizer.py
View File

@@ -15,8 +15,8 @@ gpus = tf.config.experimental.list_physical_devices("GPU")
if gpus: if gpus:
try: try:
tf.config.experimental.set_memory_growth(gpus[0], True) tf.config.experimental.set_memory_growth(gpus[0], True)
except RuntimeError as e: except RuntimeError as r:
print(e) print(r)
class Optimizer: class Optimizer:
@@ -81,10 +81,13 @@ class Optimizer:
self.w_max = w_max # 최대 관성 수치 self.w_max = w_max # 최대 관성 수치
self.negative_swarm = negative_swarm # 최적해와 반대로 이동할 파티클 비율 - 0 ~ 1 사이의 값 self.negative_swarm = negative_swarm # 최적해와 반대로 이동할 파티클 비율 - 0 ~ 1 사이의 값
self.mutation_swarm = mutation_swarm # 관성을 추가로 사용할 파티클 비율 - 0 ~ 1 사이의 값 self.mutation_swarm = mutation_swarm # 관성을 추가로 사용할 파티클 비율 - 0 ~ 1 사이의 값
self.particle_min = particle_min # 가중치 초기화 최소값
self.particle_max = particle_max
self.g_best_score = [0, np.inf] # 최고 점수 - 시작은 0으로 초기화 self.g_best_score = [0, np.inf] # 최고 점수 - 시작은 0으로 초기화
self.g_best = None # 최고 점수를 받은 가중치 self.g_best = None # 최고 점수를 받은 가중치
self.g_best_ = None # 최고 점수를 받은 가중치 - 값의 분산을 위한 변수 self.g_best_ = None # 최고 점수를 받은 가중치 - 값의 분산을 위한 변수
self.avg_score = 0 # 평균 점수 self.avg_score = 0 # 평균 점수
self.sigma = 1.0
self.save_path = None # 저장 위치 self.save_path = None # 저장 위치
self.renewal = "acc" self.renewal = "acc"
@@ -124,14 +127,11 @@ class Optimizer:
tf.keras.backend.reset_uids() tf.keras.backend.reset_uids()
tf.keras.backend.clear_session() tf.keras.backend.clear_session()
except KeyboardInterrupt: except KeyboardInterrupt:
print("Ctrl + C : Stop Training") sys.exit("Ctrl + C : Stop Training")
sys.exit(0)
except MemoryError: except MemoryError:
print("Memory Error : Stop Training") sys.exit("Memory Error : Stop Training")
sys.exit(1)
except Exception as e: except Exception as e:
print(e) sys.exit(e)
sys.exit(1)
def __del__(self): def __del__(self):
del self.model del self.model
@@ -147,6 +147,7 @@ class Optimizer:
del self.g_best del self.g_best
del self.g_best_ del self.g_best_
del self.avg_score del self.avg_score
gc.collect() gc.collect()
tf.keras.backend.reset_uids() tf.keras.backend.reset_uids()
tf.keras.backend.clear_session() tf.keras.backend.clear_session()
@@ -167,9 +168,9 @@ class Optimizer:
shape = [] shape = []
for layer in weights: for layer in weights:
shape.append(layer.shape) shape.append(layer.shape)
w_ = layer.reshape(-1) w_tmp = layer.reshape(-1)
length.append(len(w_)) length.append(len(w_tmp))
w_gpu = np.append(w_gpu, w_) w_gpu = np.append(w_gpu, w_tmp)
del weights del weights
@@ -191,18 +192,17 @@ class Optimizer:
start = 0 start = 0
for i in range(len(shape)): for i in range(len(shape)):
end = start + length[i] end = start + length[i]
w_ = weight[start:end] w_tmp = weight[start:end]
w_ = np.reshape(w_, shape[i]) w_tmp = np.reshape(w_tmp, shape[i])
weights.append(w_) weights.append(w_tmp)
start = end start = end
del weight del weight, shape, length
del shape del start, end, w_tmp
del length
return weights return weights
def f(self, x, y, weights): def _f(self, x, y, weights):
""" """
EBPSO의 목적함수 (예상) EBPSO의 목적함수 (예상)
@@ -215,11 +215,16 @@ class Optimizer:
(float): 목적 함수 값 (float): 목적 함수 값
""" """
self.model.set_weights(weights) self.model.set_weights(weights)
score = self.model.evaluate(x, y, verbose=0)[1] score = self.model.evaluate(x, y, verbose=0)
if score > 0: if self.renewal == "acc":
return 1 / (1 + score) score_ = score[1]
else: else:
return 1 + np.abs(score) score_ = score[0]
if score_ > 0:
return 1 / (1 + score_)
else:
return 1 + np.abs(score_)
def fit( def fit(
self, self,
@@ -253,6 +258,7 @@ class Optimizer:
self.dispersion = dispersion self.dispersion = dispersion
self.renewal = renewal self.renewal = renewal
particle_sum = 0 # x_j
try: try:
train_log_dir = "logs/fit/" + self.day train_log_dir = "logs/fit/" + self.day
if log == 2: if log == 2:
@@ -269,17 +275,17 @@ class Optimizer:
raise ValueError("save_path is None") raise ValueError("save_path is None")
else: else:
self.save_path = save_path self.save_path = save_path
if not os.path.exists(save_path): if not os.path.exists(f"{save_path}/{self.day}"):
os.makedirs(save_path, exist_ok=True) os.makedirs(f"{save_path}/{self.day}", exist_ok=True)
except ValueError as e: except ValueError as e:
print(e) sys.exit(e)
except Exception as e: except Exception as e:
print(e) sys.exit(e)
for i in tqdm(range(self.n_particles), desc="Initializing velocity"): for i in tqdm(range(self.n_particles), desc="Initializing velocity"):
p = self.particles[i] p = self.particles[i]
local_score = p.get_score(x, y, renewal=renewal) local_score = p.get_score(x, y, renewal=renewal)
particle_sum += local_score[1]
if renewal == "acc": if renewal == "acc":
if local_score[1] > self.g_best_score[0]: if local_score[1] > self.g_best_score[0]:
self.g_best_score[0] = local_score[1] self.g_best_score[0] = local_score[1]
@@ -301,7 +307,7 @@ class Optimizer:
if log == 1: if log == 1:
with open( with open(
f"./{save_path}/{self.day}_{self.n_particles}_{epochs}_{self.c0}_{self.c1}_{self.w_min}_{renewal}.csv", f"./{save_path}/{self.day}/{self.n_particles}_{epochs}_{self.c0}_{self.c1}_{self.w_min}_{renewal}.csv",
"a", "a",
) as f: ) as f:
f.write(f"{local_score[0]}, {local_score[1]}") f.write(f"{local_score[0]}, {local_score[1]}")
@@ -316,14 +322,15 @@ class Optimizer:
tf.summary.scalar("accuracy", local_score[1], step=0) tf.summary.scalar("accuracy", local_score[1], step=0)
del local_score del local_score
gc.collect() # gc.collect()
tf.keras.backend.reset_uids() # tf.keras.backend.reset_uids()
tf.keras.backend.clear_session() # tf.keras.backend.clear_session()
print( print(
f"initial g_best_score : {self.g_best_score[0] if self.renewal == 'acc' else self.g_best_score[1]}" f"initial g_best_score : {self.g_best_score[0] if self.renewal == 'acc' else self.g_best_score[1]}"
) )
try: try:
epoch_sum = 0
epochs_pbar = tqdm( epochs_pbar = tqdm(
range(epochs), range(epochs),
desc=f"best {self.g_best_score[0]:.4f}|{self.g_best_score[1]:.4f}", desc=f"best {self.g_best_score[0]:.4f}|{self.g_best_score[1]:.4f}",
@@ -332,8 +339,11 @@ class Optimizer:
position=0, position=0,
) )
for epoch in epochs_pbar: for epoch in epochs_pbar:
particle_avg = particle_sum / self.n_particles # x_j
particle_sum = 0
max_score = 0 max_score = 0
min_loss = np.inf min_loss = np.inf
# epoch_particle_sum = 0
part_pbar = tqdm( part_pbar = tqdm(
range(len(self.particles)), range(len(self.particles)),
desc=f"acc : {max_score:.4f} loss : {min_loss:.4f}", desc=f"acc : {max_score:.4f} loss : {min_loss:.4f}",
@@ -347,20 +357,22 @@ class Optimizer:
f"acc : {max_score:.4f} loss : {min_loss:.4f}" f"acc : {max_score:.4f} loss : {min_loss:.4f}"
) )
g_best = self.g_best
if dispersion: if dispersion:
ts = self.c0 + np.random.rand() * (self.c1 - self.c0) ts = self.particle_min + np.random.rand() * (
self.particle_max - self.particle_min
)
g_, g_sh, g_len = self._encode(self.g_best) g_, g_sh, g_len = self._encode(self.g_best)
decrement = (epochs - (epoch) + 1) / epochs decrement = (epochs - epoch + 1) / epochs
g_ = (1 - decrement) * g_ + decrement * ts g_ = (1 - decrement) * g_ + decrement * ts
self.g_best_ = self._decode(g_, g_sh, g_len) self.g_best_ = self._decode(g_, g_sh, g_len)
g_best = self.g_best_ g_best = self.g_best_
else:
g_best = self.g_best
if empirical_balance: if empirical_balance:
if np.random.rand() < np.exp(-(epoch) / epochs): if np.random.rand() < np.exp(-(epoch) / epochs):
w_p_ = self.f(x, y, self.particles[i].get_best_weights()) w_p_ = self._f(x, y, self.particles[i].get_best_weights())
w_g_ = self.f(x, y, self.g_best) w_g_ = self._f(x, y, self.g_best)
w_p = w_p_ / (w_p_ + w_g_) w_p = w_p_ / (w_p_ + w_g_)
w_g = w_p_ / (w_p_ + w_g_) w_g = w_p_ / (w_p_ + w_g_)
@@ -371,13 +383,35 @@ class Optimizer:
p_b = self.particles[i].get_best_score() p_b = self.particles[i].get_best_score()
g_a = self.avg_score g_a = self.avg_score
l_b = p_b - g_a l_b = p_b - g_a
l_b = np.sqrt(np.power(l_b, 2)) sigma_post = np.sqrt(np.power(l_b, 2))
p_ = ( sigma_pre = (
1 1
/ (self.n_particles * np.linalg.norm(self.c1 - self.c0)) / (
* l_b self.n_particles
* np.linalg.norm(
self.particle_max - self.particle_min
) )
p_ = np.exp(-1 * p_) )
* sigma_post
)
p_ = np.exp(-1 * sigma_pre * sigma_post)
# p_ = (
# 1
# / (self.n_particles * np.linalg.norm(self.particle_max - self.particle_min))
# * np.exp(
# -np.power(l_b, 2) / (2 * np.power(self.sigma, 2))
# )
# )
# g_ = (
# 1
# / np.linalg.norm(self.c1 - self.c0)
# * np.exp(
# -np.power(l_b, 2) / (2 * np.power(self.sigma, 2))
# )
# )
# w_p = p_ / (p_ + g_)
# w_g = g_ / (p_ + g_)
w_p = p_ w_p = p_
w_g = 1 - p_ w_g = 1 - p_
@@ -397,6 +431,7 @@ class Optimizer:
w_g, w_g,
renewal=renewal, renewal=renewal,
) )
epoch_sum += np.power(score[1] - particle_avg, 2)
else: else:
score = self.particles[i].step( score = self.particles[i].step(
@@ -457,10 +492,11 @@ class Optimizer:
epochs_pbar.set_description( epochs_pbar.set_description(
f"best {self.g_best_score[0]:.4f} | {self.g_best_score[1]:.4f}" f"best {self.g_best_score[0]:.4f} | {self.g_best_score[1]:.4f}"
) )
particle_sum += score[1]
if log == 1: if log == 1:
with open( with open(
f"./{save_path}/{self.day}_{self.n_particles}_{epochs}_{self.c0}_{self.c1}_{self.w_min}_{renewal}.csv", f"./{save_path}/{self.day}/{self.n_particles}_{epochs}_{self.c0}_{self.c1}_{self.w_min}_{renewal}.csv",
"a", "a",
) as f: ) as f:
f.write(f"{score[0]}, {score[1]}") f.write(f"{score[0]}, {score[1]}")
@@ -468,9 +504,6 @@ class Optimizer:
f.write(", ") f.write(", ")
else: else:
f.write("\n") f.write("\n")
# gc.collect()
# tf.keras.backend.reset_uids()
# tf.keras.backend.clear_session()
part_pbar.refresh() part_pbar.refresh()
if check_point is not None: if check_point is not None:
@@ -536,7 +569,7 @@ class Optimizer:
path (str, optional): 저장 위치. Defaults to "./result". path (str, optional): 저장 위치. Defaults to "./result".
""" """
json_save = { json_save = {
"name": f"{self.day}_{self.n_particles}_{self.c0}_{self.c1}_{self.w_min}.h5", "name": f"{self.day}/{self.n_particles}_{self.c0}_{self.c1}_{self.w_min}.h5",
"n_particles": self.n_particles, "n_particles": self.n_particles,
"score": self.g_best_score, "score": self.g_best_score,
"c0": self.c0, "c0": self.c0,

41
pso/particle.py
View File

@@ -2,6 +2,7 @@ import numpy as np
from tensorflow import keras from tensorflow import keras
class Particle: class Particle:
""" """
Particle Swarm Optimization의 Particle을 구현한 클래스 Particle Swarm Optimization의 Particle을 구현한 클래스
@@ -112,8 +113,6 @@ class Particle:
self.best_score = score[1] self.best_score = score[1]
self.best_weights = self.model.get_weights() self.best_weights = self.model.get_weights()
elif renewal == "loss": elif renewal == "loss":
if score[0] == "nan":
score[0] = np.inf
if score[0] < self.best_score: if score[0] < self.best_score:
self.best_score = score[0] self.best_score = score[0]
self.best_weights = self.model.get_weights() self.best_weights = self.model.get_weights()
@@ -134,11 +133,11 @@ class Particle:
encode_v, v_sh, v_len = self._encode(weights=self.velocities) encode_v, v_sh, v_len = self._encode(weights=self.velocities)
encode_p, p_sh, p_len = self._encode(weights=self.best_weights) encode_p, p_sh, p_len = self._encode(weights=self.best_weights)
encode_g, g_sh, g_len = self._encode(weights=g_best) encode_g, g_sh, g_len = self._encode(weights=g_best)
r0 = np.random.rand()
r1 = np.random.rand()
encode_before, before_sh, before_len = self._encode(weights=self.before_best) encode_before, before_sh, before_len = self._encode(weights=self.before_best)
r_0 = np.random.rand()
r_1 = np.random.rand()
if (encode_before != encode_g).all(): if not np.array_equal(encode_before, encode_g, equal_nan=True):
self.before_w = w * 0.6 self.before_w = w * 0.6
w = w + self.before_w w = w + self.before_w
else: else:
@@ -148,14 +147,14 @@ class Particle:
if self.negative: if self.negative:
new_v = ( new_v = (
w * encode_v w * encode_v
+ -1 * local_rate * r0 * (encode_p - encode_w) + local_rate * r_0 * (encode_p - encode_w)
+ -1 * global_rate * r1 * (encode_g - encode_w) + -1 * global_rate * r_1 * (encode_g - encode_w)
) )
else: else:
new_v = ( new_v = (
w * encode_v w * encode_v
+ local_rate * r0 * (encode_p - encode_w) + local_rate * r_0 * (encode_p - encode_w)
+ global_rate * r1 * (encode_g - encode_w) + global_rate * r_1 * (encode_g - encode_w)
) )
if np.random.rand() < self.mutation: if np.random.rand() < self.mutation:
@@ -169,7 +168,7 @@ class Particle:
del encode_p, p_sh, p_len del encode_p, p_sh, p_len
del encode_g, g_sh, g_len del encode_g, g_sh, g_len
del encode_before, before_sh, before_len del encode_before, before_sh, before_len
del r0, r1 del r_0, r_1
def _update_velocity_w(self, local_rate, global_rate, w, w_p, w_g, g_best): def _update_velocity_w(self, local_rate, global_rate, w, w_p, w_g, g_best):
""" """
@@ -188,20 +187,27 @@ class Particle:
encode_v, v_sh, v_len = self._encode(weights=self.velocities) encode_v, v_sh, v_len = self._encode(weights=self.velocities)
encode_p, p_sh, p_len = self._encode(weights=self.best_weights) encode_p, p_sh, p_len = self._encode(weights=self.best_weights)
encode_g, g_sh, g_len = self._encode(weights=g_best) encode_g, g_sh, g_len = self._encode(weights=g_best)
r0 = np.random.rand() encode_before, before_sh, before_len = self._encode(weights=self.before_best)
r1 = np.random.rand() r_0 = np.random.rand()
r_1 = np.random.rand()
if not np.array_equal(encode_before, encode_g, equal_nan=True):
self.before_w = w * 0.6
w = w + self.before_w
else:
self.before_w *= 0.75
w = w + self.before_w
if self.negative: if self.negative:
new_v = ( new_v = (
w * encode_v w * encode_v
+ -1 * local_rate * r0 * (w_p * encode_p - encode_w) + local_rate * r_0 * (w_p * encode_p - encode_w)
+ -1 * global_rate * r1 * (w_g * encode_g - encode_w) + -1 * global_rate * r_1 * (w_g * encode_g - encode_w)
) )
else: else:
new_v = ( new_v = (
w * encode_v w * encode_v
+ local_rate * r0 * (w_p * encode_p - encode_w) + local_rate * r_0 * (w_p * encode_p - encode_w)
+ global_rate * r1 * (w_g * encode_g - encode_w) + global_rate * r_1 * (w_g * encode_g - encode_w)
) )
if np.random.rand() < self.mutation: if np.random.rand() < self.mutation:
@@ -214,7 +220,8 @@ class Particle:
del encode_v, v_sh, v_len del encode_v, v_sh, v_len
del encode_p, p_sh, p_len del encode_p, p_sh, p_len
del encode_g, g_sh, g_len del encode_g, g_sh, g_len
del r0, r1 del encode_before, before_sh, before_len
del r_0, r_1
def _update_weights(self): def _update_weights(self):
""" """

11
test01.py Normal file
View File

@@ -0,0 +1,11 @@
# 반복문을 사용해서 자동 생성하는 python 코드
def pibonachi(n):
if n <= 1:
return n
else:
return pibonachi(n - 1) + pibonachi(n - 2)
print(pibonachi(10))

7
xor.py
View File

@@ -11,7 +11,7 @@ from tensorflow.keras import layers
from tensorflow.keras.layers import Dense from tensorflow.keras.layers import Dense
from tensorflow.keras.models import Sequential from tensorflow.keras.models import Sequential
from pso import Optimizer from pso import optimizer
def get_data(): def get_data():
@@ -47,10 +47,10 @@ loss = [
"mean_absolute_percentage_error", "mean_absolute_percentage_error",
] ]
pso_xor = Optimizer( pso_xor = optimizer(
model, model,
loss=loss[0], loss=loss[0],
n_particles=50, n_particles=100,
c0=0.35, c0=0.35,
c1=0.8, c1=0.8,
w_min=0.6, w_min=0.6,
@@ -66,6 +66,7 @@ best_score = pso_xor.fit(
epochs=200, epochs=200,
save_info=True, save_info=True,
log=2, log=2,
log_name="xor",
save_path="./result/xor", save_path="./result/xor",
renewal="acc", renewal="acc",
check_point=25, check_point=25,