diff --git a/mnist.ipynb b/mnist.ipynb index c58e0dc..441e108 100644 --- a/mnist.ipynb +++ b/mnist.ipynb @@ -4,13 +4,15 @@ "cell_type": "code", "execution_count": 1, "id": "8a637c69-9071-4012-ac1e-93037548b3e9", - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "2023-05-21 03:38:18.127052: 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" + "2023-05-24 12:58:36.275491: 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" ] }, { @@ -26,22 +28,24 @@ "import os\n", "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'\n", "\n", - "from pso_tf import PSO\n", - "\n", - "import numpy as np\n", - "\n", "import tensorflow as tf\n", - "from tensorflow import keras\n", - "tf.random.set_seed(777) # for reproducibility\n", + "# tf.random.set_seed(777) # for reproducibility\n", "\n", + "from tensorflow import keras\n", "from keras.datasets import mnist\n", "from keras.models import Sequential\n", "from keras.layers import Dense, Dropout, Flatten\n", "from keras.layers import Conv2D, MaxPooling2D\n", "from keras import backend as K\n", "\n", + "from pso_tf import PSO\n", + "\n", + "import numpy as np\n", "import matplotlib.pyplot as plt\n", + "\n", "from datetime import date\n", + "from tqdm import tqdm\n", + "import json\n", "\n", "print(tf.__version__)\n", "print(tf.config.list_physical_devices())\n", @@ -68,9 +72,7 @@ " model.add(Dense(128, activation='relu'))\n", " model.add(Dense(10, activation='softmax'))\n", "\n", - " model.compile(loss='sparse_categorical_crossentropy',optimizer='adam', metrics=['accuracy'])\n", - "\n", - " model.summary()\n", + " # model.summary()\n", "\n", " return model" ] @@ -79,41 +81,83 @@ "cell_type": "code", "execution_count": 2, "id": "a2d9891d", - "metadata": {}, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "'''\n", + "optimizer parameter\n", + "'''\n", + "lr = 0.1\n", + "momentun = 0.8\n", + "decay = 1e-04\n", + "nestrov = True\n", + "\n", + "'''\n", + "pso parameter\n", + "'''\n", + "n_particles = 30\n", + "maxiter = 50\n", + "# epochs = 1\n", + "w = 0.8\n", + "c0 = 0.6\n", + "c1 = 1.6\n", + "\n", + "def auto_tuning(n_particles=n_particles, maxiter=maxiter, c0=c0, c1=c1, w=w):\n", + " x_train, y_train, x_test, y_test = get_data()\n", + " model = make_model()\n", + "\n", + " loss = keras.losses.MeanSquaredError()\n", + " optimizer = keras.optimizers.SGD(lr=lr, momentum=momentun, decay=decay, nesterov=nestrov)\n", + "\n", + "\n", + " pso_m = PSO(model=model, loss_method=loss, n_particles=n_particles, x_train=x_train, y_train=y_train)\n", + " # c0 : 지역 최적값 중요도\n", + " # c1 : 전역 최적값 중요도\n", + " # w : 관성 (현재 속도를 유지하는 정도)\n", + " best_weights, score = pso_m.optimize(x_train, y_train, x_test, y_test, maxiter=maxiter, c0=c0, c1=c1, w=w)\n", + " model.set_weights(best_weights)\n", + "\n", + " score_ = model.evaluate(x_test, y_test, verbose=2)\n", + " print(f\" Test loss: {score_}\")\n", + " score = round(score_[1]*100, 2)\n", + "\n", + " day = date.today().strftime(\"%Y-%m-%d\")\n", + " \n", + " os.makedirs(f'./model', exist_ok=True)\n", + " model.save(f'./model/{day}_{score}_mnist.h5')\n", + " json_save = {\n", + " \"name\" : f\"{day}_{score}_mnist.h5\",\n", + " \"score\" : score_,\n", + " \"maxiter\" : maxiter,\n", + " \"c0\" : c0,\n", + " \"c1\" : c1,\n", + " \"w\" : w \n", + " }\n", + " with open(f'./model/{day}_{score}_mnist.json', 'a') as f:\n", + " json.dump(json_save, f)\n", + " f.write(',\\n')\n", + " \n", + " return model\n", + "\n", + "# auto_tuning(n_particles=30, maxiter=1000, c0=0.5, c1=1.5, w=0.75)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1a38f3c1-8291-40d9-838e-4ffbf4578be5", + "metadata": { + "tags": [] + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x_train : (28, 28, 1) | y_train : ()\n", - "x_test : (28, 28, 1) | y_test : ()\n", - "Model: \"sequential\"\n", - "_________________________________________________________________\n", - " Layer (type) Output Shape Param # \n", - "=================================================================\n", - " conv2d (Conv2D) (None, 24, 24, 32) 832 \n", - " \n", - " max_pooling2d (MaxPooling2D (None, 8, 8, 32) 0 \n", - " ) \n", - " \n", - " conv2d_1 (Conv2D) (None, 6, 6, 64) 18496 \n", - " \n", - " max_pooling2d_1 (MaxPooling (None, 3, 3, 64) 0 \n", - " 2D) \n", - " \n", - " dropout (Dropout) (None, 3, 3, 64) 0 \n", - " \n", - " flatten (Flatten) (None, 576) 0 \n", - " \n", - " dense (Dense) (None, 128) 73856 \n", - " \n", - " dense_1 (Dense) (None, 10) 1290 \n", - " \n", - "=================================================================\n", - "Total params: 94,474\n", - "Trainable params: 94,474\n", - "Non-trainable params: 0\n", - "_________________________________________________________________\n" + "x_test : (28, 28, 1) | y_test : ()\n" ] }, { @@ -122,184 +166,733 @@ "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", " super().__init__(name, **kwargs)\n", - "init particles position: 100%|██████████| 2/2 [00:00<00:00, 34.52it/s]\n", - "init velocities: 100%|██████████| 2/2 [00:00<00:00, 1203.19it/s]\n", - "Iteration 0 / 10: 100%|##########| 2/2 [00:48<00:00, 24.43s/it]\n" + "init particles position: 100%|██████████| 30/30 [00:00<00:00, 36.95it/s]\n", + "init velocities: 100%|██████████| 30/30 [00:00<00:00, 1399.35it/s]\n", + "Iter 0/50: 100%|##########| 30/30 [00:15<00:00, 1.98it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "loss : 0.021180160343647003 | acc : 0.9930999875068665\n" + "loss avg : 0.9084339777628581 | acc avg : 0.0019799999892711638 | best loss : 0.15219999849796295\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Iteration 1 / 10: 100%|##########| 2/2 [00:46<00:00, 23.46s/it]\n" + "Iter 1/50: 100%|##########| 30/30 [00:11<00:00, 2.54it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "loss : 0.029995786026120186 | acc : 0.9927999973297119\n" + "loss avg : 0.9090563456217448 | acc avg : 0.0031199999153614043 | best loss : 0.20149999856948853\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Iteration 2 / 10: 100%|##########| 2/2 [00:47<00:00, 23.57s/it]\n" + "Iter 2/50: 100%|##########| 30/30 [00:11<00:00, 2.59it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "loss : 0.13020965456962585 | acc : 0.9929999709129333\n" + "loss avg : 0.9103448867797852 | acc avg : 0.005286666750907898 | best loss : 0.20149999856948853\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Iteration 3 / 10: 100%|##########| 2/2 [00:47<00:00, 23.62s/it]\n" + "Iter 3/50: 100%|##########| 30/30 [00:11<00:00, 2.55it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "loss : 0.032199352979660034 | acc : 0.9918000102043152\n" + "loss avg : 0.9113266626993816 | acc avg : 0.004926666617393494 | best loss : 0.20149999856948853\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Iteration 4 / 10: 100%|##########| 2/2 [00:47<00:00, 23.66s/it]\n" + "Iter 4/50: 100%|##########| 30/30 [00:11<00:00, 2.54it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "loss : 0.025606701150536537 | acc : 0.9925000071525574\n" + "loss avg : 0.9113243738810222 | acc avg : 0.004126666734615962 | best loss : 0.20149999856948853\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Iteration 5 / 10: 100%|##########| 2/2 [00:47<00:00, 23.64s/it]\n" + "Iter 5/50: 100%|##########| 30/30 [00:11<00:00, 2.56it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "loss : 0.04198306426405907 | acc : 0.9921000003814697\n" + "loss avg : 0.9113284428914388 | acc avg : 0.002809999883174896 | best loss : 0.20180000364780426\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Iteration 6 / 10: 100%|##########| 2/2 [00:47<00:00, 23.69s/it]\n" + "Iter 6/50: 100%|##########| 30/30 [00:11<00:00, 2.51it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "loss : 0.048351287841796875 | acc : 0.9919999837875366\n" + "loss avg : 0.9113288243611654 | acc avg : 0.0034666667381922406 | best loss : 0.20180000364780426\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Iteration 7 / 10: 100%|##########| 2/2 [00:47<00:00, 23.73s/it]\n" + "Iter 7/50: 100%|##########| 30/30 [00:11<00:00, 2.60it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "loss : 0.0416271910071373 | acc : 0.9890999794006348\n" + "loss avg : 0.9113253911336263 | acc avg : 0.0029633333285649615 | best loss : 0.20180000364780426\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Iteration 8 / 10: 100%|##########| 2/2 [00:47<00:00, 23.70s/it]\n" + "Iter 8/50: 100%|##########| 30/30 [00:11<00:00, 2.57it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "loss : 0.18129077553749084 | acc : 0.9502000212669373\n" + "loss avg : 0.9113227208455403 | acc avg : 0.002809999883174896 | best loss : 0.20180000364780426\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Iteration 9 / 10: 100%|##########| 2/2 [00:47<00:00, 23.69s/it]\n" + "Iter 9/50: 100%|##########| 30/30 [00:11<00:00, 2.53it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "loss : 0.8072962760925293 | acc : 0.7225000262260437\n", - "313/313 - 0s - loss: 0.0212 - accuracy: 0.9931 - 290ms/epoch - 926us/step\n", - "Test loss: 0.021180160343647003 / Test accuracy: 0.9930999875068665\n" + "loss avg : 0.911251958211263 | acc avg : 0.005486666659514109 | best loss : 0.20180000364780426\n" ] - } - ], - "source": [ - "x_train, y_train, x_test, y_test = get_data()\n", - "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", - "\n", - "pso_m = PSO(model=model, loss_method=loss, optimizer=optimizer, n_particles=2)\n", - "best_weights, score = pso_m.optimize(x_train, y_train, x_test, y_test, maxiter=10)\n", - "\n", - "model.set_weights(best_weights)\n", - "\n", - "score = model.evaluate(x_test, y_test, verbose=2)\n", - "print(f\"Test loss: {score[0]} / Test accuracy: {score[1]}\")\n", - "\n", - "day = date.today().strftime(\"%Y-%m-%d\")\n", - "\n", - "model.save(f'./model/{day}_mnist.h5')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "1a38f3c1-8291-40d9-838e-4ffbf4578be5", - "metadata": {}, - "outputs": [ + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 10/50: 100%|##########| 30/30 [00:11<00:00, 2.57it/s]\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "313/313 [==============================] - 0s 685us/step\n", - "틀린 것 갯수 > 69\n" + "loss avg : 0.9113367716471354 | acc avg : 0.004316666722297668 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 11/50: 100%|##########| 30/30 [00:12<00:00, 2.47it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.9113431294759115 | acc avg : 0.002943333238363266 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 12/50: 100%|##########| 30/30 [00:11<00:00, 2.57it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.9113429387410482 | acc avg : 0.004413333535194397 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 13/50: 100%|##########| 30/30 [00:11<00:00, 2.58it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.9113424936930339 | acc avg : 0.004670000076293946 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 14/50: 100%|##########| 30/30 [00:11<00:00, 2.55it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.9113433202107747 | acc avg : 0.0024433332184950513 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 15/50: 100%|##########| 30/30 [00:12<00:00, 2.48it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.9113349914550781 | acc avg : 0.0030966666837533314 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 16/50: 100%|##########| 30/30 [00:11<00:00, 2.57it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.002956666549046834 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 17/50: 100%|##########| 30/30 [00:11<00:00, 2.56it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.002806666741768519 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 18/50: 100%|##########| 30/30 [00:11<00:00, 2.55it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.002503333240747452 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 19/50: 100%|##########| 30/30 [00:12<00:00, 2.47it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.9113413492838541 | acc avg : 0.003179999937613805 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 20/50: 100%|##########| 30/30 [00:11<00:00, 2.60it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.004823333521684011 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 21/50: 100%|##########| 30/30 [00:11<00:00, 2.60it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.003663333257039388 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 22/50: 100%|##########| 30/30 [00:11<00:00, 2.54it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.002916666616996129 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 23/50: 100%|##########| 30/30 [00:11<00:00, 2.55it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.0026966666181882223 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 24/50: 100%|##########| 30/30 [00:12<00:00, 2.43it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.0028999999165534975 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 25/50: 100%|##########| 30/30 [00:11<00:00, 2.56it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.0028833332161108654 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 26/50: 100%|##########| 30/30 [00:11<00:00, 2.55it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.0027433333297570547 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 27/50: 100%|##########| 30/30 [00:11<00:00, 2.59it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.0024033332864443462 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 28/50: 100%|##########| 30/30 [00:11<00:00, 2.60it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.004453333218892416 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 29/50: 100%|##########| 30/30 [00:11<00:00, 2.56it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.00338333323597908 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 30/50: 100%|##########| 30/30 [00:12<00:00, 2.44it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.0028333333631356556 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 31/50: 100%|##########| 30/30 [00:11<00:00, 2.58it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.002480000009139379 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 32/50: 100%|##########| 30/30 [00:11<00:00, 2.58it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.0030733334521452584 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 33/50: 100%|##########| 30/30 [00:11<00:00, 2.58it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.0028366667528947195 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 34/50: 100%|##########| 30/30 [00:11<00:00, 2.58it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.002760000030199687 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 35/50: 100%|##########| 30/30 [00:11<00:00, 2.57it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.002463333308696747 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 36/50: 100%|##########| 30/30 [00:11<00:00, 2.55it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.004286666711171468 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 37/50: 100%|##########| 30/30 [00:12<00:00, 2.39it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.003916666656732559 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 38/50: 100%|##########| 30/30 [00:11<00:00, 2.59it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.0037066665788491565 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 39/50: 100%|##########| 30/30 [00:11<00:00, 2.60it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.003233333428700765 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 40/50: 100%|##########| 30/30 [00:11<00:00, 2.60it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.0020900001128514607 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 41/50: 100%|##########| 30/30 [00:11<00:00, 2.60it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.002956666549046834 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 42/50: 100%|##########| 30/30 [00:11<00:00, 2.60it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.0028566665947437286 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 43/50: 100%|##########| 30/30 [00:11<00:00, 2.57it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.0026866666972637176 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 44/50: 100%|##########| 30/30 [00:11<00:00, 2.58it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.0045466666420300806 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 45/50: 100%|##########| 30/30 [00:12<00:00, 2.36it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.004050000011920929 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 46/50: 100%|##########| 30/30 [00:11<00:00, 2.58it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.0037399999797344207 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 47/50: 100%|##########| 30/30 [00:11<00:00, 2.60it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.00264999990661939 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 48/50: 100%|##########| 30/30 [00:11<00:00, 2.61it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.0029666667183240254 | best loss : 0.20180000364780426\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iter 49/50: 100%|##########| 30/30 [00:11<00:00, 2.56it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss avg : 0.911343765258789 | acc avg : 0.002906666696071625 | best loss : 0.20180000364780426\n", + "313/313 - 0s - loss: 27.3092 - accuracy: 0.2018 - 247ms/epoch - 788us/step\n", + " Test loss: [27.309202194213867, 0.20180000364780426]\n", + "x_train : (28, 28, 1) | y_train : ()\n", + "x_test : (28, 28, 1) | y_test : ()\n", + "313/313 [==============================] - 0s 691us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "진행도: 100%|██████████| 10000/10000 [00:00<00:00, 2226867.00it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "틀린 갯수 > 7982/10000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -310,24 +903,62 @@ ], "source": [ "# print(f\"정답 > {y_test}\")\n", - "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()" + "def get_score(model):\n", + " x_train, y_train, x_test, y_test = get_data()\n", + " \n", + " predicted_result = model.predict(x_test)\n", + " predicted_labels = np.argmax(predicted_result, axis=1)\n", + " not_correct = []\n", + " for i in tqdm(range(len(y_test)), desc=\"진행도\"):\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)}/{len(y_test)}\")\n", + "\n", + " for i in range(3):\n", + " plt.imshow(x_test[not_correct[i]].reshape(28,28), cmap='Greys')\n", + " plt.show() \n", + " \n", + "get_score(auto_tuning(n_particles=30, maxiter=1000, c0=0.5, c1=1.5, w=0.75))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fc2d7044", + "metadata": {}, + "outputs": [], + "source": [ + "def default_mnist(epochs=5):\n", + " x_train, y_train, x_test, y_test = get_data()\n", + " model = make_model()\n", + " \n", + " model.compile(loss='mse', optimizer='adam', metrics=['accuracy'])\n", + " wei = model.get_weights()\n", + " model.set_weights(wei)\n", + " score = model.evaluate(x_test, y_test, verbose=2)\n", + " print(f\"score : {score}\")\n", + " # hist = model.fit(x_train, y_train, epochs=epochs, batch_size=32, verbose=1)\n", + " # print(hist.history['loss'][-1])\n", + " # print(hist.history['accuracy'][-1])\n", + "\n", + " # predicted_result = model.predict(x_test)\n", + " # predicted_labels = np.argmax(predicted_result, axis=1)\n", + " # not_correct = []\n", + " # for i in tqdm(range(len(y_test)), desc=\"진행도\"):\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)}/{len(y_test)}\")\n", + "# default_mnist()" ] }, { "cell_type": "code", "execution_count": null, - "id": "fc2d7044", + "id": "27024a0b", "metadata": {}, "outputs": [], "source": [] diff --git a/mnist.py b/mnist.py new file mode 100644 index 0000000..fe8fbf0 --- /dev/null +++ b/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)) + +# %% + + + diff --git a/pso_bp.py b/pso_bp.py new file mode 100644 index 0000000..5502687 --- /dev/null +++ b/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() diff --git a/pso.py b/pso_meta.py similarity index 100% rename from pso.py rename to pso_meta.py diff --git a/pso_tf.py b/pso_tf.py index f0d5f6a..0e98b6d 100644 --- a/pso_tf.py +++ b/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]) - self.model.fit(x_train, y_train, epochs=epoch, - verbose=0, validation_data=(x_test, y_test)) - self.particles_weights[i] = self.model.get_weights() - + 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[0] < self.p_best_score[i]: - self.p_best_score[i] = score[0] - self.p_best[i] = self.particles_weights[i] - if score[0] < self.g_best_score: - self.g_best_score = score[0] + 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.copy()) + self.g_history.append(self.g_best) + self.g_best_score_history.append( + self.g_best_score) - self.score = score[0] - loss = score[0] - acc = score[1] + self.score = score + self.all_cost_history[i].append(score) # 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() diff --git a/pso_tuning.py b/pso_tuning.py new file mode 100644 index 0000000..fa267ce --- /dev/null +++ b/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)}") + + +# %% diff --git a/readme.md b/readme.md index 03093ee..f10c78e 100644 --- a/readme.md +++ b/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를 향해서 상승하는 현상이 나타난다. +>
+> 따라서 weights의 이동 방법을 더 탐구하거나, weights를 초기화 할때 random 중요도를 좀더 노이즈가 적게 생성하는 방향을 모색해야할 것 같다. ### 개인적인 생각 > 머신러닝 분류 방식에 존재하는 random forest 방식을 이용하여, 오차역전파 함수를 최적화 하는 방법이 있을것 같습니다 +>
> > > pso 와 random forest 방식이 매우 유사하다고 생각하여 학습할 때 뿐만 아니라 예측 할 때도 이러한 방식으로 사용할 수 있을 것 같습니다 diff --git a/readme.png b/readme.png new file mode 100644 index 0000000..45685b1 Binary files /dev/null and b/readme.png differ diff --git a/xor.ipynb b/xor.ipynb index 948dd9a..cb86049 100644 --- a/xor.ipynb +++ b/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", - " super().__init__(name, **kwargs)\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", - " super().__init__(name, **kwargs)\n" + "init particles position: 100%|██████████| 15/15 [00:00<00:00, 85.12it/s]\n", + "init velocities: 100%|██████████| 15/15 [00:00<00:00, 46465.70it/s]\n", + "Iteration 0 / 10: 100%|##########| 15/15 [00:05<00:00, 2.63it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "None\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", - "4 particle score : 0.2513682246208191\n", - "0 particle score : 0.26079031825065613\n", - "1 particle score : 0.24931921064853668\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", - "1 particle score : 0.26747316122055054\n", - "2 particle score : 0.36957648396492004\n", - "3 particle score : 0.19372068345546722\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", - "3 particle score : 0.37263113260269165\n", - "4 particle score : 0.47822105884552\n", - "0 particle score : 0.37611791491508484\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", - "0 particle score : 0.05194556713104248\n", - "1 particle score : 0.3102635443210602\n", - "2 particle score : 0.31894028186798096\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", - "2 particle score : 0.003701586974784732\n", - "3 particle score : 0.0026527238078415394\n", - "4 particle score : 0.0430503748357296\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", - "4 particle score : 0.21686825156211853\n", - "0 particle score : 4.901693273495766e-07\n", - "1 particle score : 0.003860481781885028\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", - "1 particle score : 2.8646991268033162e-05\n", - "2 particle score : 1.0552450024903237e-09\n", - "3 particle score : 3.566808572941227e-07\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", - "3 particle score : 2.485284791549705e-14\n", - "4 particle score : 2.431787924306583e-26\n", - "0 particle score : 3.854774978241029e-18\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", - "0 particle score : 9.170106118851775e-37\n", - "1 particle score : 0.49933725595474243\n", - "2 particle score : 0.43209874629974365\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", - "2 particle score : 0.25\n", - "3 particle score : 0.0\n", - "4 particle score : 0.0\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", - "4 particle score : 0.25\n", - "0 particle score : 0.0\n", - "1 particle score : 0.0\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", - "1 particle score : 0.25\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", - "1 particle score : 0.0\n", - "2 particle score : 0.0\n", - "3 particle score : 0.0\n", - "4 particle score : 0.5\n", - "0 particle score : 1.2923532081356227e-22\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", - "0 particle score : 0.4959273338317871\n", - "1 particle score : 0.5\n", - "2 particle score : 0.5\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", - "2 particle score : 0.5\n", - "3 particle score : 0.5\n", - "4 particle score : 0.5\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", - "4 particle score : 0.25\n", - "0 particle score : 0.0\n", - "1 particle score : 0.5\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", - "1 particle score : 0.25\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", - "1 particle score : 0.25\n", - "2 particle score : 0.25\n", - "3 particle score : 0.25\n", - "4 particle score : 0.25\n", - "0 particle score : 0.5760642290115356\n", - "1 particle score : 0.25\n", - "2 particle score : 0.25000467896461487\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.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", + "loss : 0.2620863338311513 | acc : 0.5 | best loss : 0.24143654108047485\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iteration 1 / 10: 100%|##########| 15/15 [00:05<00:00, 2.69it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss : 0.24147300918896994 | acc : 0.6333333333333333 | best loss : 0.20360520482063293\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iteration 2 / 10: 100%|##########| 15/15 [00:05<00:00, 2.72it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss : 0.211648628115654 | acc : 0.65 | best loss : 0.17383326590061188\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iteration 3 / 10: 100%|##########| 15/15 [00:05<00:00, 2.72it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss : 0.21790608167648315 | acc : 0.6833333333333333 | best loss : 0.16785581409931183\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iteration 4 / 10: 100%|##########| 15/15 [00:05<00:00, 2.73it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss : 0.20557119349638622 | acc : 0.7333333333333333 | best loss : 0.16668711602687836\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iteration 5 / 10: 100%|##########| 15/15 [00:05<00:00, 2.68it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss : 0.20823073089122773 | acc : 0.7 | best loss : 0.16668711602687836\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iteration 6 / 10: 100%|##########| 15/15 [00:05<00:00, 2.53it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss : 0.21380058924357095 | acc : 0.7166666666666667 | best loss : 0.16668711602687836\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iteration 7 / 10: 100%|##########| 15/15 [00:06<00:00, 2.30it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss : 0.2561836312214533 | acc : 0.6833333333333333 | best loss : 0.16667115688323975\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iteration 8 / 10: 100%|##########| 15/15 [00:05<00:00, 2.55it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss : 0.30372582376003265 | acc : 0.65 | best loss : 0.16667115688323975\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Iteration 9 / 10: 100%|##########| 15/15 [00:05<00:00, 2.65it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss : 0.281868569056193 | acc : 0.7 | best loss : 0.16667115688323975\n", + "1/1 [==============================] - 0s 26ms/step\n", + "[[0. ]\n", + " [0.66422266]\n", + " [0.6642227 ]\n", + " [0.6642227 ]]\n", "[[0]\n", " [1]\n", " [1]\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", - " [ 3.2274616]], dtype=float32), array([0.40823892], dtype=float32)], [array([[-6.749437, -5.01979 ],\n", - " [ 9.477569, 9.011221]], dtype=float32), array([ 1.0140182, -5.089527 ], dtype=float32), array([[-5.9527373],\n", - " [ 8.538484 ]], dtype=float32), array([0.8423419], dtype=float32)], [array([[-4.4376955, -7.542317 ],\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" + " [0]]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\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", - "\n", - "best_weights, score = pso_xor.optimize(x, y, x_test, y_test, maxiter=30)\n", + "best_weights, score = pso_xor.optimize(x, y, x_test, y_test, maxiter=10, epochs=20)\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,