создание отчета и выполненная лабораторная работа

labworks/LW1/.ipynb_checkpoints/my_document-checkpoint.md

@@ -0,0 +1,533 @@
+
+## Отчёт по лабораторной работе №1
+
+**Троянов Д.С., Чернов Д.Е. — А-01-22**
+
+---
+
+## 1) В среде Google Colab создали блокнот. Импортировали необходимые библиотеки и модули.
+
+```python
+# импорт модулей
+import tensorflow as tf
+from tensorflow import keras
+from keras.datasets import mnist
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.utils import to_categorical
+from sklearn.model_selection import train_test_split
+import matplotlib.pyplot as plt
+import numpy as np
+from PIL import Image
+import os
+
+# Укажем текущую директорию
+os.chdir('/content/drive/MyDrive/Colab Notebooks/is_dnn/labworks/LW1')
+```
+
+---
+
+## 2) Загрузили набор данных MNIST, содержащий размеченные изображения рукописных цифр.
+
+```python
+# Загрузка датасета
+(X_train_orig, y_train_orig), (X_test_orig, y_test_orig) = mnist.load_data()
+
+```
+
+---
+
+## 3) Разбили набор данных на обучающие и тестовые данные в соотношении 60 000:10 000 элементов.
+При разбиении параметр `random_state` выбрали равным (4k – 1), где k - номер бригады, k = 6 ⇒ `random_state = 23`.
+
+```python
+# разбиваем выборку на обучающую и тестовую выборку
+X = np.concatenate((X_train_orig, X_test_orig))
+y = np.concatenate((y_train_orig, y_test_orig))
+
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y,
+    test_size=10000,
+    train_size=60000,
+    random_state=3,
+)
+
+# вывод размерности массивов данных
+print('Shape of X train:', X_train.shape)
+print('Shape of y train:', y_train.shape)
+print('Shape of X test:', X_test.shape)
+print('Shape of y test:', y_test.shape)
+```
+
+```
+Shape of X train: (60000, 28, 28)
+Shape of y train: (60000,)
+Shape of X test: (10000, 28, 28)
+Shape of y test: (10000,)
+```
+
+---
+
+## 4) Вывели первые 4 элемента обучающих данных (изображения и метки цифр).
+
+```python
+# Вывод первых 4 изображений
+fig, axes = plt.subplots(1, 4, figsize=(12, 3))
+for i in range(4):
+    axes[i].imshow(X_train[i], cmap='gray')
+    axes[i].set_title(f'Метка: {y_train[i]}')
+    axes[i].axis('off')
+plt.tight_layout()
+plt.show()
+```
+
+![4 цифры](paragraph_4.png)
+
+
+# Были выведены цифры 7, 8, 2, 2
+---
+
+## 5) Провели предобработку данных: привели обучающие и тестовые данные к формату, пригодному для обучения нейронной сети. Входные данные должны принимать значения от 0 до 1, метки цифр должны быть закодированы по принципу «one-hot encoding». Вывели размерности предобработанных обучающих и тестовых массивов данных.
+
+```python
+# развернем каждое изображение 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('Shape of transformed X train:', X_train.shape)
+```
+
+```
+Shape of transformed X train: (60000, 784)
+```
+
+```python
+# переведем метки в one-hot
+from keras.utils import to_categorical
+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]
+```
+
+```
+Shape of transformed y train: (60000, 10)
+```
+
+---
+
+## 6) Реализовали модель однослойной нейронной сети и обучили ее на обучающих данных с выделением части обучающих данных в качестве валидационных. Вывели информацию об архитектуре нейронной сети. Вывели график функции ошибки на обучающих и валидационных данных по эпохам.
+
+
+```python
+model_0 = Sequential()
+model_0.add(Dense(units=num_classes, input_dim=num_pixels, activation='softmax'))
+
+# Компиляция модели
+model_0.compile(loss='categorical_crossentropy',
+                optimizer='sgd',
+                metrics=['accuracy'])
+
+# Вывод информации об архитектуре
+print("Архитектура однослойной сети:")
+model_0.summary()
+```
+
+![архитектура модели](architecture_of_1_layer_NN.png)
+
+```
+# Обучение модели
+history_0 = model_0.fit(X_train, y_train,
+                        validation_split=0.1,
+                        epochs=50)
+```
+
+```python
+# График функции ошибки по эпохам
+plt.figure(figsize=(10, 6))
+plt.plot(history_0.history['loss'], label='Обучающая выборка')
+plt.plot(history_0.history['val_loss'], label='Валидационная выборка')
+plt.title('Функция ошибки по эпохам (Однослойная сеть)')
+plt.xlabel('Эпохи')
+plt.ylabel('Ошибка')
+plt.legend()
+plt.grid(True)
+plt.show()
+```
+
+![график обучения](paragraph_6.png)
+
+---
+
+## 7) Применили обученную модель к тестовым данным. Вывели значение функции ошибки и значение метрики качества классификации на тестовых данных.
+
+```python
+# Оценка на тестовых данных
+scores_0 = model_0.evaluate(X_test, y_test, verbose=0)
+print("Результаты однослойной сети:")
+print(f"Ошибка на тестовых данных: {scores_0[0]}")
+print(f"Точность на тестовых данных: {scores_0[1]}")
+```
+
+```
+Результаты однослойной сети:
+		Ошибка на тестовых данных: 0.28625616431236267
+		Точность на тестовых данных: 0.92330002784729
+```
+
+---
+
+## 8) Добавили в модель один скрытый и провели обучение и тестирование (повторить п. 6–7) при 100, 300, 500 нейронах в скрытом слое. По метрике качества классификации на тестовых данных выбрали наилучшее количество нейронов в скрытом слое. В качестве функции активации нейронов в скрытом слое использовали функцию `sigmoid`.
+
+```python
+# Функция для создания и обучения модели
+def create_and_train_model(hidden_units, model_name):
+    model = Sequential()
+    model.add(Dense(units=hidden_units, input_dim=num_pixels, activation='sigmoid'))
+    model.add(Dense(units=num_classes, activation='softmax'))
+
+    model.compile(loss='categorical_crossentropy',
+                  optimizer='sgd',
+                  metrics=['accuracy'])
+
+    history = model.fit(X_train, y_train,
+                        validation_split=0.1,
+                        epochs=50)
+
+    scores = model.evaluate(X_test, y_test, verbose=0)
+
+    return model, history, scores
+
+# Эксперименты с разным количеством нейронов
+hidden_units_list = [100, 300, 500]
+models_1 = {}
+histories_1 = {}
+scores_1 = {}
+
+# Обучение сетей с одним скрытым слоем
+for units in hidden_units_list:
+    print(f"
+Обучение модели с {units} нейронами...")
+    model, history, scores = create_and_train_model(units, f"model_{units}")
+
+    models_1[units] = model
+    histories_1[units] = history
+    scores_1[units] = scores
+
+    print(f"Точность: {scores[1]}")
+```
+
+# Определим лучшую модель по итогвой точности
+```python
+# Выбор наилучшей модели
+best_units_1 = max(scores_1.items(), key=lambda x: x[1][1])[0]
+print(f"
+Наилучшее количество нейронов: {best_units_1}")
+print(f"Точность: {scores_1[best_units_1][1]}")
+```
+
+```
+		Наилучшее количество нейронов: 100
+		Точность: 0.9422000050544739
+```
+
+# Отобразим графики ошибок для каждой из архитектур нейросети
+
+```python
+# Графики ошибок для всех моделей
+plt.figure(figsize=(15, 5))
+for i, units in enumerate(hidden_units_list, 1):
+    plt.subplot(1, 3, i)
+    plt.plot(histories_1[units].history['loss'], label='Обучающая')
+    plt.plot(histories_1[units].history['val_loss'], label='Валидационная')
+    plt.title(f'{units} нейронов')
+    plt.xlabel('Эпохи')
+    plt.ylabel('Ошибка')
+    plt.legend()
+    plt.grid(True)
+plt.tight_layout()
+plt.show()
+```
+
+![график обучения для каждой эпохи](paragraph_8.png)
+
+
+**По результатам проведнного эксперимента наилучший показатель точности продемонстрировала нейронная сеть со 100 нейронами в скрытом слое - примерно 0.9422.**
+
+---
+
+## 9) Добавили в архитектуру с лучшим показателем из п. 8, второй скрытый слой и провели обучение и тестирование при 50 и 100 нейронах во втором скрытом слое. В качестве функции активации нейронов в скрытом слое использовали функцию `sigmoid`.
+
+```python
+# Добавление второго скрытого слоя
+second_layer_units = [50, 100]
+models_2 = {}
+histories_2 = {}
+scores_2 = {}
+
+
+for units_2 in second_layer_units:
+    print(f"
+Обучение модели со вторым слоем {units_2} нейронов")
+
+    model = Sequential()
+    model.add(Dense(units=best_units_1, input_dim=num_pixels, activation='sigmoid'))
+    model.add(Dense(units=units_2, activation='sigmoid'))
+    model.add(Dense(units=num_classes, activation='softmax'))
+
+    model.compile(loss='categorical_crossentropy',
+                  optimizer='sgd',
+                  metrics=['accuracy'])
+
+    history = model.fit(X_train, y_train,
+                        validation_split=0.1,
+                        epochs=50)
+
+    scores = model.evaluate(X_test, y_test)
+
+    models_2[units_2] = model
+    histories_2[units_2] = history
+    scores_2[units_2] = scores
+
+    print(f"Точность: {scores[1]}")
+
+```
+
+# Результаты обучения моделей:
+
+```
+Обучение модели со вторым слоем 50 нейронов:
+Точность: 0.9417999982833862
+
+Обучение модели со вторым слоем 100 нейронов
+Точность: 0.942300021648407
+```
+
+# Выбор наилучшей двухслойной модели
+```python
+best_units_2 = max(scores_2.items(), key=lambda x: x[1][1])[0]
+print(f"
+Наилучшее количество нейронов во втором слое: {best_units_2}")
+print(f"Точность: {scores_2[best_units_2][1]}")
+```
+
+```
+	Наилучшее количество нейронов во втором слое: 100
+	Точность: 0.9423
+```
+
+
+## 10) Результаты исследования архитектуры нейронной сети занесли в таблицу:
+
+```python
+# Сбор результатов
+results = {
+    '0 слоев': {'нейроны_1': '-', 'нейроны_2': '-', 'точность': scores_0[1]},
+    '1 слой_100': {'нейроны_1': 100, 'нейроны_2': '-', 'точность': scores_1[100][1]},
+    '1 слой_300': {'нейроны_1': 300, 'нейроны_2': '-', 'точность': scores_1[300][1]},
+    '1 слой_500': {'нейроны_1': 500, 'нейроны_2': '-', 'точность': scores_1[500][1]},
+    '2 слоя_50': {'нейроны_1': best_units_1, 'нейроны_2': 50, 'точность': scores_2[50][1]},
+    '2 слоя_100': {'нейроны_1': best_units_1, 'нейроны_2': 100, 'точность': scores_2[100][1]}
+}
+
+# Создаем DataFrame из результатов
+df_results = pd.DataFrame([
+    {'Кол-во скрытых слоев': 0, 'Нейроны_1_слоя': '-', 'Нейроны_2_слоя': '-', 'Точность': results['0 слоев']['точность']},
+    {'Кол-во скрытых слоев': 1, 'Нейроны_1_слоя': 100, 'Нейроны_2_слоя': '-', 'Точность': results['1 слой_100']['точность']},
+    {'Кол-во скрытых слоев': 1, 'Нейроны_1_слоя': 300, 'Нейроны_2_слоя': '-', 'Точность': results['1 слой_300']['точность']},
+    {'Кол-во скрытых слоев': 1, 'Нейроны_1_слоя': 500, 'Нейроны_2_слоя': '-', 'Точность': results['1 слой_500']['точность']},
+    {'Кол-во скрытых слоев': 2, 'Нейроны_1_слоя': best_units_1, 'Нейроны_2_слоя': 50, 'Точность': results['2 слоя_50']['точность']},
+    {'Кол-во скрытых слоев': 2, 'Нейроны_1_слоя': best_units_1, 'Нейроны_2_слоя': 100, 'Точность': results['2 слоя_100']['точность']}
+])
+
+print(" " * 20 + "ТАБЛИЦА РЕЗУЛЬТАТОВ")
+print("=" * 70)
+# print(df_results.to_string(index=False, formatters={
+#     'Точность': '{:.4f}'.format
+# }))
+print(df_results.reset_index(drop=True))
+
+
+
+```
+
+```
+		ТАБЛИЦА РЕЗУЛЬТАТОВ
+		======================================================================
+		   Кол-во скрытых слоев Нейроны_1_слоя Нейроны_2_слоя  Точность
+		0                     0              -              -    0.9233
+		1                     1            100              -    0.9422
+		2                     1            300              -    0.9377
+		3                     1            500              -    0.9312
+		4                     2            100             50    0.9418
+		5                     2            100            100    0.9423
+
+```
+
+```python
+# Выбор наилучшей модели
+best_model_type = max(results.items(), key=lambda x: x[1]['точность'])[0]
+best_accuracy = results[best_model_type]['точность']
+print(f"
+Наилучшая архитектура: {best_model_type}")
+print(f"Точность: {best_accuracy}")
+```
+
+```
+		Наилучшая архитектура: 2 слоя_100
+		Точность: 0.9423
+```
+### По результатам исследования сделали выводы и выбрали наилучшую архитектуру нейронной сети с точки зрения качества классификации.
+
+**Из таблицы следует, что лучшей архитектурой является НС с двумя скрытыми слоями по 100 и 50 нейронов, второе место занимает НС с одним скрытым слоем и 100 нейронами, на основе которой мы и строили НС с двумя скрытыми слоями. При увеличении количества нейронов в архитектуре НС с 1-м скрытым слоем в результате тестирования было вявлено, что метрики качества падают. Это связано с переобучение нашей НС с 1-м скрытым слоем (когда построенная модель хорошо объясняет примеры из обучающей выборки, но относительно плохо работает на примерах, не участвовавших в обучении) Такая тенденция вероятно возникает из-за простоты датасета MNIST, при усложнении архитектуры НС начинает переобучаться, а оценка качества на тестовых данных падает. Но также стоит отметить, что при усложнении структуры НС точнсть модели также и растет.**
+
+---
+
+## 11) Сохранили наилучшую нейронную сеть на диск.
+
+```python
+# Сохранение модели
+best_model.save('best_mnist_model.keras')
+```
+
+---
+
+## 12) Для нейронной сети наилучшей архитектуры вывели два тестовых изображения, истинные метки и результат распознавания изображений.
+
+```python
+# вывод тестового изображения и результата распознавания (1)
+n = 123
+result = best_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)))
+```
+
+![результат 1](paragraph_12_1.png)
+
+```python
+# вывод тестового изображения и результата распознавания (3)
+n = 353
+result = best_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)))
+```
+![результат 2](paragraph_12_3.png)
+
+---
+
+## 13) Создали собственные изображения рукописных цифр, подобное представленным в наборе MNIST. Цифру выбрали как остаток от деления на 10 числа своего дня рождения (12 марта → 2, 17 сентября → 7 ). Сохранили изображения. Загрузили, предобработали и подали на вход обученной нейронной сети собственные изображения. Вывели изображения и результаты распознавания.
+
+```python
+# загрузка собственного изображения
+file_data_2 = Image.open('2.png')
+file_data_7 = Image.open('7.png')
+file_data_2 = file_data_2.convert('L') # перевод в градации серого
+file_data_7 = file_data_7.convert('L') # перевод в градации серого
+test_img_2 = np.array(file_data_2)
+test_img_7 = np.array(file_data_7)
+
+
+# вывод собственного изображения (цифра 2)
+plt.imshow(test_img_2, cmap=plt.get_cmap('gray'))
+plt.show()
+# предобработка
+test_img_2 = test_img_2 / 255
+test_img_2 = test_img_2.reshape(1, num_pixels)
+# распознавание
+result = best_model.predict(test_img_2)
+print('I think it\'s ', np.argmax(result))
+```
+
+![собственные изображения](2.png)
+
+```
+1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 31ms/step
+```
+
+```python
+# вывод собственного изображения (цифра 7)
+plt.imshow(test_img_7, cmap=plt.get_cmap('gray'))
+plt.show()
+# предобработка
+test_img_7 = test_img_7 / 255
+test_img_7 = test_img_7.reshape(1, num_pixels)
+# распознавание
+result = best_model.predict(test_img_7)
+print('I think it\'s ', np.argmax(result))
+```
+
+```
+![собственные изображения](7.png)
+```
+
+```
+1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 48ms/step
+I think it's  7
+```
+**Как видим в результате эксперимента наша НС недостаточно точно определила изображение цифры 2. Возможно это связано с малом размером используемой выборки. Для улучшения качества решения задачи классификации можно либо увеличить размерность выборки для обучения НС, либо изменить структуру НС для более точной ее работы**
+
+---
+
+## 14) Создать копию собственного изображения, отличающуюся от оригинала поворотом на 90 градусов в любую сторону. Сохранили изображения. Загрузили, предобработали и подали на вход обученной нейронной сети измененные изображения. Вывели изображения и результаты распознавания. Сделали выводы по результатам эксперимента.
+
+```python
+# загрузка собственного изображения
+file_data_2_90 = Image.open('2_90.png')
+file_data_7_90 = Image.open('7_90.png')
+file_data_2_90 = file_data_2_90.convert('L') # перевод в градации серого
+file_data_7_90 = file_data_7_90.convert('L') # перевод в градации серого
+test_img_2_90 = np.array(file_data_2_90)
+test_img_7_90= np.array(file_data_7_90)
+
+# вывод собственного изображения (цифра 2)
+plt.imshow(test_img_2_90, cmap=plt.get_cmap('gray'))
+plt.show()
+# предобработка
+test_img_2_90 = test_img_2_90 / 255
+test_img_2_90 = test_img_2_90.reshape(1, num_pixels)
+# распознавание
+result = best_model.predict(test_img_2_90)
+print('I think it\'s ', np.argmax(result))
+```
+
+![собственные изображения повернутые на 90 градусов](2_90.png)
+
+```
+1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 91ms/step
+I think it's  7
+```
+
+```python
+# вывод собственного изображения (цифра 7)
+plt.imshow(test_img_7_90, cmap=plt.get_cmap('gray'))
+plt.show()
+# предобработка
+test_img_7_90 = test_img_7_90 / 255
+test_img_7_90 = test_img_7_90.reshape(1, num_pixels)
+# распознавание
+result = best_model.predict(test_img_7_90)
+print('I think it\'s ', np.argmax(result))
+```
+
+![собственные изображения повернутые на 90 градусов](2_90.png)
+
+```
+1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 48ms/step
+I think it's  7
+```
+
+
+**При повороте рисунков цифр НС не смогла распознать одну из цифр. Так получилось, во-первых, по той же причине, почему НС не распознала одну из цифр в пункте 13, во-вторых - наша НС не обучалась на перевернутых цифрах**
+
+---
+
+
+
+        

