блокнот без выводов

Добавление отчета, блокнота и изображений

labworks/LW1/report.md

@@ -0,0 +1,550 @@
+# Отчет по лабораторной работе №1
+Текотова Виктория, Секирин Артем, А-02-22
+
+## 1. В среде GoogleColab создали блокнот(notebook.ipynb).
+```
+import os
+os.chdir('/content/drive/MyDrive/Colab Notebooks')
+```
+
+* импорт модулей 
+```
+from tensorflow import keras
+import matplotlib.pyplot as plt
+import numpy as np
+import sklearn
+```
+
+## 2. Загрузка датасета MNIST
+```
+from keras.datasets import mnist
+(X_train,y_train),(X_test,y_test)=mnist.load_data()
+```
+
+## 3. Разбиение набора данных на обучающие и тестовые 
+```
+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=3)
+```
+
+* Вывод размерностей
+```
+print('ShapeofXtrain:',X_train.shape)
+print('Shapeofytrain:',y_train.shape)
+print('ShapeofXtrain:',X_test.shape)
+print('Shapeofytrain:',y_test.shape)
+```
+
+> ShapeofXtrain: (60000, 784)
+> Shapeofytrain: (60000, 10)
+> ShapeofXtrain: (10000, 784)
+> Shapeofytrain: (10000, 10)
+
+## 4. Вывод элементов обучающих данных
+* Создаем subplot для 4 изображений
+```
+for i in range(4):
+    plt.subplot(1, 4, i+1)  # 1 строка, n столбцов
+    plt.imshow(X_train[i], cmap='gray')
+    plt.axis('off')  # убрать оси
+    plt.title(y_train[i])  # метка под картинкой
+
+plt.show()
+```
+
+![отображение элементов](p4.png)
+
+## 5. Предобработка данных
+* развернем каждое изображение 28*28 в вектор 784
+```
+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('ShapeoftransformedXtrain:',X_train.shape)
+```
+
+> ShapeoftransformedXtrain: (60000, 784)
+
+* переведем метки в one-hot
+```
+from keras.utils import to_categorical
+y_train=to_categorical(y_train)
+y_test=to_categorical(y_test)
+print('Shapeoftransformedytrain:',y_train.shape)
+num_classes=y_train.shape[1]
+```
+
+> Shapeoftransformedytrain: (60000, 10)
+* Вывод размерностей
+```
+print('ShapeofXtrain:',X_train.shape)
+print('Shapeofytrain:',y_train.shape)
+print('ShapeofXtrain:',X_test.shape)
+print('Shapeofytrain:',y_test.shape)
+```
+> ShapeofXtrain: (60000, 784)
+> Shapeofytrain: (60000, 10)
+> ShapeofXtrain: (10000, 784)
+> Shapeofytrain: (10000, 10)
+
+## 6. Реализация и обучение однослойной нейронной сети
+```
+from keras.models import Sequential
+from keras.layers import Dense
+```
+
+* 6.1. создаем модель - объявляем ее объектом класса Sequential
+```
+model=Sequential()
+model.add(Dense(input_dim=num_pixels,units=num_classes,activation='softmax'))
+```
+* 6.2. компилируем модель
+```
+model.compile(loss='categorical_crossentropy',optimizer='sgd',metrics=['accuracy'])
+```
+* Вывод информации об архитектуре модели
+```
+print(model.summary())
+```
+>Model: "sequential"
+>┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
+>┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
+>┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
+>│ dense (Dense)                   │ (None, 10)             │         7,850 │
+>└─────────────────────────────────┴────────────────────────┴───────────────┘
+> Total params: 7,850 (30.66 KB)
+> Trainable params: 7,850 (30.66 KB)
+> Non-trainable params: 0 (0.00 B)
+>None
+
+* Обучаем модель
+```
+H=model.fit(X_train,y_train,validation_split=0.1,epochs=50)
+```
+
+* Выводим график функции ошибки
+```
+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('Lossbyepochs')
+plt.show()
+```
+
+![график функции ошибки](p6.png)
+
+## 7. Применение модели к тестовым данным
+```
+scores=model.evaluate(X_test,y_test)
+print('Loss on test data:',scores[0])
+print('Accuracy on test data:',scores[1])
+```
+
+> 313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9207 - loss: 0.2944
+> Loss on test data: 0.2864772379398346
+> Accuracy on test data: 0.9229999780654907
+
+## 8. Добавили один скрытый слой и повторили п. 6-7 
+* при 100 нейронах в скрытом слое
+```
+model_1h100=Sequential()
+model_1h100.add(Dense(units=100,input_dim=num_pixels,activation='sigmoid'))
+model_1h100.add(Dense(units=num_classes,activation='softmax'))
+model_1h100.compile(loss='categorical_crossentropy',optimizer='sgd',metrics=['accuracy'])
+```
+* Вывод информации об архитектуре модели
+```
+print(model_1h100.summary())
+```
+> Model: "sequential_1"
+> ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
+> ┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
+> ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
+> │ dense_1 (Dense)                 │ (None, 100)            │        78,500 │
+> ├─────────────────────────────────┼────────────────────────┼───────────────┤
+> │ dense_2 (Dense)                 │ (None, 10)             │         1,010 │
+> └─────────────────────────────────┴────────────────────────┴───────────────┘
+>  Total params: 79,510 (310.59 KB)
+>  Trainable params: 79,510 (310.59 KB)
+>  Non-trainable params: 0 (0.00 B)
+> None
+
+* Обучаем модель
+```
+H=model_1h100.fit(X_train,y_train,validation_split=0.1,epochs=50)
+```
+
+* Выводим график функции ошибки
+```
+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('Lossbyepochs')
+plt.show()
+```
+
+![график функции ошибки](p8_100.png)
+* Оценка качества работы модели на тестовых данных
+```
+scores=model_1h100.evaluate(X_test,y_test)
+print('Loss on test data:',scores[0])
+print('Accuracy on test data:',scores[1])
+```
+
+> 313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - accuracy: 0.9380 - loss: 0.2142
+> Loss on test data: 0.2046738713979721
+> Accuracy on test data: 0.942799985408783
+
+* при 300 нейронах в скрытом слое
+```
+model_1h300=Sequential()
+model_1h300.add(Dense(units=300,input_dim=num_pixels,activation='sigmoid'))
+model_1h300.add(Dense(units=num_classes,activation='softmax'))
+model_1h300.compile(loss='categorical_crossentropy',optimizer='sgd',metrics=['accuracy'])
+```
+* Вывод информации об архитектуре модели
+```
+print(model_1h300.summary())
+```
+> Model: "sequential_2"
+> ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
+> ┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
+> ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
+> │ dense_3 (Dense)                 │ (None, 300)            │       235,500 │
+> ├─────────────────────────────────┼────────────────────────┼───────────────┤
+> │ dense_4 (Dense)                 │ (None, 10)             │         3,010 │
+> └─────────────────────────────────┴────────────────────────┴───────────────┘
+>  Total params: 238,510 (931.68 KB)
+>  Trainable params: 238,510 (931.68 KB)
+>  Non-trainable params: 0 (0.00 B)
+> None
+
+* Обучаем модель
+```
+H=model_1h300.fit(X_train,y_train,validation_split=0.1,epochs=50)
+```
+
+* Выводим график функции ошибки
+```
+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('Lossbyepochs')
+plt.show()
+```
+
+![график функции ошибки](p8_300.png)
+
+* Оценка качества работы модели на тестовых данных
+```
+scores=model_1h300.evaluate(X_test,y_test)
+print('Loss on test data:',scores[0])
+print('Accuracy on test data:',scores[1])
+```
+
+>313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9328 - loss: 0.2403
+>Loss on test data: 0.23027946054935455
+>Accuracy on test data: 0.9363999962806702
+
+* при 500 нейронах в скрытом слое
+```
+model_1h500=Sequential()
+model_1h500.add(Dense(units=500,input_dim=num_pixels,activation='sigmoid'))
+model_1h500.add(Dense(units=num_classes,activation='softmax'))
+model_1h500.compile(loss='categorical_crossentropy',optimizer='sgd',metrics=['accuracy'])
+```
+* Вывод информации об архитектуре модели
+```
+print(model_1h500.summary())
+```
+>Model: "sequential_3"
+>┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
+>┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
+>┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
+>│ dense_5 (Dense)                 │ (None, 500)            │       392,500 │
+>├─────────────────────────────────┼────────────────────────┼───────────────┤
+>│ dense_6 (Dense)                 │ (None, 10)             │         5,010 │
+>└─────────────────────────────────┴────────────────────────┴───────────────┘
+> Total params: 397,510 (1.52 MB)
+> Trainable params: 397,510 (1.52 MB)
+> Non-trainable params: 0 (0.00 B)
+>None
+
+* Обучаем модель
+```
+H=model_1h500.fit(X_train,y_train,validation_split=0.1,epochs=50)
+```
+
+* Выводим график функции ошибки
+```
+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('Lossbyepochs')
+plt.show()
+```
+
+![график функции ошибки](p8_500.png)
+
+* Оценка качества работы модели на тестовых данных
+```
+scores=model_1h500.evaluate(X_test,y_test)
+print('Loss on test data:',scores[0])
+print('Accuracy on test data:',scores[1])
+```
+>313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9265 - loss: 0.2585
+>Loss on test data: 0.24952808022499084
+>Accuracy on test data: 0.9307000041007996
+
+Как мы видим, лучшая метрика получилась равной 0.942799985408783 при архитектуре со 100 нейронами в скрытом слое, поэтому для дальнейших пунктов используем ее.
+
+## 9. Добавили второй скрытый слой
+* при 50 нейронах во втором скрытом слое
+```
+model_1h100_2h50=Sequential()
+model_1h100_2h50.add(Dense(units=100,input_dim=num_pixels,activation='sigmoid'))
+model_1h100_2h50.add(Dense(units=50,activation='sigmoid'))
+model_1h100_2h50.add(Dense(units=num_classes,activation='softmax'))
+model_1h100_2h50.compile(loss='categorical_crossentropy',optimizer='sgd',metrics=['accuracy'])
+```
+* Вывод информации об архитектуре модели
+```
+print(model_1h100_2h50.summary())
+```
+> Model: "sequential_4"
+> ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
+> ┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
+> ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
+> │ dense_7 (Dense)                 │ (None, 100)            │        78,500 │
+> ├─────────────────────────────────┼────────────────────────┼───────────────┤
+> │ dense_8 (Dense)                 │ (None, 50)             │         5,050 │
+> ├─────────────────────────────────┼────────────────────────┼───────────────┤
+> │ dense_9 (Dense)                 │ (None, 10)             │           510 │
+> └─────────────────────────────────┴────────────────────────┴───────────────┘
+>  Total params: 84,060 (328.36 KB)
+>  Trainable params: 84,060 (328.36 KB)
+>  Non-trainable params: 0 (0.00 B)
+> None
+
+* Обучаем модель
+```
+H=model_1h100_2h50.fit(X_train,y_train,validation_split=0.1,epochs=50)
+```
+
+* Выводим график функции ошибки
+```
+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('Lossbyepochs')
+plt.show()
+```
+
+![график функции ошибки](p9_50.png)
+
+* Оценка качества работы модели на тестовых данных
+```
+scores=model_1h100_2h50.evaluate(X_test,y_test)
+print('Loss on test data:',scores[0])
+print('Accuracy on test data:',scores[1])
+```
+
+>313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9388 - loss: 0.2173
+>Loss on test data: 0.20536193251609802
+>Accuracy on test data: 0.9416000247001648
+
+* при 100 нейронах во втором скрытом слое
+```
+model_1h100_2h100=Sequential()
+model_1h100_2h100.add(Dense(units=100,input_dim=num_pixels,activation='sigmoid'))
+model_1h100_2h100.add(Dense(units=50,activation='sigmoid'))
+model_1h100_2h100.add(Dense(units=num_classes,activation='softmax'))
+model_1h100_2h100.compile(loss='categorical_crossentropy',optimizer='sgd',metrics=['accuracy'])
+```
+* Вывод информации об архитектуре модели
+```
+print(model_1h100_2h100.summary())
+```
+>Model: "sequential_5"
+>┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
+>┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
+>┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
+>│ dense_10 (Dense)                │ (None, 100)            │        78,500 │
+>├─────────────────────────────────┼────────────────────────┼───────────────┤
+>│ dense_11 (Dense)                │ (None, 50)             │         5,050 │
+>├─────────────────────────────────┼────────────────────────┼───────────────┤
+>│ dense_12 (Dense)                │ (None, 10)             │           510 │
+>└─────────────────────────────────┴────────────────────────┴───────────────┘
+> Total params: 84,060 (328.36 KB)
+> Trainable params: 84,060 (328.36 KB)
+> Non-trainable params: 0 (0.00 B)
+>None
+
+* Обучаем модель
+```
+H=model_1h100_2h100.fit(X_train,y_train,validation_split=0.1,epochs=50)
+```
+
+* Выводим график функции ошибки
+```
+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('Lossbyepochs')
+plt.show()
+```
+
+![график функции ошибки](p9_100.png)
+
+* Оценка качества работы модели на тестовых данных
+```
+scores=model_1h100_2h100.evaluate(X_test,y_test)
+print('Loss on test data:',scores[0])
+print('Accuracy on test data:',scores[1])
+```
+
+>313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - accuracy: 0.9414 - loss: 0.2154
+>Loss on test data: 0.2049565464258194
+>Accuracy on test data: 0.9427000284194946 
+
+Количество	   Количество нейронов в	Количество нейронов во	Значение метрики
+скрытых слоев  первом скрытом слое      втором скрытом слое     качества классификации
+0	                     -	                      -	            0.9229999780654907
+1      	                100	                      -	            0.942799985408783
+1	                    300	                      -	            0.9363999962806702
+1	                    500	                      -	            0.9307000041007996
+2	                    100	                      50	        0.9416000247001648
+2	                    100	                      100	        0.9427000284194946
+
+Из таблицы видно, что лучше всего справились с задачей НС с одним скрытым слоем и 100 нейронами и НС с двумя скрытыми слоями по 100 нейронов.
+Метрика точности достигла почти 95% при достаточно простой архитектуре сетей, это может быть связано с тем, что датасет MNIST имеет только 60,000 обучающих примеров - недостаточно для более сложных архитектур. Также при усложнении архитектуры сети появляется риск переобучения. В нашей задаче мы видим, что при увеличении числа нейронов в скрытых слоях метрика падает.Простая модель лучше обобщает на подобных учебных датасетах, более сложные же архитектуры стоит использовать на более сложных датасетах, например ImageNet.
+
+## 11. Сохранение наилучшей модели на диск
+```
+model_1h100.save('/content/drive/MyDrive/Colab Notebooks/best_model.keras')
+```
+
+## 12. Вывод тестовых изображений и результатов распознаваний
+```
+for i in range(1,3,1):
+  result=model_1h100.predict(X_test[i:i+1])
+  print('NNoutput:',result)
+  plt.imshow(X_test[i].reshape(28,28),cmap=plt.get_cmap('gray'))
+  plt.show()
+  print('Realmark:',str(np.argmax(y_test[i])))
+  print('NNanswer:',str(np.argmax(result)))
+```
+
+> NNoutput: [[1.4195202e-03 1.1157753e-03 1.3601109e-02 1.2154530e-01 4.0756597e-04
+  8.3563459e-01 2.9775328e-03 7.1576833e-05 1.9775130e-02 3.4518384e-03]]
+![изображение](11.png)
+>Realmark: 3
+>NNanswer: 5
+> NNoutput: [[1.1838503e-04 1.7378072e-04 4.7975280e-03 9.3888867e-01 3.9176564e-05
+  3.4841071e-03 1.5808465e-06 1.6603278e-02 1.6292465e-03 3.4264266e-02]]
+![изображение](11_2.png)
+>Realmark: 3
+>NNanswer: 3
+
+## 13. Тестирование на собственных изображениях
+* загрузка 1 собственного изображения
+```
+from PIL import Image
+file_data=Image.open('/content/drive/MyDrive/Colab Notebooks/2.png')
+file_data=file_data.convert('L')
+test_img=np.array(file_data)
+```
+
+* вывод собственного изображения, предобработка, распознавание
+```
+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_1h100.predict(test_img)
+print('Ithinkit\'s',np.argmax(result))
+```
+
+![1 изображение](12_1.png)
+> Ithinkit's 2 
+
+* тест 2 изображения
+```
+from PIL import Image
+file_data=Image.open('/content/drive/MyDrive/Colab Notebooks/5.png')
+file_data=file_data.convert('L')
+test_img=np.array(file_data)
+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_1h100.predict(test_img)
+print('Ithinkit\'s',np.argmax(result))
+```
+
+![2 изображение](12_2.png)
+>Ithinkit's 5
+
+Сеть не ошиблась и корректно распознала обе цифры на изображениях
+
+## 14. Тестирование на собственных повернутых изображениях
+```
+from PIL import Image
+file_data=Image.open('/content/drive/MyDrive/Colab Notebooks/2_1.png')
+file_data=file_data.convert('L')
+test_img=np.array(file_data)
+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_1h100.predict(test_img)
+print('Ithinkit\'s',np.argmax(result))
+```
+![1 изображения перевернутое](14_1.png)
+>Ithinkit's 5
+
+```
+from PIL import Image
+file_data=Image.open('/content/drive/MyDrive/Colab Notebooks/5_1.png')
+file_data=file_data.convert('L')
+test_img=np.array(file_data)
+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_1h100.predict(test_img)
+print('Ithinkit\'s',np.argmax(result))
+```
+
+![2 изображения перевернутое](14_2.png)
+>Ithinkit's 7
+
+При повороте изображений сеть не распознала цифры правильно. Так как она не обучалась на повернутых изображениях.

