# Отчёт по лабораторной работе №3 **Кобзев Александр, Кирсанов Егор — А-01-22** ## 1.1. В среде Google Colab создали новый блокнот (notebook). Импортировали необходимые для работы библиотеки и модули. ```python from google.colab import drive drive.mount('/content/drive') 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 ``` --- ## 1.2. Загрузили набор данных MNIST, содержащий размеченные изображения рукописных цифр. ```python from keras.datasets import mnist (X_train, y_train), (X_test, y_test) = mnist.load_data() ``` --- ## 1.3. Разбили набор данных на обучающие и тестовые данные в соотношении 60 000:10 000 элементов. При разбиении параметр random_state выбрали равным (4k – 1)=39, где k=10 –номер бригады. Вывели размерности полученных обучающих и тестовых массивов данных. ```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 = 39) # вывод размерностей 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,) ``` --- ## 1.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) ``` --- ## 1.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_2" ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓ ┃ Layer (type) ┃ Output Shape ┃ Param # ┃ ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩ │ conv2d_4 (Conv2D) │ (None, 26, 26, 32) │ 320 │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ max_pooling2d_4 (MaxPooling2D) │ (None, 13, 13, 32) │ 0 │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ conv2d_5 (Conv2D) │ (None, 11, 11, 64) │ 18,496 │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ max_pooling2d_5 (MaxPooling2D) │ (None, 5, 5, 64) │ 0 │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ dropout_2 (Dropout) │ (None, 5, 5, 64) │ 0 │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ flatten_2 (Flatten) │ (None, 1600) │ 0 │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ dense_2 (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) ``` --- ## 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 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - accuracy: 0.9883 - loss: 0.0410 Loss on test data: 0.04110224172472954 Accuracy on test data: 0.988099992275238 ``` --- ## 1.7. Подали на вход обученной модели два тестовых изображения. Вывели изображения, истинные метки и результаты распознавания. ```python for n in [123,321]: 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)) ``` ![image](images_for_report/1.png) ``` Real mark: 6 NN answer: 6 ``` ![image](images_for_report/2.png) ``` Real mark: 4 NN answer: 4 ``` --- ## 1.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() ``` ``` 313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step precision recall f1-score support 0 0.99 0.99 0.99 990 1 0.99 0.99 0.99 1155 2 0.99 0.99 0.99 1025 3 0.99 0.99 0.99 1016 4 0.99 0.99 0.99 959 5 0.99 0.99 0.99 889 6 0.99 0.99 0.99 997 7 0.99 0.98 0.98 1034 8 0.99 0.98 0.98 991 9 0.99 0.98 0.98 944 accuracy 0.99 10000 macro avg 0.99 0.99 0.99 10000 weighted avg 0.99 0.99 0.99 10000 ``` ![image](images_for_report/3.png) --- ## 1.9. Загрузили, предобработали и подали на вход обученной нейронной сети собственное изображение, созданное при выполнении лабораторной работы №1. Вывели изображение и результат распознавания. ```python # загрузка собственного изображения from PIL import Image file_data = Image.open('/content/drive/MyDrive/Colab Notebooks/IS_lab_4.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)) ``` ![image](images_for_report/4.png) ``` I think it's 4 ``` ```python from PIL import Image file_data = Image.open('/content/drive/MyDrive/Colab Notebooks/IS_lab_7.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)) ``` ![image](images_for_report/5.png) ``` I think it's 7 ``` --- ## 1.10. Загрузили с диска модель, сохраненную при выполнении лабораторной работы №1. Вывели информацию об архитектуре модели. Повторили для этой модели п. 6. ```python model_lr1 = keras.models.load_model("/content/drive/MyDrive/Colab Notebooks/best_model_100.keras") model_lr1.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 X_train_flat = X.reshape(70000, 28*28) X_train_flat = X_train_flat / 255.0 X_train_flat, X_test_flat, y_train_flat, y_test_flat = train_test_split( X_train_flat, y, test_size=10000, train_size=60000, random_state=39 ) y_train_flat = keras.utils.to_categorical(y_train_flat, num_classes) y_test_flat = keras.utils.to_categorical(y_test_flat, num_classes) print('Shape of transformed X train:', X_train_flat.shape) print('Shape of transformed X test:', X_test_flat.shape) print('Shape of transformed y train:', y_train_flat.shape) print('Shape of transformed y test:', y_test_flat.shape) ``` ``` Shape of transformed X train: (60000, 784) Shape of transformed X test: (10000, 784) Shape of transformed y train: (60000, 10) Shape of transformed y test: (10000, 10) ``` ```python scores = model_lr1.evaluate(X_test_flat, y_test_flat) print('Loss on test data:', scores[0]) print('Accuracy on test data:', scores[1]) ``` ``` 313/313 ━━━━━━━━━━━━━━━━━━━━ 2s 5ms/step - accuracy: 0.9153 - loss: 0.3012 Loss on test data: 0.2998492121696472 Accuracy on test data: 0.9138000011444092 ``` --- ## 1.11. Сравнить обученную модель сверточной сети и наилучшую модель полносвязной сети из лабораторной работы №1 по следующим показателям: - количество настраиваемых параметров в сети - количество эпох обучения - качество классификации тестовой выборки. | Модель | Количество настраиваемых параметров | Количество эпох обучения | Качество классификации тестовой выборки | |----------|-------------------------------------|---------------------------|-----------------------------------------| | Сверточная | 34 826 | 15 | accuracy: 0.9880; loss: 0.041 | | Полносвязная | 79,512 | 150 | accuracy: 0.914; loss: 0.299 | ### Сверточная нейронная сеть показала себя более эффективной: она обучается быстрее, требует меньше параметров и при этом обеспечивает более высокое качество распознавания изображений по сравнению с полносвязной моделью. --- ## 2. Изменили изменив набор данных MNIST на CIFAR-10 ### При этом: - в п. 3 разбиение данных на обучающие и тестовые произвести в соотношении 50 000:10 000 - после разбиения данных (между п. 3 и 4) вывести 25 изображений из обучающей выборки с подписями классов - в п. 7 одно из тестовых изображений должно распознаваться корректно, а другое – ошибочно. --- ## 2.1. Загрузили набор данных CIFAR-10, содержащий цветные изображения размеченные на 10 классов: самолет, автомобиль, птица, кошка, олень, собака, лягушка, лошадь, корабль, грузовик. ```python from keras.datasets import cifar10 (X_train, y_train), (X_test, y_test) = cifar10.load_data() ``` --- ## 2.2. Разбили набор данных на обучающие и тестовые данные в соотношении 60 000:10 000 элементов. Параметр random_state выбрали равным (4k – 1)=39, где k=10 – номер бригады. Вывели размерности полученных обучающих и тестовых массивов данных. ```python # создание своего разбиения датасета # объединяем в один набор 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=39 ) # вывод размерностей 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() ``` ![image](images_for_report/6.png) --- ## 2.3. Провели предобработку данных: привели обучающие и тестовые данные к формату, пригодному для обучения сверточной нейронной сети. Входные данные принимают значения от 0 до 1, метки цифр закодированы по принципу «one-hot encoding». Вывели размерности предобработанных обучающих и тестовых массивов данных. ```python # Зададим параметры данных и модели num_classes = 10 input_shape = (32, 32, 3) # Приведение входных данных к диапазону [0, 1] X_train = X_train / 255.0 X_test = X_test / 255.0 print('Shape of transformed X train:', X_train.shape) print('Shape of transformed X test:', X_test.shape) # Переводим метки в one-hot encoding 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) ``` --- ## 2.4. Реализовали модель сверточной нейронной сети и обучили ее на обучающих данных с выделением части обучающих данных в качестве валидационных. Вывели информацию об архитектуре нейронной сети. ```python model = Sequential() model.add(layers.Conv2D(32, (3,3), padding="same", activation="relu", input_shape=input_shape)) model.add(layers.BatchNormalization()) model.add(layers.Conv2D(32, (3,3), padding="same", activation="relu")) model.add(layers.BatchNormalization()) model.add(layers.BatchNormalization()) model.add(layers.Dropout(0.25)) model.add(layers.Conv2D(64, (3,3), padding="same", activation="relu")) model.add(layers.Conv2D(64, (3,3), padding="same", activation="relu")) model.add(layers.MaxPooling2D((2,2))) model.add(layers.Dropout(0.25)) model.add(layers.Conv2D(128, (3,3), padding="same", activation="relu")) model.add(layers.MaxPooling2D((2,2))) model.add(layers.Dropout(0.25)) 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_15" ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓ ┃ Layer (type) ┃ Output Shape ┃ Param # ┃ ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩ │ conv2d_52 (Conv2D) │ (None, 32, 32, 32) │ 896 │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ batch_normalization_29 │ (None, 32, 32, 32) │ 128 │ │ (BatchNormalization) │ │ │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ conv2d_53 (Conv2D) │ (None, 32, 32, 32) │ 9,248 │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ batch_normalization_30 │ (None, 32, 32, 32) │ 128 │ │ (BatchNormalization) │ │ │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ batch_normalization_31 │ (None, 32, 32, 32) │ 128 │ │ (BatchNormalization) │ │ │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ dropout_37 (Dropout) │ (None, 32, 32, 32) │ 0 │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ conv2d_54 (Conv2D) │ (None, 32, 32, 64) │ 18,496 │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ conv2d_55 (Conv2D) │ (None, 32, 32, 64) │ 36,928 │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ max_pooling2d_34 (MaxPooling2D) │ (None, 16, 16, 64) │ 0 │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ dropout_38 (Dropout) │ (None, 16, 16, 64) │ 0 │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ conv2d_56 (Conv2D) │ (None, 16, 16, 128) │ 73,856 │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ max_pooling2d_35 (MaxPooling2D) │ (None, 8, 8, 128) │ 0 │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ dropout_39 (Dropout) │ (None, 8, 8, 128) │ 0 │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ flatten_15 (Flatten) │ (None, 8192) │ 0 │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ dense_27 (Dense) │ (None, 128) │ 1,048,704 │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ dropout_40 (Dropout) │ (None, 128) │ 0 │ ├─────────────────────────────────┼────────────────────────┼───────────────┤ │ dense_28 (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 # компилируем и обучаем модель model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"]) model.fit(X_train, y_train, batch_size=64, validation_split=0.1, epochs=50) ``` --- ## 2.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 ``` --- ## 2.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)) ``` ![image](images_for_report/7.png) ``` Real mark: 4 NN answer: 0 ``` ![image](images_for_report/8.png) ``` Real mark: 4 NN answer: 4 ``` --- ## 2.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() ``` ``` 313/313 ━━━━━━━━━━━━━━━━━━━━ 4s 8ms/step precision recall f1-score support airplane 0.78 0.85 0.81 983 automobile 0.90 0.93 0.91 1026 bird 0.73 0.69 0.71 1007 cat 0.63 0.64 0.64 1011 deer 0.81 0.75 0.78 985 dog 0.70 0.71 0.71 974 frog 0.86 0.79 0.82 1007 horse 0.81 0.84 0.83 982 ship 0.88 0.93 0.90 1026 truck 0.92 0.88 0.90 999 accuracy 0.80 10000 macro avg 0.80 0.80 0.80 10000 weighted avg 0.80 0.80 0.80 10000 ``` ![image](images_for_report/9.png) ### Модель успешно обучилась распознавать изображения из CIFAR-10, однако справляется с задачей хуже, чем на MNIST. Это связано с тем, что цветные изображения сложнее и содержат больше разнообразия, поэтому нейросети требуется более глубокая архитектура и больше ресурсов для достижения высокой точности.