From 0d0beed503f3c5f085ce905d56c23b13fd21022d Mon Sep 17 00:00:00 2001 From: Fonov_Alexandr Date: Thu, 11 Dec 2025 10:11:11 +0000 Subject: [PATCH] a --- labworks/LW3/report.md | 528 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 528 insertions(+) create mode 100644 labworks/LW3/report.md diff --git a/labworks/LW3/report.md b/labworks/LW3/report.md new file mode 100644 index 0000000..8c51d84 --- /dev/null +++ b/labworks/LW3/report.md @@ -0,0 +1,528 @@ +# Лабораторная работа №3: Распознование изображений +**Фонов А.Д., Хнытченков А.М. — А-01-22** +## Вариант 2 + +### Цель работы +Получить практические навыки создания, обучения и применения сверточных нейронных сетей для распознавания изображений. Познакомиться с классическими показателямикачества классификации. + +--- + +## ЗАДАНИЕ 1: + +### 1) В среде Google Colab создали новый блокнот (notebook). Импортировали необходимые для работы библиотеки модули. +```python +# импорт модулей +import os +os.chdir('/content/drive/MyDrive/Colab Notebooks/is_lab3') + +from tensorflow import keras +from tensorflow.keras import layers +from tensorflow.keras.models import Sequential +import matplotlib.pyplot as plt +import numpy as np +from sklearn.metrics import classification_report, confusion_matrix +from sklearn.metrics import ConfusionMatrixDisplay +``` + +### 2) Загрузили набор данных MNIST, содержащий размеченные изображения рукописных цифр. +```python +#загрузка датасета +from keras.datasets import mnist +(X_train,y_train),(X_test,y_test)=mnist.load_data() +``` +### 3) Разбили набор данных на обучающие и тестовые данные в соотношении 60 000:10 000 элементов. Параметр random_state выбрали равным (4k – 1)=11, где k=3 –номер бригады. Вывели размерности полученных обучающих и тестовых массивов данных. + +```python +# создание своего разбиения датасета +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=1) +#вывод размерностей +print('ShapeofXtrain:',X_train.shape) +print('Shapeofytrain:',y_train.shape) +print('ShapeofXtest:',X_test.shape) +print('Shapeofytest:',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) Провели предобработку данных: привели обучающие и тестовые данные к формату, пригодному для обучения сверточной нейронной сети. Входные данные принимают значения от 0 до 1, метки цифр закодированы по принципу «one-hot encoding». Вывели размерности предобработанных обучающих и тестовых массивов данных. + +```python +# Зададим параметры данных и модели +num_classes = 10 +input_shape = (28, 28, 1) + +# Приведение входных данных к диапазону [0, 1] +X_train = X_train / 255 +X_test = X_test / 255 + +# Расширяем размерность входных данных, чтобы каждое изображение имело +# размерность (высота, ширина, количество каналов) + +X_train = np.expand_dims(X_train, -1) +X_test = np.expand_dims(X_test, -1) +print('Shape of transformed X train:', X_train.shape) +print('Shape of transformed X test:', X_test.shape) + +# переведем метки в one-hot +y_train = keras.utils.to_categorical(y_train, num_classes) +y_test = keras.utils.to_categorical(y_test, num_classes) +print('Shape of transformed y train:', y_train.shape) +print('Shape of transformed y test:', y_test.shape) +``` + +**Результат выполнения:** +``` +Shape of transformed X train: (60000, 28, 28, 1) +Shape of transformed X test: (10000, 28, 28, 1) +Shape of transformed y train: (60000, 10) +Shape of transformed y test: (10000, 10) +``` + +### 5) Реализовали модель сверточной нейронной сети и обучили ее на обучающих данных с выделением части обучающих данных в качестве валидационных. Вывели информацию об архитектуре нейронной сети. + +```python +# создаем модель +model = Sequential() +model.add(layers.Conv2D(32, kernel_size=(3, 3), activation="relu", input_shape=input_shape)) +model.add(layers.MaxPooling2D(pool_size=(2, 2))) +model.add(layers.Conv2D(64, kernel_size=(3, 3), activation="relu")) +model.add(layers.MaxPooling2D(pool_size=(2, 2))) +model.add(layers.Dropout(0.5)) +model.add(layers.Flatten()) +model.add(layers.Dense(num_classes, activation="softmax")) + +model.summary() +``` + +**Результат выполнения:** +``` +Model: "sequential" +┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓ +┃ Layer (type) ┃ Output Shape ┃ Param # ┃ +┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩ +│ conv2d (Conv2D) │ (None, 26, 26, 32) │ 320 │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ max_pooling2d (MaxPooling2D) │ (None, 13, 13, 32) │ 0 │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ conv2d_1 (Conv2D) │ (None, 11, 11, 64) │ 18,496 │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ max_pooling2d_1 (MaxPooling2D) │ (None, 5, 5, 64) │ 0 │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ dropout (Dropout) │ (None, 5, 5, 64) │ 0 │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ flatten (Flatten) │ (None, 1600) │ 0 │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ dense (Dense) │ (None, 10) │ 16,010 │ +└─────────────────────────────────┴────────────────────────┴───────────────┘ + Total params: 34,826 (136.04 KB) + Trainable params: 34,826 (136.04 KB) + Non-trainable params: 0 (0.00 B) +``` + +```python +# компилируем и обучаем модель +batch_size = 512 +epochs = 15 +model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"]) +model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.1) +``` + +### 6) Оценили качество обучения на тестовых данных. Вывели значение функции ошибки и значение метрики качества классификации на тестовых данных. + +```python +# Оценка качества работы модели на тестовых данных +scores = model.evaluate(X_test, y_test) +print('Loss on test data:', scores[0]) +print('Accuracy on test data:', scores[1]) +``` + +**Результат выполнения:** +``` +313/313 ━━━━━━━━━━━━━━━━━━━━ 2s 8ms/step - accuracy: 0.9884 - loss: 0.0407 +Loss on test data: 0.0380745530128479 +Accuracy on test data: 0.988099992275238 +``` + +### 7) Подали на вход обученной модели два тестовых изображения. Вывели изображения, истинные метки и результаты распознавания. + +```python +# вывод двух тестовых изображений и результатов распознавания + +for n in [3,26]: + 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: ', np.argmax(y_test[n])) + print('NN answer: ', np.argmax(result)) +``` + +**Результат выполнения:** +``` +NN output: [[9.9974984e-01 1.1346071e-09 4.2711710e-07 9.8862856e-08 1.8424662e-07 + 1.0386100e-06 1.1210213e-06 4.2410937e-09 1.0569496e-04 1.4153722e-04]] +Real mark: 0 +NN answer: 0 +``` +![](img_2.png) +``` +1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 39ms/step +NN output: [[1.6414211e-06 3.8204837e-07 6.8303052e-06 7.4757695e-06 4.4060772e-07 + 4.1652779e-04 4.2315129e-05 3.0511899e-10 9.9951470e-01 9.6667927e-06]]``` +![](7-1.png) +Real mark: 8 +NN answer: 8 +``` + +![](img_3.png) + +### 8) Вывели отчет о качестве классификации тестовой выборки и матрицу ошибок для тестовой выборки. + +```python +# истинные метки классов +true_labels = np.argmax(y_test, axis=1) +# предсказанные метки классов +predicted_labels = np.argmax(model.predict(X_test), axis=1) + +# отчет о качестве классификации +print(classification_report(true_labels, predicted_labels)) +# вычисление матрицы ошибок +conf_matrix = confusion_matrix(true_labels, predicted_labels) +# отрисовка матрицы ошибок в виде "тепловой карты" +display = ConfusionMatrixDisplay(confusion_matrix=conf_matrix) +display.plot() +plt.show() +``` + +**Результат выполнения:** + +![](img_1.png) + +### 9) Загрузили, предобработали и подали на вход обученной нейронной сети собственное изображение, созданное при выполнении лабораторной работы №1. Вывели изображение и результат распознавания. + +```python +# загрузка собственного изображения +from PIL import Image + +file_data = Image.open('9.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 = np.reshape(test_img, (1,28,28,1)) + +# распознавание +result = model.predict(test_img) +print('I think it\'s', np.argmax(result)) +``` + +**Результат выполнения:** +!(9.png) +``` +I think it's 9 +``` + +### 10) Загрузили с диска модель, сохраненную при выполнении лабораторной работы №1. Вывели информацию об архитектуре модели. Повторили для этой модели п. 6. + +```python +LR1_model = keras.models.load_model("best_model.keras") +LR1_model.summary() +``` + +**Результат выполнения:** +``` +Model: "sequential_16" +┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓ +┃ Layer (type) ┃ Output Shape ┃ Param # ┃ +┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩ +│ dense_26 (Dense) │ (None, 100) │ 78,500 │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ dense_27 (Dense) │ (None, 10) │ 1,010 │ +└─────────────────────────────────┴────────────────────────┴───────────────┘ + Total params: 79,512 (310.60 KB) + Trainable params: 79,510 (310.59 KB) + Non-trainable params: 0 (0.00 B) + Optimizer params: 2 (12.00 B) +``` + +```python +# Оценка качества работы модели на тестовых данных +scores = LR1_model.evaluate(X_test, y_test) +print('Loss on test data:', scores[0]) +print('Accuracy on test data:', scores[1]) +``` + +**Результат выполнения:** +``` +accuracy: 0.9153 - loss: 0.3012 +Loss on test data: 0.299849271774292 +Accuracy on test data: 0.9138000011444092 +``` + +### 11) Сравнили обученную модель сверточной сети и наилучшую модель полносвязной сети из лабораторной работы №1 по следующим показателям: + +###- количество настраиваемых параметров в сети +###- количество эпох обучения +###- качество классификации тестовой выборки. + +###Сделали выводы по результатам применения сверточной нейронной сети для распознавания изображений. +Таблица 1: +| Модель | Количество настраиваемых параметров | Количество эпох обучения | Качество классификации тестовой выборки | +|-----------------|-------------------------------------|--------------------------|-----------------------------------------| +| Сверточная | 34,826 | 15 | accuracy: 0.9869 - loss: 0.0416 | +| Полносвязная | 79,512 | 500 | accuracy: 0.9163 - loss: 0.2937 | + +### По результатам таблицы можно сделать вывод, чьл сверточная НС гораздо лучше справляется с задачей распознавания изображений, чем полносвязная. У нее меньше настраиваемых параметров, ей требуется меньше эпох обучения и ее показатели качества лучше, чем у полносвязной. + +## Задание 2 + +### В новом блокноте выполнили п. 2–8 задания 1, изменив набор данных MNIST на CIFAR-10, содержащий размеченные цветные изображения объектов, разделенные на 10 классов. + +### При этом: +* в п.3 разбиение данных на обучающие и тестовые произвести в соотношении 50000:10000 +* после разбиения данных(между п. 3 и 4)вывести 25 изображений из обучающей выборки с подписями классов +* в п.7 одно из тестовых изображений должно распознаваться корректно, а другое – ошибочно. + +### 1) Загрузили набор данных CIFAR-10, содержащий цветные изображения размеченные на 10 классов: самолет, автомобиль, птица, кошка, олень, собака, лягушка, лошадь, корабль, грузовик. + +```python +# загрузка датасета +from keras.datasets import cifar10 + +(X_train, y_train), (X_test, y_test) = cifar10.load_data() +``` + +### 2) Разбили набор данных на обучающие и тестовые данные в соотношении 50 000:10 000 элементов. Параметр random_state выбрали равным (4k – 1)=11, где k=3 –номер бригады. Вывели размерности полученных обучающих и тестовых массивов данных. + +```python +# создание своего разбиения датасета +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 = 50000,random_state = 11 + ) +# вывод размерностей +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: (50000, 32, 32, 3) +Shape of y train: (50000, 1) +Shape of X test: (10000, 32, 32, 3) +Shape of y test: (10000, 1) +``` + +### Вывели 25 изображений из обучающей выборки с подписью классов. + +```python +class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer','dog', 'frog', 'horse', 'ship', 'truck'] + +plt.figure(figsize=(10,10)) +for i in range(25): + plt.subplot(5,5,i+1) + plt.xticks([]) + plt.yticks([]) + plt.grid(False) + plt.imshow(X_train[i]) + plt.xlabel(class_names[y_train[i][0]]) +plt.show() +``` + +**Результат выполнения:** + +![](img_4 .png) + +### 3) Провели предобработку данных: привели обучающие и тестовые данные к формату, пригодному для обучения сверточной нейронной сети. Входные данные принимают значения от 0 до 1, метки цифр закодированы по принципу «one-hot encoding». Вывели размерности предобработанных обучающих и тестовых массивов данных. + +```python +# Зададим параметры данных и модели +num_classes = 10 +input_shape = (32, 32, 3) + +# Приведение входных данных к диапазону [0, 1] +X_train = X_train / 255 +X_test = X_test / 255 + +print('Shape of transformed X train:', X_train.shape) +print('Shape of transformed X test:', X_test.shape) + +# переведем метки в one-hot +y_train = keras.utils.to_categorical(y_train, num_classes) +y_test = keras.utils.to_categorical(y_test, num_classes) +print('Shape of transformed y train:', y_train.shape) +print('Shape of transformed y test:', y_test.shape) +``` + +**Результат выполнения:** +``` +Shape of transformed X train: (50000, 32, 32, 3) +Shape of transformed X test: (10000, 32, 32, 3) +Shape of transformed y train: (50000, 10) +Shape of transformed y test: (10000, 10) +``` + +### 4) Реализовали модель сверточной нейронной сети и обучили ее на обучающих данных с выделением части обучающих данных в качестве валидационных. Вывели информацию об архитектуре нейронной сети. + +```python +model = Sequential() +model.add(layers.Conv2D(32, kernel_size=(3, 3), activation="relu", input_shape=input_shape)) +model.add(layers.MaxPooling2D(pool_size=(2, 2))) +model.add(layers.Conv2D(64, kernel_size=(3, 3), activation="relu")) +model.add(layers.MaxPooling2D(pool_size=(2, 2))) +model.add(layers.Conv2D(128, kernel_size=(3, 3), activation="relu")) +model.add(layers.MaxPooling2D(pool_size=(2, 2))) +model.add(layers.Flatten()) +model.add(layers.Dense(128, activation='relu')) +model.add(layers.Dropout(0.5)) +model.add(layers.Dense(num_classes, activation="softmax")) +model.summary() +``` + +**Результат выполнения:** +``` +Model: "sequential_1" +┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓ +┃ Layer (type) ┃ Output Shape ┃ Param # ┃ +┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩ +│ conv2d_2 (Conv2D) │ (None, 32, 32, 32) │ 896 │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ batch_normalization │ (None, 32, 32, 32) │ 128 │ +│ (BatchNormalization) │ │ │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ conv2d_3 (Conv2D) │ (None, 32, 32, 32) │ 9,248 │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ batch_normalization_1 │ (None, 32, 32, 32) │ 128 │ +│ (BatchNormalization) │ │ │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ batch_normalization_2 │ (None, 32, 32, 32) │ 128 │ +│ (BatchNormalization) │ │ │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ dropout_1 (Dropout) │ (None, 32, 32, 32) │ 0 │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ conv2d_4 (Conv2D) │ (None, 32, 32, 64) │ 18,496 │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ conv2d_5 (Conv2D) │ (None, 32, 32, 64) │ 36,928 │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ max_pooling2d_2 (MaxPooling2D) │ (None, 16, 16, 64) │ 0 │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ dropout_2 (Dropout) │ (None, 16, 16, 64) │ 0 │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ conv2d_6 (Conv2D) │ (None, 16, 16, 128) │ 73,856 │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ max_pooling2d_3 (MaxPooling2D) │ (None, 8, 8, 128) │ 0 │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ dropout_3 (Dropout) │ (None, 8, 8, 128) │ 0 │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ flatten_1 (Flatten) │ (None, 8192) │ 0 │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ dense_1 (Dense) │ (None, 128) │ 1,048,704 │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ dropout_4 (Dropout) │ (None, 128) │ 0 │ +├─────────────────────────────────┼────────────────────────┼───────────────┤ +│ dense_2 (Dense) │ (None, 10) │ 1,290 │ +└─────────────────────────────────┴────────────────────────┴───────────────┘ + Total params: 1,189,802 (4.54 MB) + Trainable params: 1,189,610 (4.54 MB) + Non-trainable params: 192 (768.00 B) + ``` + + ```python + # компилируем и обучаем модель +batch_size = 64 +epochs = 50 +model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"]) +model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.1) +``` + +### 5) Оценили качество обучения на тестовых данных. Вывели значение функции ошибки и значение метрики качества классификации на тестовых данных. + +```python +scores = model.evaluate(X_test, y_test) +print('Loss on test data:', scores[0]) +print('Accuracy on test data:', scores[1]) +``` + +**Результат выполнения:** +``` +313/313 ━━━━━━━━━━━━━━━━━━━━ 2s 5ms/step - accuracy: 0.7982 - loss: 0.6423 +Loss on test data: 0.6325967311859131 +Accuracy on test data: 0.8019000291824341 +``` + +### 6) Подали на вход обученной модели два тестовых изображения. Вывели изображения, истинные метки и результаты распознавания. + +```python +for n in [7, 16]: + result = model.predict(X_test[n:n+1]) + plt.imshow(X_test[n].reshape(32,32,3), cmap=plt.get_cmap('gray')) + plt.show() + print('Real mark: ', np.argmax(y_test[n])) + print('NN answer: ', np.argmax(result)) +``` + +**Результат выполнения:** + + +![](img_7.png) + +``` +Real mark: 4 +NN answer: 0![img_8.png](img_8.png) +``` + +![](img_8.png) + +``` +Real mark: 4 +NN answer: 4 +``` + +### 7) Вывели отчет о качестве классификации тестовой выборки и матрицу ошибок для тестовой выборки. + +```python +true_labels = np.argmax(y_test, axis=1) +# предсказанные метки классов +predicted_labels = np.argmax(model.predict(X_test), axis=1) +# отчет о качестве классификации +print(classification_report(true_labels, predicted_labels, target_names=class_names)) +# вычисление матрицы ошибок +conf_matrix = confusion_matrix(true_labels, predicted_labels) +# отрисовка матрицы ошибок в виде "тепловой карты" +display = ConfusionMatrixDisplay(confusion_matrix=conf_matrix, display_labels=class_names) +display.plot() +plt.show() +``` + +**Результат выполнения:** + +![](img_9.png) + +### По результатам классификации датасета CIFAR-10 с использованием сверточной НС можно сделать вывод, что она достаточно хорошо справляется с поставленной задачей. + + +