labworks/LW2/lab02_lib.py

@@ -29,12 +29,14 @@ 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):
 
@@ -91,8 +93,27 @@ 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):
+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)
 
     size = cl_train.shape[1]
     #ans = '2'
@@ -140,22 +161,28 @@ 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
 
-    early_stopping_callback_on_error = EarlyStoppingOnValue(monitor='loss', baseline=error_stop)
+
+    verbose = 1 if verbose_show else 0
+
+    early_stopping_callback_on_error = EarlyStoppingOnValue(monitor='loss', baseline=early_stopping_value)
     early_stopping_callback_on_improving = tensorflow.keras.callbacks.EarlyStopping(monitor='loss',
-                                                                                           min_delta=0.0001, patience = patience,
-                                                                                           verbose=1, mode='auto',
+                                                                                           min_delta=early_stopping_delta, patience = patience,
+                                                                                           verbose=verbose, mode='min',
                                                                                            baseline=None,
-                                                                                           restore_best_weights=False)
+                                                                                           restore_best_weights=True)
     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],
+                                callbacks=[
+                                  early_stopping_callback_on_error, 
+                                  history_callback,
+                                  early_stopping_callback_on_improving,
+                                  VerboseEveryNEpochs(every_n_epochs=verbose_every_n_epochs),
+                                ],
                                 verbose=verbose)
     ae_trainned = ae
     ae_pred = ae_trainned.predict(cl_train)
