Небольшие правки 2.0

labworks/LW1/report.md

@@ -0,0 +1,416 @@
+# Отчет по ЛР1
+
+Коновалова Алёна, Ильинцева Любовь, А-01-22
+
+## 1. Настройка созданного блокнота и импорт библиотек и модулей
+
+Импортируем библиотеки и модули.
+
+```py
+import os
+os.chdir('/content/drive/MyDrive/Colab Notebooks')
+
+from tensorflow import keras
+import matplotlib.pyplot as plt
+import numpy as np
+import sklearn
+
+from keras.utils import to_categorical
+#from keras.utils import np_utils
+from keras.models import Sequential
+from keras.layers import Dense
+```
+## 2. Загрузка набор данных
+
+Загрузим набор данных MNIST, содержащий размеченные изображения рукописных цифр.
+
+```py
+from keras.datasets import mnist
+(X_train, y_train), (X_test, y_test) = mnist.load_data()
+```
+
+
+**Вывод:**
+```bash
+Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
+```
+
+## 3. Разбиение набора данных на обучающие и тестовые данные и вывод размерностей полученных данных
+
+Разобьем набор данных на обучающие и тестовые данные в соотношении 60000:10000 элементов.
+
+```py
+# создание своего разбиения датасета
+from sklearn.model_selection import train_test_split
+# объединяем в один набор
+X = np.concatenate((X_train, X_test))
+y = np.concatenate((y_train, y_test))
+# разбиваем по вариантам
+X_train, X_test, y_train, y_test = train_test_split(X, y,
+                                                    test_size = 10000,
+                                                    train_size = 60000,
+                                                    random_state = 31)
+```
+
+Выведем размерности.
+
+```py
+print('Shape of X train:', X_train.shape)
+print('Shape of y train:', y_train.shape)
+```
+
+
+**Вывод:**
+```bash
+Shape of X train: (60000, 28, 28)
+Shape of y train: (60000,)
+```
+
+
+## 4. Вывод 4 элементов обучающих данных
+
+Выведем изображения и их метки.
+
+```py
+for i in range(4):
+  plt.imshow(X_train[i],cmap=plt.get_cmap('gray'))
+  plt.show()
+
+  print(y_train[i])
+```
+
+
+**Вывод:**
+
+![5](train_4_5.png)
+
+
+![1](train_4_1.png)
+
+
+![0](train_4_0.1.png)
+
+
+![0](train_4_0.2.png)
+
+
+
+## 5. Предобработка данных
+
+Развернем каждое входное изображение 28*28 в вектор 784, для того, чтобы их можно было подать на вход нейронной сети.
+
+```py
+num_pixels = X_train.shape[1] * X_train.shape[2]
+X_train = X_train.reshape(X_train.shape[0], num_pixels) / 255
+X_test = X_test.reshape(X_test.shape[0], num_pixels) / 255
+print('Shape of transformed X train:', X_train.shape)
+```
+
+**Вывод:**
+```bash
+Shape of transformed X train: (60000, 784)
+```
+
+Проведем предобработку выходных данных. Переведем выходные метки по принципу one-hot.
+
+
+```py
+y_train = to_categorical(y_train)
+y_test = to_categorical(y_test)
+print('Shape of transformed y train:', y_train.shape)
+num_classes = y_train.shape[1]
+```
+
+**Вывод:**
+```bash
+Shape of transformed y train: (60000, 10)
+```
+
+## 6. Реализация модели однослойной нейронной сети
+
+1. Создадим модель и объявим ее объектом класса *Sequental*.
+
+```py
+model = Sequential()
+```
+2. Добавим выходной слой и скомпилируем модель.
+
+```py
+model.add(Dense(units=num_classes, activation='softmax'))
+
+model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy'])
+```
+
+3. Выведем информацию об архитектуре модели и обучим ее
+
+```py
+print(model.summary())
+H = model.fit(X_train, y_train, validation_split=0.1, epochs=50)
+```
+
+**Вывод:**
+```bash
+Model: "sequential"
+
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
+┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
+┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
+│ dense (Dense)                   │ ?                      │   0 (unbuilt) │
+└─────────────────────────────────┴────────────────────────┴───────────────┘
+
+Total params: 0 (0.00 B)
+
+Trainable params: 0 (0.00 B)
+ 
+Non-trainable params: 0 (0.00 B)
+
+
+None
+Epoch 1/50
+1688/1688 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - accuracy: 0.7060 - loss: 1.1734 - val_accuracy: 0.8710 - val_loss: 0.5186
+Epoch 2/50
+1688/1688 ━━━━━━━━━━━━━━━━━━━━ 3s 2ms/step - accuracy: 0.8774 - loss: 0.4847 - val_accuracy: 0.8860 - val_loss: 0.4319
+Epoch 3/50
+1688/1688 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - accuracy: 0.8904 - loss: 0.4151 - val_accuracy: 0.8912 - val_loss: 0.3966
+Epoch 4/50
+1688/1688 ━━━━━━━━━━━━━━━━━━━━ 5s 2ms/step - accuracy: 0.8973 - loss: 0.3828 - val_accuracy: 0.8947 - val_loss: 0.3761
+Epoch 5/50
+1688/1688 ━━━━━━━━━━━━━━━━━━━━ 3s 2ms/step - accuracy: 0.9000 - loss: 0.3700 - val_accuracy: 0.8998 - val_loss: 0.3625
+Epoch 6/50
+1688/1688 ━━━━━━━━━━━━━━━━━━━━ 9s 4ms/step - accuracy: 0.9021 - loss: 0.3542 - val_accuracy: 0.9018 - val_loss: 0.3535
+...
+Epoch 49/50
+1688/1688 ━━━━━━━━━━━━━━━━━━━━ 6s 2ms/step - accuracy: 0.9250 - loss: 0.2693 - val_accuracy: 0.9178 - val_loss: 0.2900
+Epoch 50/50
+1688/1688 ━━━━━━━━━━━━━━━━━━━━ 6s 2ms/step - accuracy: 0.9273 - loss: 0.2634 - val_accuracy: 0.9157 - val_loss: 0.2896
+```
+
+4. Выведем график ошибки по эпохам
+
+```py
+plt.plot(H.history['loss'])
+plt.plot(H.history['val_loss'])
+plt.grid()
+plt.xlabel('Epochs')
+plt.ylabel('loss')
+plt.legend(['train_loss', 'val_loss'])
+plt.title('Loss by epochs')
+plt.show()
+```
+
+**Вывод:**
+
+![График ошибки по эпохам](plot_0_hidden_layer.png)
+
+
+
+## 7. Оценка работы модели на тестовых данных
+
+```py
+scores = model.evaluate(X_test, y_test)
+print('Loss on test data:', scores[0])
+print('Accuracy on test data:', scores[1])
+```
+
+**Вывод:**
+```bash
+313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9165 - loss: 0.2995
+Loss on test data: 0.28918400406837463
+Accuracy on test data: 0.9185000061988831
+```
+
+
+## 8. Обучение и тестирование модели с одним скрытым слоем
+
+Проведем тестирование модели при 100, 300, 500 нейронов в скрытом слое. В качестве функции активации нейронов в скрытом слое будем использовать функцию sigmoid.
+
+По метрике качества классификации выберем наилучшее количество нейронов в скрытом слое.
+
+1. Модель со 100 нейронами в скрытом слое
+
+![График ошибки по эпохам со 100 нейронами в скрытом слое](plot_1_hidden_layer_100.png)
+
+```bash
+Loss on test data: 0.20470060408115387
+Accuracy on test data: 0.9412999749183655
+```
+
+2. Модель с 300 нейронами в скрытом слое
+
+![График ошибки по эпохам с 300 нейронами в скрытом слое](plot_1_hidden_layer_300.jpg)
+
+```bash
+Loss on test data: 0.23246125876903534
+Accuracy on test data: 0.9337999820709229
+```
+
+3. Модель с 500 нейронами в скрытом слое
+
+![График ошибки по эпохам с 500 нейронами в скрытом слое](plot_1_hidden_layer_500.jpg)
+
+```bash
+Loss on test data: 0.24853046238422394
+Accuracy on test data: 0.9283999800682068
+```
+
+По результирующим метрикам видно, что наилучшее количество нейронов - 100.
+
+
+## 9. Обучение и тестирование модели с двумя скрытыми слоями
+
+Добавим к нашей модели со 100 нейронами в первом скрытом слое второй скрытый слой. Проведем тестирование при 50 и 100 нейронах во втором скрытом слое. В качестве функции активации нейронов во втором скрытом слое будем использовать функцию sigmoid.
+
+1. Модель с 50 нейронами в скрытом слое
+
+![График ошибки по эпохам с 50 нейронами в скрытом слое](plot_2_hidden_layer_50.jpg)
+
+```bash
+Loss on test data: 0.19981178641319275
+Accuracy on test data: 0.9387000203132629
+```
+
+2. Модель со 100 нейронами в скрытом слое
+
+![График ошибки по эпохам со 100 нейронами в скрытом слое](plot_2_hidden_layer_100.jpg)
+
+```bash
+Loss on test data: 0.19404223561286926
+Accuracy on test data: 0.9413999915122986
+```
+
+## 10. Результаты исследования
+
+```
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┓
+┃ Слои                            ┃ Метрика loss          ┃  Accuracy           ┃
+┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━┩
+│ 0                               │ 0.28918400406837463   │ 0.9185000061988831  │
+├─────────────────────────────────┼───────────────────────┼─────────────────────┤
+│ 1 (100 нейронов)                │ 0.20470060408115387   │ 0.9412999749183655  │
+├─────────────────────────────────┼───────────────────────┼─────────────────────┤
+│ 1 (300 нейронов)                │ 0.23246125876903534   │ 0.9337999820709229  │
+├─────────────────────────────────┼───────────────────────┼─────────────────────┤
+│ 1 (500 нейронов)                │ 0.24853046238422394   │ 0.9283999800682068  │
+├─────────────────────────────────┼───────────────────────┼─────────────────────┤
+│ 2 (100, 50 нейронов)            │ 0.19981178641319275   │ 0.9387000203132629  │
+├─────────────────────────────────┼───────────────────────┼─────────────────────┤
+│ 2 (100, 100 нейронов)           │ 0.19404223561286926   │ 0.9413999915122986  │
+└─────────────────────────────────┴───────────────────────┴─────────────────────┘
+```
+
+По результатам исследования мы видим, что наилучшие результаты достигаются при архитектуре при 100 нейронах на каждом скрытом слое.
+
+## 11. Сохранение наилучшей модели на диск
+
+```py
+filepath='/content/drive/MyDrive/Colab Notebooks/best_model.keras'
+model_2_100.save(filepath)
+```
+
+## 12. Вывод тестовых изображений
+
+```py
+n = 31
+result = model.predict(X_test[n:n+1])
+print('NN output:', result)
+plt.imshow(X_test[n].reshape(28,28), cmap=plt.get_cmap('gray'))
+plt.show()
+print('Real mark: ', str(np.argmax(y_test[n])))
+print('NN answer: ', str(np.argmax(result)))
+```
+
+**Вывод:**
+
+```bash
+NN output: [[4.3196760e-06 1.3248758e-04 9.4383031e-02 2.8113697e-03 2.2433515e-04 4.0835417e-05 5.3229469e-05 8.9428437e-01 3.7515254e-04 7.6909573e-03]]
+```
+
+
+![alt text](test_12_7.png)
+
+```bash
+Real mark:  7
+NN answer:  7
+```
+
+```py
+n = 123
+result = model.predict(X_test[n:n+1])
+print('NN output:', result)
+plt.imshow(X_test[n].reshape(28,28), cmap=plt.get_cmap('gray'))
+plt.show()
+print('Real mark: ', str(np.argmax(y_test[n])))
+print('NN answer: ', str(np.argmax(result)))
+```
+
+**Вывод:**
+
+```bash
+NN output: [[4.8947215e-05 3.4176528e-03 8.6587053e-05 9.2398334e-01 5.9264214e-05
+  5.0175749e-02 8.9853020e-06 1.3068309e-03 7.7676596e-03 1.3145068e-02]]
+```
+
+![alt text](test_12_3.png)
+
+```bash
+Real mark:  3
+NN answer:  3
+```
+
+
+## 13. Тестирование модели на собственных изображениях цифр
+
+1. Создадим собственные изображения рукописных цифр "1" и "0"
+
+![alt text](created_0.png)
+
+
+![alt text](created_1.png)
+
+2. Загрузим, предобработаем и подадим на вход обученной нейросети собственные изображения
+
+```py
+# вывод собственного изображения
+plt.imshow(test_img, cmap=plt.get_cmap('gray'))
+plt.show()
+# предобработка
+test_img = test_img / 255
+test_img = test_img.reshape(1, num_pixels)
+# распознавание
+result = model.predict(test_img)
+print('I think it\'s ', np.argmax(result))
+```
+
+**Вывод:**
+
+![alt text](result_0.png)
+
+```bash
+I think it's  0
+```
+
+![alt text](result_1.png)
+
+```bash
+I think it's  1
+```
+
+
+## 14. Тестирование модели на собственных изображениях цифр, повернутых на 90 градусов
+
+**Результат тестирования:**
+
+
+![alt text](result_0_90.png)
+
+```bash
+I think it's  0
+```
+
+![alt text](result_1_90.png)
+
+```bash
+I think it's  4
+```
+
+*Таким образом, нейросеть смогла определить 0 из-за простой и неизменной формы при повороте, однако подав на вход перевернутую 1, нейросеть не смогла корренто определить цифру.*