labworks/LW1/my_document.md

@@ -0,0 +1,533 @@
+
+## Отчёт по лабораторной работе №1
+
+**Троянов Д.С., Чернов Д.Е. — А-01-22**
+
+---
+
+## 1) В среде Google Colab создали блокнот. Импортировали необходимые библиотеки и модули.
+
+```python
+# импорт модулей
+import tensorflow as tf
+from tensorflow import keras
+from keras.datasets import mnist
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.utils import to_categorical
+from sklearn.model_selection import train_test_split
+import matplotlib.pyplot as plt
+import numpy as np
+from PIL import Image
+import os
+
+# Укажем текущую директорию
+os.chdir('/content/drive/MyDrive/Colab Notebooks/is_dnn/labworks/LW1')
+```
+
+---
+
+## 2) Загрузили набор данных MNIST, содержащий размеченные изображения рукописных цифр.
+
+```python
+# Загрузка датасета
+(X_train_orig, y_train_orig), (X_test_orig, y_test_orig) = mnist.load_data()
+
+```
+
+---
+
+## 3) Разбили набор данных на обучающие и тестовые данные в соотношении 60 000:10 000 элементов.
+При разбиении параметр `random_state` выбрали равным (4k – 1), где k - номер бригады, k = 6 ⇒ `random_state = 23`.
+
+```python
+# разбиваем выборку на обучающую и тестовую выборку
+X = np.concatenate((X_train_orig, X_test_orig))
+y = np.concatenate((y_train_orig, y_test_orig))
+
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y,
+    test_size=10000,
+    train_size=60000,
+    random_state=3,
+)
+
+# вывод размерности массивов данных
+print('Shape of X train:', X_train.shape)
+print('Shape of y train:', y_train.shape)
+print('Shape of X test:', X_test.shape)
+print('Shape of y test:', y_test.shape)
+```
+
+```
+Shape of X train: (60000, 28, 28)
+Shape of y train: (60000,)
+Shape of X test: (10000, 28, 28)
+Shape of y test: (10000,)
+```
+
+---
+
+## 4) Вывели первые 4 элемента обучающих данных (изображения и метки цифр).
+
+```python
+# Вывод первых 4 изображений
+fig, axes = plt.subplots(1, 4, figsize=(12, 3))
+for i in range(4):
+    axes[i].imshow(X_train[i], cmap='gray')
+    axes[i].set_title(f'Метка: {y_train[i]}')
+    axes[i].axis('off')
+plt.tight_layout()
+plt.show()
+```
+
+![4 цифры](paragraph_4.png)
+
+
+# Были выведены цифры 7, 8, 2, 2
+---
+
+## 5) Провели предобработку данных: привели обучающие и тестовые данные к формату, пригодному для обучения нейронной сети. Входные данные должны принимать значения от 0 до 1, метки цифр должны быть закодированы по принципу «one-hot encoding». Вывели размерности предобработанных обучающих и тестовых массивов данных.
+
+```python
+# развернем каждое изображение 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('Shape of transformed X train:', X_train.shape)
+```
+
+```
+Shape of transformed X train: (60000, 784)
+```
+
+```python
+# переведем метки в one-hot
+from keras.utils import to_categorical
+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]
+```
+
+```
+Shape of transformed y train: (60000, 10)
+```
+
+---
+
+## 6) Реализовали модель однослойной нейронной сети и обучили ее на обучающих данных с выделением части обучающих данных в качестве валидационных. Вывели информацию об архитектуре нейронной сети. Вывели график функции ошибки на обучающих и валидационных данных по эпохам.
+
+
+```python
+model_0 = Sequential()
+model_0.add(Dense(units=num_classes, input_dim=num_pixels, activation='softmax'))
+
+# Компиляция модели
+model_0.compile(loss='categorical_crossentropy',
+                optimizer='sgd',
+                metrics=['accuracy'])
+
+# Вывод информации об архитектуре
+print("Архитектура однослойной сети:")
+model_0.summary()
+```
+
+![архитектура модели](architecture_of_1_layer_NN.png)
+
+```
+# Обучение модели
+history_0 = model_0.fit(X_train, y_train,
+                        validation_split=0.1,
+                        epochs=50)
+```
+
+```python
+# График функции ошибки по эпохам
+plt.figure(figsize=(10, 6))
+plt.plot(history_0.history['loss'], label='Обучающая выборка')
+plt.plot(history_0.history['val_loss'], label='Валидационная выборка')
+plt.title('Функция ошибки по эпохам (Однослойная сеть)')
+plt.xlabel('Эпохи')
+plt.ylabel('Ошибка')
+plt.legend()
+plt.grid(True)
+plt.show()
+```
+
+![график обучения](paragraph_6.png)
+
+---
+
+## 7) Применили обученную модель к тестовым данным. Вывели значение функции ошибки и значение метрики качества классификации на тестовых данных.
+
+```python
+# Оценка на тестовых данных
+scores_0 = model_0.evaluate(X_test, y_test, verbose=0)
+print("Результаты однослойной сети:")
+print(f"Ошибка на тестовых данных: {scores_0[0]}")
+print(f"Точность на тестовых данных: {scores_0[1]}")
+```
+
+```
+Результаты однослойной сети:
+		Ошибка на тестовых данных: 0.28625616431236267
+		Точность на тестовых данных: 0.92330002784729
+```
+
+---
+
+## 8) Добавили в модель один скрытый и провели обучение и тестирование (повторить п. 6–7) при 100, 300, 500 нейронах в скрытом слое. По метрике качества классификации на тестовых данных выбрали наилучшее количество нейронов в скрытом слое. В качестве функции активации нейронов в скрытом слое использовали функцию `sigmoid`.
+
+```python
+# Функция для создания и обучения модели
+def create_and_train_model(hidden_units, model_name):
+    model = Sequential()
+    model.add(Dense(units=hidden_units, input_dim=num_pixels, activation='sigmoid'))
+    model.add(Dense(units=num_classes, activation='softmax'))
+
+    model.compile(loss='categorical_crossentropy',
+                  optimizer='sgd',
+                  metrics=['accuracy'])
+
+    history = model.fit(X_train, y_train,
+                        validation_split=0.1,
+                        epochs=50)
+
+    scores = model.evaluate(X_test, y_test, verbose=0)
+
+    return model, history, scores
+
+# Эксперименты с разным количеством нейронов
+hidden_units_list = [100, 300, 500]
+models_1 = {}
+histories_1 = {}
+scores_1 = {}
+
+# Обучение сетей с одним скрытым слоем
+for units in hidden_units_list:
+    print(f"
+Обучение модели с {units} нейронами...")
+    model, history, scores = create_and_train_model(units, f"model_{units}")
+
+    models_1[units] = model
+    histories_1[units] = history
+    scores_1[units] = scores
+
+    print(f"Точность: {scores[1]}")
+```
+
+# Определим лучшую модель по итогвой точности
+```python
+# Выбор наилучшей модели
+best_units_1 = max(scores_1.items(), key=lambda x: x[1][1])[0]
+print(f"
+Наилучшее количество нейронов: {best_units_1}")
+print(f"Точность: {scores_1[best_units_1][1]}")
+```
+
+```
+		Наилучшее количество нейронов: 100
+		Точность: 0.9422000050544739
+```
+
+# Отобразим графики ошибок для каждой из архитектур нейросети
+
+```python
+# Графики ошибок для всех моделей
+plt.figure(figsize=(15, 5))
+for i, units in enumerate(hidden_units_list, 1):
+    plt.subplot(1, 3, i)
+    plt.plot(histories_1[units].history['loss'], label='Обучающая')
+    plt.plot(histories_1[units].history['val_loss'], label='Валидационная')
+    plt.title(f'{units} нейронов')
+    plt.xlabel('Эпохи')
+    plt.ylabel('Ошибка')
+    plt.legend()
+    plt.grid(True)
+plt.tight_layout()
+plt.show()
+```
+
+![график обучения для каждой эпохи](paragraph_8.png)
+
+
+**По результатам проведнного эксперимента наилучший показатель точности продемонстрировала нейронная сеть со 100 нейронами в скрытом слое - примерно 0.9422.**
+
+---
+
+## 9) Добавили в архитектуру с лучшим показателем из п. 8, второй скрытый слой и провели обучение и тестирование при 50 и 100 нейронах во втором скрытом слое. В качестве функции активации нейронов в скрытом слое использовали функцию `sigmoid`.
+
+```python
+# Добавление второго скрытого слоя
+second_layer_units = [50, 100]
+models_2 = {}
+histories_2 = {}
+scores_2 = {}
+
+
+for units_2 in second_layer_units:
+    print(f"
+Обучение модели со вторым слоем {units_2} нейронов")
+
+    model = Sequential()
+    model.add(Dense(units=best_units_1, input_dim=num_pixels, activation='sigmoid'))
+    model.add(Dense(units=units_2, activation='sigmoid'))
+    model.add(Dense(units=num_classes, activation='softmax'))
+
+    model.compile(loss='categorical_crossentropy',
+                  optimizer='sgd',
+                  metrics=['accuracy'])
+
+    history = model.fit(X_train, y_train,
+                        validation_split=0.1,
+                        epochs=50)
+
+    scores = model.evaluate(X_test, y_test)
+
+    models_2[units_2] = model
+    histories_2[units_2] = history
+    scores_2[units_2] = scores
+
+    print(f"Точность: {scores[1]}")
+
+```
+
+# Результаты обучения моделей:
+
+```
+Обучение модели со вторым слоем 50 нейронов:
+Точность: 0.9417999982833862
+
+Обучение модели со вторым слоем 100 нейронов
+Точность: 0.942300021648407
+```
+
+# Выбор наилучшей двухслойной модели
+```python
+best_units_2 = max(scores_2.items(), key=lambda x: x[1][1])[0]
+print(f"
+Наилучшее количество нейронов во втором слое: {best_units_2}")
+print(f"Точность: {scores_2[best_units_2][1]}")
+```
+
+```
+	Наилучшее количество нейронов во втором слое: 100
+	Точность: 0.9423
+```
+
+
+## 10) Результаты исследования архитектуры нейронной сети занесли в таблицу:
+
+```python
+# Сбор результатов
+results = {
+    '0 слоев': {'нейроны_1': '-', 'нейроны_2': '-', 'точность': scores_0[1]},
+    '1 слой_100': {'нейроны_1': 100, 'нейроны_2': '-', 'точность': scores_1[100][1]},
+    '1 слой_300': {'нейроны_1': 300, 'нейроны_2': '-', 'точность': scores_1[300][1]},
+    '1 слой_500': {'нейроны_1': 500, 'нейроны_2': '-', 'точность': scores_1[500][1]},
+    '2 слоя_50': {'нейроны_1': best_units_1, 'нейроны_2': 50, 'точность': scores_2[50][1]},
+    '2 слоя_100': {'нейроны_1': best_units_1, 'нейроны_2': 100, 'точность': scores_2[100][1]}
+}
+
+# Создаем DataFrame из результатов
+df_results = pd.DataFrame([
+    {'Кол-во скрытых слоев': 0, 'Нейроны_1_слоя': '-', 'Нейроны_2_слоя': '-', 'Точность': results['0 слоев']['точность']},
+    {'Кол-во скрытых слоев': 1, 'Нейроны_1_слоя': 100, 'Нейроны_2_слоя': '-', 'Точность': results['1 слой_100']['точность']},
+    {'Кол-во скрытых слоев': 1, 'Нейроны_1_слоя': 300, 'Нейроны_2_слоя': '-', 'Точность': results['1 слой_300']['точность']},
+    {'Кол-во скрытых слоев': 1, 'Нейроны_1_слоя': 500, 'Нейроны_2_слоя': '-', 'Точность': results['1 слой_500']['точность']},
+    {'Кол-во скрытых слоев': 2, 'Нейроны_1_слоя': best_units_1, 'Нейроны_2_слоя': 50, 'Точность': results['2 слоя_50']['точность']},
+    {'Кол-во скрытых слоев': 2, 'Нейроны_1_слоя': best_units_1, 'Нейроны_2_слоя': 100, 'Точность': results['2 слоя_100']['точность']}
+])
+
+print(" " * 20 + "ТАБЛИЦА РЕЗУЛЬТАТОВ")
+print("=" * 70)
+# print(df_results.to_string(index=False, formatters={
+#     'Точность': '{:.4f}'.format
+# }))
+print(df_results.reset_index(drop=True))
+
+
+
+```
+
+```
+		ТАБЛИЦА РЕЗУЛЬТАТОВ
+		======================================================================
+		   Кол-во скрытых слоев Нейроны_1_слоя Нейроны_2_слоя  Точность
+		0                     0              -              -    0.9233
+		1                     1            100              -    0.9422
+		2                     1            300              -    0.9377
+		3                     1            500              -    0.9312
+		4                     2            100             50    0.9418
+		5                     2            100            100    0.9423
+
+```
+
+```python
+# Выбор наилучшей модели
+best_model_type = max(results.items(), key=lambda x: x[1]['точность'])[0]
+best_accuracy = results[best_model_type]['точность']
+print(f"
+Наилучшая архитектура: {best_model_type}")
+print(f"Точность: {best_accuracy}")
+```
+
+```
+		Наилучшая архитектура: 2 слоя_100
+		Точность: 0.9423
+```
+### По результатам исследования сделали выводы и выбрали наилучшую архитектуру нейронной сети с точки зрения качества классификации.
+
+**Из таблицы следует, что лучшей архитектурой является НС с двумя скрытыми слоями по 100 и 50 нейронов, второе место занимает НС с одним скрытым слоем и 100 нейронами, на основе которой мы и строили НС с двумя скрытыми слоями. При увеличении количества нейронов в архитектуре НС с 1-м скрытым слоем в результате тестирования было вявлено, что метрики качества падают. Это связано с переобучение нашей НС с 1-м скрытым слоем (когда построенная модель хорошо объясняет примеры из обучающей выборки, но относительно плохо работает на примерах, не участвовавших в обучении) Такая тенденция вероятно возникает из-за простоты датасета MNIST, при усложнении архитектуры НС начинает переобучаться, а оценка качества на тестовых данных падает. Но также стоит отметить, что при усложнении структуры НС точнсть модели также и растет.**
+
+---
+
+## 11) Сохранили наилучшую нейронную сеть на диск.
+
+```python
+# Сохранение модели
+best_model.save('best_mnist_model.keras')
+```
+
+---
+
+## 12) Для нейронной сети наилучшей архитектуры вывели два тестовых изображения, истинные метки и результат распознавания изображений.
+
+```python
+# вывод тестового изображения и результата распознавания (1)
+n = 123
+result = best_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)))
+```
+
+![результат 1](paragraph_12_1.png)
+
+```python
+# вывод тестового изображения и результата распознавания (3)
+n = 353
+result = best_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)))
+```
+![результат 2](paragraph_12_3.png)
+
+---
+
+## 13) Создали собственные изображения рукописных цифр, подобное представленным в наборе MNIST. Цифру выбрали как остаток от деления на 10 числа своего дня рождения (12 марта → 2, 17 сентября → 7 ). Сохранили изображения. Загрузили, предобработали и подали на вход обученной нейронной сети собственные изображения. Вывели изображения и результаты распознавания.
+
+```python
+# загрузка собственного изображения
+file_data_2 = Image.open('2.png')
+file_data_7 = Image.open('7.png')
+file_data_2 = file_data_2.convert('L') # перевод в градации серого
+file_data_7 = file_data_7.convert('L') # перевод в градации серого
+test_img_2 = np.array(file_data_2)
+test_img_7 = np.array(file_data_7)
+
+
+# вывод собственного изображения (цифра 2)
+plt.imshow(test_img_2, cmap=plt.get_cmap('gray'))
+plt.show()
+# предобработка
+test_img_2 = test_img_2 / 255
+test_img_2 = test_img_2.reshape(1, num_pixels)
+# распознавание
+result = best_model.predict(test_img_2)
+print('I think it\'s ', np.argmax(result))
+```
+
+![собственные изображения](2.png)
+
+```
+1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 31ms/step
+```
+
+```python
+# вывод собственного изображения (цифра 7)
+plt.imshow(test_img_7, cmap=plt.get_cmap('gray'))
+plt.show()
+# предобработка
+test_img_7 = test_img_7 / 255
+test_img_7 = test_img_7.reshape(1, num_pixels)
+# распознавание
+result = best_model.predict(test_img_7)
+print('I think it\'s ', np.argmax(result))
+```
+
+```
+![собственные изображения](7.png)
+```
+
+```
+1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 48ms/step
+I think it's  7
+```
+**Как видим в результате эксперимента наша НС недостаточно точно определила изображение цифры 2. Возможно это связано с малом размером используемой выборки. Для улучшения качества решения задачи классификации можно либо увеличить размерность выборки для обучения НС, либо изменить структуру НС для более точной ее работы**
+
+---
+
+## 14) Создать копию собственного изображения, отличающуюся от оригинала поворотом на 90 градусов в любую сторону. Сохранили изображения. Загрузили, предобработали и подали на вход обученной нейронной сети измененные изображения. Вывели изображения и результаты распознавания. Сделали выводы по результатам эксперимента.
+
+```python
+# загрузка собственного изображения
+file_data_2_90 = Image.open('2_90.png')
+file_data_7_90 = Image.open('7_90.png')
+file_data_2_90 = file_data_2_90.convert('L') # перевод в градации серого
+file_data_7_90 = file_data_7_90.convert('L') # перевод в градации серого
+test_img_2_90 = np.array(file_data_2_90)
+test_img_7_90= np.array(file_data_7_90)
+
+# вывод собственного изображения (цифра 2)
+plt.imshow(test_img_2_90, cmap=plt.get_cmap('gray'))
+plt.show()
+# предобработка
+test_img_2_90 = test_img_2_90 / 255
+test_img_2_90 = test_img_2_90.reshape(1, num_pixels)
+# распознавание
+result = best_model.predict(test_img_2_90)
+print('I think it\'s ', np.argmax(result))
+```
+
+![собственные изображения повернутые на 90 градусов](2_90.png)
+
+```
+1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 91ms/step
+I think it's  7
+```
+
+```python
+# вывод собственного изображения (цифра 7)
+plt.imshow(test_img_7_90, cmap=plt.get_cmap('gray'))
+plt.show()
+# предобработка
+test_img_7_90 = test_img_7_90 / 255
+test_img_7_90 = test_img_7_90.reshape(1, num_pixels)
+# распознавание
+result = best_model.predict(test_img_7_90)
+print('I think it\'s ', np.argmax(result))
+```
+
+![собственные изображения повернутые на 90 градусов](7_90.png)
+
+```
+1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 48ms/step
+I think it's  7
+```
+
+
+**При повороте рисунков цифр НС не смогла распознать одну из цифр. Так получилось, во-первых, по той же причине, почему НС не распознала одну из цифр в пункте 13, во-вторых - наша НС не обучалась на перевернутых цифрах**
+
+---
+
+
+
+        

labworks/LW2/LW1

@@ -0,0 +1 @@
+Subproject commit 3f51d49924a6a14ad44f2a5e70c707fb576ac786

labworks/LW3/LW1

@@ -0,0 +1 @@
+Subproject commit 3f51d49924a6a14ad44f2a5e70c707fb576ac786