@@ -538,4 +565,4 @@ def ire_plot(title, IRE_test, IREth, ae_name):
     plt.gcf().savefig('out/IRE_' + title + ae_name + '.png')
     plt.show()
 
-    return
+    return

labworks/LW2/out/AE1_ire_th.txt

@@ -0,0 +1 @@
+1.86

labworks/LW2/out/AE2_ire_th.txt

@@ -0,0 +1 @@
+0.48

labworks/LW2/out/AE3_ire_th.txt

@@ -0,0 +1 @@
+3.1

labworks/LW2/out/result.txt

@@ -0,0 +1,5 @@
+------------Оценка качества AE2 С ПОМОЩЬЮ НОВЫХ МЕТРИК------------
+Approx = 0.44186046511627913
+Excess = 1.263157894736842
+Deficit = 0.0
+Coating = 1.0

labworks/LW2/report.md

@@ -0,0 +1,372 @@
+# Отчет по лабораторной работе №2
+Текотова Виктория, Секирин Артем, А-02-22
+
+# Задание 1.
+## 1. В среде GoogleColab создали блокнот(notebook.ipynb).
+```python
+import os
+os.chdir('/content/drive/MyDrive/Colab Notebooks')
+```
+
+* импорт модулей 
+```python
+import numpy as np
+import lab02_lib as lib
+```
+
+## 2. Генерация датасета
+```python
+data=lib.datagen(1,1,1000,2)
+```
+![отображение датасета](2.png)
+* Вывод данных и размерности
+```python
+print('Исходныеданные:')
+print(data)
+print('Размерностьданных:')
+print(data.shape)
+```
+> Исходные данные:
+> 
+> [[1.13623025 1.07517135]
+> 
+>  [1.03093312 1.06813773]
+> 
+>  [0.97208689 1.0748715 ]
+> 
+>  ...
+>  [1.19215258 0.990978  ]
+> 
+>  [0.95942384 0.94390713]
+> 
+>  [1.04279375 1.03934433]]
+> 
+> Размерность данных:
+> 
+> (1000, 2)
+
+## 3. Создание и обучение автокодировщик AE1
+```python
+patience= 10
+ae1_trained, IRE1, IREth1= lib.create_fit_save_ae(data,'out/AE1.h5','out/AE1_ire_th.txt', 50, True, patience)
+```
+> Задать архитектуру автокодировщиков или использовать архитектуру по умолчанию? (1/2): 1
+> 
+> Задайте количество скрытых слоёв (нечетное число) : 3
+> 
+> Задайте архитектуру скрытых слоёв автокодировщика, например, в виде 3 1 3 : 3 1 3
+> 
+> Epoch 1/50
+> 
+> 1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 1s/step - loss: 1.7463
+> 
+> Epoch 2/50
+> 
+> 1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 32ms/step - loss: 1.7342
+> 
+> ...
+> 
+> Epoch 49/50
+>
+> 1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 51ms/step - loss: 1.2118
+>
+> Epoch 50/50
+>
+> 1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 50ms/step - loss: 1.2019
+
+
+
+## 4. Построение   график   ошибки   реконструкции обучающей   выборки. Вывод  порога  ошибки  реконструкции – порога  обнаружения аномалий.
+```python
+patience= 10
+ae1_trained, IRE1, IREth1= lib.create_fit_save_ae(data,'out/AE1.h5','out/AE1_ire_th.txt', 50, True, patience)
+```
+![График ошибки реконструкции](4.png)
+```python
+print("Порог ошибки реконструкции = ",IREth1)
+```
+> Порог ошибки реконструкции =  0.63
+
+## 5. Создание  и  обучиние  второй  автокодировщик AE2
+```python
+patience= 100
+ae2_trained, IRE2, IREth2= lib.create_fit_save_ae(data,'out/AE2.h5','out/AE2_ire_th.txt', 1000, True, patience)
+lib.ire_plot('training', IRE2, IREth2, 'AE2')
+```
+
+> Задать архитектуру автокодировщиков или использовать архитектуру по умолчанию? (1/2): 2
+>
+> Epoch 1/1000
+>
+> 1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 1s/step - loss: 1.0920
+>
+> Epoch 2/1000
+>
+> 1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 31ms/step - loss: 1.0838
+> 
+> ...
+> 
+> Epoch 454/1000
+>
+> 1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 48ms/step - loss: 0.0103
+>
+> Epoch 455/1000
+>
+> 1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 48ms/step - loss: 0.0103
+
+## 6. Построение   график   ошибки   реконструкции обучающей   выборки. Вывод  порога  ошибки  реконструкции – порога  обнаружения аномалий.
+```python
+lib.ire_plot('training', IRE2, IREth2, 'AE2')
+```
+![График ошибки реконструкции](6.png)
+```python
+print("Порог ошибки реконструкции = ",IREth2)
+```
+> Порог ошибки реконструкции =  0.48
+
+## 7.  Рассчитет характеристик качества обучения EDCA для AE1 и AE2. Визуализация и сравнение области пространства признаков,распознаваемые автокодировщиками AE1 и AE2. Вывод о пригодности AE1 и AE2 для качественного обнаружения аномалий.
+```python
+numb_square= 20
+xx,yy,Z1=lib.square_calc(numb_square,data,ae1_trained,IREth1,'1',True)
+```
+* Качество обучения AE1
+![](7.png)
+> amount:  19
+>
+> amount_ae:  272
+![](7_1.png)
+> Оценка качества AE1
+>
+> IDEAL = 0. Excess:  13.31578947368421
+>
+> IDEAL = 0. Deficit:  0.0
+>
+> IDEAL = 1. Coating:  1.0
+>
+> summa:  1.0
+>
+> IDEAL = 1. Extrapolation precision (Approx):  0.06985294117647059
+
+* Качество обучения AE2
+```python
+numb_square= 20
+xx,yy,Z2=lib.square_calc(numb_square,data,ae2_trained,IREth2,'2',True)
+```
+![](7_2.png)
+> amount:  19
+>
+> amount_ae:  43
+![](7_3.png)
+> Оценка качества AE2
+>
+> IDEAL = 0. Excess:  1.263157894736842
+>
+> IDEAL = 0. Deficit:  0.0
+>
+> IDEAL = 1. Coating:  1.0
+>
+> summa:  1.0
+>
+> IDEAL = 1. Extrapolation precision (Approx):  0.44186046511627913
+
+```python
+lib.plot2in1(data,xx,yy,Z1,Z2)
+```
+![](7_4.png)
+* Вывод: На основе проведенного сравнения можно заключить, что автокодировщик AE2 с пятислойной архитектурой является оптимальным решением, поскольку обеспечивает минимальную ошибку реконструкции по сравнению с более простой моделью AE1.
+## 8. Создание тестовой выборки
+```python
+test_data = np.array([[1.6, 1.2], [1.2, 1], [1.1, 1], [1.5,1.5], [1, 1], [1.5, 1.5]])
+```
+
+## 9. Применение обученных автокодировщиков AE1 и AE2 к тестовым данным
+* Автокодировщик AE1
+```python
+predicted_labels1, ire1 = lib.predict_ae(ae1_trained, data_test, IREth1)
+lib.anomaly_detection_ae(predicted_labels1, ire1, IREth1)
+lib.ire_plot('test', ire1, IREth1, 'AE1')
+```
+* Аномалий не обнаружено
+![График ошибки реконструкции](9.png)
+```python
+predicted_labels2, ire2 = lib.predict_ae(ae2_trained, data_test, IREth2)
+lib.anomaly_detection_ae(predicted_labels2, ire2, IREth2)
+lib.ire_plot('training', IRE2, IREth2, 'AE2')
+```
+* Аномалий не обнаружено
+![График ошибки реконструкции](9_1.png)
+## 10. Визуализировать элементы обучающей и тестовой выборки в областях пространства признаков
+* Построение областей аппроксимации и точек тестового набора
+```python
+lib.plot2in1_anomaly(data, xx, yy, Z1, Z2, data_test)
+```
+![](10.png)
+## 11. Результаты исследования занести в таблицу
+| Модель | Количество скрытых слоев | Количество нейронов в скрытых слоях | Количество эпох обучения | Ошибка MSE_stop | Порог ошибки реконструкции | Excess | Approx   | Аномалии |
+|--------|:------------------------:|:-----------------------------------:|:------------------------:|:---------------:|:--------------------------:|:------:|:--------:|:--------:|
+| AE1    | 3                        | 3 1 3                              | 50                    | 1.2019          | 0.63                       | 13.31   | 0.069 | 0        |
+| AE2    | 5                        | 3 2 1 2 3                          | 1000                    | 0.0103        | 0.48                     | 1.26 | 0.44  | 0        |
+
+
+## 11. Выводы о требованиях
+* Вывод:
+
+Критерии качественного детектирования аномалий:
+
+1.Данные: двумерный формат входных данных
+
+2.Архитектура: наличие bottleneck-слоя уменьшенной размерности
+
+3.Обучение: увеличение эпох при росте сложности сети
+
+4.Качество: MSE_stop ∈ [0,1] и минимальная ошибка реконструкции
+
+5.Метрики: Excess=0, Deficit=0, Coating=1, Approx=1"
+# Задание 2.
+## 1. Оописание своего набора реальных данных
+* Исходный набор данных Letter Recognition Data Set из  репозитория  машинного обучения UCI представляет собой набор данных для многоклассовой классификации. Набор предназначен для распознавания черно-белых пиксельных прямоугольников как одну из 26 заглавных букв английского алфавита, где буквы алфавита представлены в 16 измерениях. Чтобы получить данные, подходящие для обнаружения аномалий, была произведена подвыборка данных из 3 букв, чтобы сформировать нормальный класс, и случайным образом их пары были объединены так, чтобы их размерность удваивалась. Чтобы  сформировать  класс аномалий,  случайным  образом были  выбраны несколько экземпляров  букв,  которые  не  входят нормальный  класс,  и они  были  объединены  с экземплярами  из нормального класса.  Процесс  объединения  выполняется  для  того, чтобы  сделать  обнаружение  более  сложным,  поскольку  каждый аномальный  пример также будет иметь некоторые нормальные значения признаков.
+
+  Количество признаков - 32
+
+  Количество примеров - 1600
+
+  Количество нормальных примеров - 1500
+
+  Количество аномальных примеров - 100
+
+## 2. Загрузка многомерной обучающей выборки
+```python
+train= np.loadtxt('letter_train.txt', dtype=float)
+test = np.loadtxt('letter_test.txt', dtype=float)
+```
+## 3. Вывод данных и размера выборки
+```python
+print('Исходные данные:')
+print(train)
+print('Размерность данных:')
+print(train.shape)
+```
+> Исходные данные:
+> 
+> [[ 6. 10.  5. ... 10.  2.  7.]
+> 
+>  [ 0.  6.  0. ...  8.  1.  7.]
+> 
+>  [ 4.  7.  5. ...  8.  2.  8.]
+> 
+>  ...
+> 
+>  [ 7. 10. 10. ...  8.  5.  6.]
+> 
+>  [ 7.  7. 10. ...  6.  0.  8.]
+> 
+>  [ 3.  4.  5. ...  9.  5.  5.]]
+> 
+> Размерность данных:
+> 
+> (1500, 32)
+
+## 4. Создание и обучение автокодировщика с подходящей для данных архитектурой.
+```python
+ae3_trained, IRE3, IREth3 = lib.create_fit_save_ae(train,'out/AE3.h5','out/AE3_ire_th.txt',
+100000, False, 20000, early_stopping_delta = 0.001)
+```
+> Задать архитектуру автокодировщиков или использовать архитектуру по умолчанию? (1/2): 1
+>
+> Задайте количество скрытых слоёв (нечетное число) : 9
+>
+> Задайте архитектуру скрытых слоёв автокодировщика, например, в виде 3 1 3 : 64 48 32 24 16 24 32 48 64
+>
+> Epoch 1000/100000
+>
+>  - loss: 6.0089
+> 
+> Epoch 2000/100000
+>
+>  - loss: 6.0089
+>   
+>  ...
+>
+>Epoch 99000/100000
+>
+>  - loss: 0.0862
+>  
+>  Epoch 100000/100000
+>
+>  - loss: 0.0864
+
+## 5. Построение   график   ошибки   реконструкции обучающей   выборки. Вывод  порога  ошибки  реконструкции – порога  обнаружения аномалий.
+```python
+lib.ire_plot('training', IRE3, IREth3, 'AE3')
+```
+![График ошибки реконструкции](2_5.png)
+```python
+print("Порог ошибки реконструкции = ",IREth3)
+```
+> Порог ошибки реконструкции =  3.1
+## 6. Загрузка многомерной тестовой выборки
+```python
+print('Исходные данные:')
+print(test)
+print('Размерность данных:')
+print(test.shape)
+```
+>  Исходные данные:
+> 
+>  [[ 8. 11.  8. ...  7.  4.  9.]
+> 
+>   [ 4.  5.  4. ... 13.  8.  8.]
+> 
+>   [ 3.  3.  5. ...  8.  3.  8.]
+> 
+>   ...
+> 
+>   [ 4.  9.  4. ...  8.  3.  8.]
+> 
+>   [ 6. 10.  6. ...  9.  8.  8.]
+> 
+>   [ 3.  1.  3. ...  9.  1.  7.]]
+> 
+>  Размерность данных:
+> 
+>  (100, 32)
+## 7. Вывести график ошибки реконструкции элементов тестовой выборки относительно порога
+```python
+predicted_labels3, ire3 = lib.predict_ae(ae3_trained, test, IREth3)
+lib.anomaly_detection_ae(predicted_labels3, ire3, IREth3)
+lib.ire_plot('test', ire3, IREth3, 'AE3')
+```
+> i         Labels    IRE       IREth
+>
+> 0         [1.]      [6.51]    3.1
+> 
+> 1         [1.]      [8.23]    3.1
+> 
+> 2         [1.]      [8.73]    3.1   
+> 
+> ...
+>
+> 98        [1.]      [6.18]    3.1
+>
+> 99        [1.]      [5.91]    3.1      
+>
+> Обнаружено  100.0  аномалий
+ 
+![График ошибки реконструкции](2_7.png)
+## 8. Параметры наилучшего автокодировщика и результаты обнаружения аномалий
+| Dataset name | Количество скрытых слоев | Количество нейронов в скрытых слоях | Количество эпох обучения | Ошибка MSE_stop | Порог ошибки реконструкции | % обнаруженных аномалий |
+|--------|:------------------------:|:-----------------------------------:|:------------------------:|:---------------:|:--------------------------:|:------:|
+| Letter   | 9                        | 64 48 32 24 16 24 32 48 64                | 100000                    | 0.0864          | 3.1                      | 100.0 | 
+
+## 9. Вывод о требованиях
+>  Для качественного обнаружения аномалий в случае, когда размерность пространства признаков высока.
+> 
+> Данные для обучения должны быть без аномалий, чтобы автокодировщик смог рассчитать верное пороговое значение
+> 
+> Архитектура автокодировщика должна постепенно сужатся к бутылочному горлышку,а затем постепенно возвращатся к исходным выходным размерам, кол-во скрытых слоев 7-11.
+> 
+> В рамках данного набора данных оптимальное кол-во эпох 100000 с patience 20000 эпох
+> 
+> Оптимальная ошибка MSE-stop в районе 0.1, желательно не меньше для предотвращения переобучения
+> 
+> Значение порога не больше 3.1