labworks/LW2/lab02_lib.py

@@ -29,14 +29,12 @@ from pandas import DataFrame
 from sklearn.metrics import precision_score, recall_score, f1_score, confusion_matrix
 from tensorflow.keras.models import Sequential
 from tensorflow.keras.layers import Dense, Activation
-from tensorflow.keras.callbacks import Callback
 
 
 
 visual = True
 verbose_show = False
 
-
 # generate 2d classification dataset
 def datagen(x_c, y_c, n_samples, n_features):
 
@@ -93,27 +91,8 @@ class EarlyStoppingOnValue(tensorflow.keras.callbacks.Callback):
             )
         return monitor_value
 
-
-class VerboseEveryNEpochs(Callback):
-    def __init__(self, every_n_epochs=1000, verbose=1):
-        super().__init__()
-        self.every_n_epochs = every_n_epochs
-        self.verbose = verbose
-
-    def on_epoch_end(self, epoch, logs=None):
-        if (epoch + 1) % self.every_n_epochs == 0:
-            if self.verbose:
-                print(f"\nEpoch {epoch + 1}/{self.params['epochs']}")
-                if logs:
-                    log_str = ", ".join([f"{k}: {v:.4f}" for k, v in logs.items()])
-                    print(f" - {log_str}")
-
-
 #создание и обучение модели автокодировщика
