форкнуто от main/is_dnn
Вы не можете выбрать более 25 тем
Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.
611 строки
32 KiB
Markdown
611 строки
32 KiB
Markdown
# Отчёт по лабораторной работе №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))
|
|
```
|
|
|
|
|
|
|
|
```
|
|
Real mark: 6
|
|
NN answer: 6
|
|
```
|
|
|
|
|
|
|
|
```
|
|
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
|
|
```
|
|
|
|
|
|
|
|
---
|
|
|
|
## 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))
|
|
```
|
|
|
|
|
|
|
|
```
|
|
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))
|
|
```
|
|
|
|
|
|
|
|
```
|
|
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()
|
|
```
|
|
|
|
|
|
|
|
---
|
|
|
|
## 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))
|
|
```
|
|
|
|
|
|
|
|
```
|
|
Real mark: 4
|
|
NN answer: 0
|
|
```
|
|
|
|
|
|
|
|
```
|
|
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
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
### Модель успешно обучилась распознавать изображения из CIFAR-10, однако справляется с задачей хуже, чем на MNIST. Это связано с тем, что цветные изображения сложнее и содержат больше разнообразия, поэтому нейросети требуется более глубокая архитектура и больше ресурсов для достижения высокой точности. |