-def create_fit_save_ae(cl_train, ae_file, irefile, epohs, verbose_show, patience, **kwargs):
-    verbose_every_n_epochs = kwargs.get('verbose_every_n_epochs', 1000)
-    early_stopping_delta = kwargs.get('early_stopping_delta', 0.01)
-    early_stopping_value = kwargs.get('early_stopping_value', 0.0001)
+def create_fit_save_ae(cl_train, ae_file, irefile, epohs, verbose_show, patience):
 
     size = cl_train.shape[1]
     #ans = '2'
@@ -161,28 +140,22 @@ def create_fit_save_ae(cl_train, ae_file, irefile, epohs, verbose_show, patience
 
     optimizer = tensorflow.keras.optimizers.Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, amsgrad=False)
     ae.compile(loss='mean_squared_error', optimizer=optimizer)
+    error_stop = 0.0001
     epo = epohs
 
-
-    verbose = 1 if verbose_show else 0
-
-    early_stopping_callback_on_error = EarlyStoppingOnValue(monitor='loss', baseline=early_stopping_value)
+    early_stopping_callback_on_error = EarlyStoppingOnValue(monitor='loss', baseline=error_stop)
     early_stopping_callback_on_improving = tensorflow.keras.callbacks.EarlyStopping(monitor='loss',
-                                                                                           min_delta=early_stopping_delta, patience = patience,
-                                                                                           verbose=verbose, mode='min',
+                                                                                           min_delta=0.0001, patience = patience,
+                                                                                           verbose=1, mode='auto',
                                                                                            baseline=None,
-                                                                                           restore_best_weights=True)
+                                                                                           restore_best_weights=False)
     history_callback = tensorflow.keras.callbacks.History()
-
+    verbose = 1 if verbose_show else 0
     history_object = ae.fit(cl_train, cl_train,
                                 batch_size=cl_train.shape[0],
                                 epochs=epo,
-                                callbacks=[
-                                  early_stopping_callback_on_error, 
-                                  history_callback,
-                                  early_stopping_callback_on_improving,
-                                  VerboseEveryNEpochs(every_n_epochs=verbose_every_n_epochs),
-                                ],
+                                callbacks=[early_stopping_callback_on_error, history_callback,
+                                early_stopping_callback_on_improving],
                                 verbose=verbose)
     ae_trainned = ae
     ae_pred = ae_trainned.predict(cl_train)
@@ -565,4 +538,4 @@ def ire_plot(title, IRE_test, IREth, ae_name):
     plt.gcf().savefig('out/IRE_' + title + ae_name + '.png')
     plt.show()
 
-    return
+    return