is_dnn

35 KiB

Исходник Вина История

Задание 1

1) Подготовка рабочей среды и импорт библиотек

Инициализируем рабочую среду Google Colab и подключаем необходимые библиотеки для работы с нейронными сетями и обработки данных.

# Подключение необходимых библиотек и модулей
import os


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

Загружаем стандартный набор данных MNIST, который содержит изображения рукописных цифр от 0 до 9 с соответствующими метками.

# Импорт и загрузка датасета MNIST
from keras.datasets import mnist
(X_train, y_train), (X_test, y_test) = mnist.load_data()

3) Разделение данных на обучающую и тестовую выборки

Производим собственное разбиение датасета в соотношении 60 000:10 000. Для воспроизводимости результатов используем параметр random_state = 3 (вычисляется как 4k - 1, где k = 1 - номер нашей бригады).

# Создание собственного разбиения датасета
from sklearn.model_selection import train_test_split

# Объединение исходных обучающей и тестовой выборок в единый набор
X = np.concatenate((X_train, X_test))
y = np.concatenate((y_train, y_test))

# Разделение на обучающую и тестовую выборки согласно заданию
X_train, X_test, y_train, y_test = train_test_split(X, y,
                                                    test_size = 10000,
                                                    train_size = 60000,
                                                    random_state = 3)
# Вывод размерностей полученных массивов
print('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)

4) Предобработка данных

Выполняем нормализацию пикселей изображений (приведение к диапазону [0, 1]) и преобразование меток в формат one-hot encoding для корректной работы с категориальной функцией потерь.

# Определение параметров данных и модели
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 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)

5) Построение и обучение сверточной нейронной сети

Создаем архитектуру сверточной нейронной сети с использованием сверточных слоев, пулинга и регуляризации. Обучаем модель на подготовленных данных с выделением части данных для валидации.

# Создание модели сверточной нейронной сети
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()

# Компиляция и обучение модели
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) Оценка качества модели на тестовых данных

Проводим финальную оценку обученной модели на независимой тестовой выборке, получая значения функции потерь и точности классификации.

# Оценка качества работы обученной модели на тестовой выборке
scores = model.evaluate(X_test, y_test)
print('Loss on test data:', scores[0])
print('Accuracy on test data:', scores[1])

7) Демонстрация работы модели на отдельных примерах

Визуализируем результаты распознавания для двух тестовых изображений, сравнивая предсказания модели с истинными метками.

# Визуализация результатов распознавания для двух тестовых изображений

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))

8) Детальный анализ качества классификации

Генерируем подробный отчет о качестве классификации и строим матрицу ошибок для визуального анализа работы модели по каждому классу.

# Получение истинных и предсказанных меток для всех тестовых данных
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()

9) Тестирование на собственных изображениях

Загружаем и обрабатываем собственные изображения цифр, созданные ранее, и проверяем способность модели их корректно распознавать.

# Загрузка и обработка собственных изображений
from PIL import Image

for name_image in ['2.png', '7.png']:
  file_data = Image.open(name_image)
  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))

10) Сравнение с моделью из предыдущей лабораторной работы

Загружаем сохраненную полносвязную нейронную сеть из лабораторной работы №1 и оцениваем ее производительность на тех же тестовых данных для последующего сравнения.

model_lr1 = keras.models.load_model("best_mnist_model.keras")

model_lr1.summary()

# Подготовка данных для полносвязной сети (преобразование изображений в векторы)
X_train, X_test, y_train, y_test = train_test_split(X, y,
                                                    test_size = 10000,
                                                    train_size = 60000,
                                                    random_state = 3)
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)
print('Shape of transformed X train:', 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)

# Оценка качества работы обученной модели на тестовой выборке
scores = model_lr1.evaluate(X_test, y_test)
print('Loss on test data:', scores[0])
print('Accuracy on test data:', scores[1])

11) Сравнительный анализ моделей

Сравниваем сверточную нейронную сеть с полносвязной сетью по ключевым показателям: количеству параметров, времени обучения и качеству классификации.

Таблица1:

Модель	Количество настраиваемых параметров	Количество эпох обучения	Качество классификации тестовой выборки
Сверточная	34 826	15	accuracy: 0.988; loss: 0.041
Полносвязная	7 852	50	accuracy: 0.923; loss: 0.286

Выводы:

На основе проведенного анализа можно заключить, что сверточная нейронная сеть демонстрирует существенные преимущества перед полносвязной сетью при решении задач распознавания изображений:

Эффективность параметров: Сверточная сеть имеет больше параметров (34 826 против 7 852), но при этом показывает значительно лучшие результаты, что говорит о более эффективном использовании параметров для извлечения пространственных признаков.
Скорость обучения: Для достижения высокого качества сверточной сети требуется в 3.3 раза меньше эпох обучения (15 против 50), что существенно сокращает время обучения.
Точность классификации: Сверточная сеть показывает более высокую точность (98.8% против 92.3%) и значительно меньшую функцию потерь (0.041 против 0.286). Разница в точности составляет 6.5%, что является существенным улучшением.
Обобщающая способность: Сверточная сеть демонстрирует лучшую способность к обобщению, что видно из более низкой функции потерь на тестовых данных.

Эти результаты подтверждают, что архитектура сверточных сетей, учитывающая пространственную структуру изображений через операции свертки и пулинга, является более подходящим выбором для задач компьютерного зрения, несмотря на большее количество параметров.

Задание 2

В новом блокноте выполнили п. 2–8 задания 1, изменив набор данных MNIST на CIFAR-10, содержащий размеченные цветные изображения объектов, разделенные на 10 классов.

При этом:

- в п. 3 разбиение данных на обучающие и тестовые произвели в соотношении 50 000:10 000

- после разбиения данных (между п. 3 и 4) вывели 25 изображений из обучающей выборки с подписями классов

- в п. 7 одно из тестовых изображений должно распознаваться корректно, а другое – ошибочно.

1) Загрузка датасета CIFAR-10

Загружаем набор данных CIFAR-10, который содержит цветные изображения размером 32x32 пикселя, разделенные на 10 классов: самолет, автомобиль, птица, кошка, олень, собака, лягушка, лошадь, корабль, грузовик.

# Импорт и загрузка датасета MNIST
from keras.datasets import cifar10

(X_train, y_train), (X_test, y_test) = cifar10.load_data()

2) Разделение данных на обучающую и тестовую выборки

Создаем собственное разбиение датасета CIFAR-10 в соотношении 50 000:10 000. Используем random_state = 3 для воспроизводимости результатов (k = 1 - номер нашей бригады).

# Создание собственного разбиения датасета

# Объединение исходных обучающей и тестовой выборок в единый набор
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 = 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)

Визуализация примеров из обучающей выборки

Отображаем сетку из 25 изображений из обучающей выборки с подписями соответствующих классов для визуального ознакомления с данными.

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()

3) Предобработка данных CIFAR-10

Нормализуем значения пикселей и преобразуем метки в формат one-hot encoding для работы с категориальной функцией потерь.

# Определение параметров данных и модели
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 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)

4) Построение и обучение сверточной сети для CIFAR-10

Создаем более сложную архитектуру сверточной сети с использованием батч-нормализации и нескольких блоков свертки для работы с цветными изображениями.

# Создание модели сверточной нейронной сети
model = Sequential()

# Блок 1
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.MaxPooling2D((2, 2)))
model.add(layers.Dropout(0.25))

# Блок 2
model.add(layers.Conv2D(64, (3, 3), padding="same", activation="relu"))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(64, (3, 3), padding="same", activation="relu"))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Dropout(0.25))

# Блок 3
model.add(layers.Conv2D(128, (3, 3), padding="same", activation="relu"))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(128, (3, 3), padding="same", activation="relu"))
model.add(layers.BatchNormalization())
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Dropout(0.4))

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()

# Компиляция и обучение модели
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) Оценка качества модели на тестовых данных

Оцениваем финальную производительность обученной модели на тестовой выборке CIFAR-10.

# Оценка качества работы обученной модели на тестовой выборке
scores = model.evaluate(X_test, y_test)
print('Loss on test data:', scores[0])
print('Accuracy on test data:', scores[1])

6) Демонстрация работы модели на отдельных примерах

Визуализируем результаты распознавания для двух тестовых изображений: одно должно быть распознано корректно, другое - ошибочно.

# Визуализация результатов распознавания для двух тестовых изображений

for n in [3,14]:
  result = model.predict(X_test[n:n+1])
  print('NN output:', result)

  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))

7) Детальный анализ качества классификации CIFAR-10

Генерируем подробный отчет о качестве классификации и строим матрицу ошибок для анализа работы модели по каждому классу.

# Получение истинных и предсказанных меток для всех тестовых данных
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)

fig, ax = plt.subplots(figsize=(6, 6))
disp = ConfusionMatrixDisplay(confusion_matrix=conf_matrix,display_labels=class_names)
disp.plot(ax=ax, xticks_rotation=45)  # поворот подписей по X и приятная палитра
plt.tight_layout()  # чтобы всё влезло
plt.show()

Выводы по результатам классификации CIFAR-10:

Разработанная сверточная нейронная сеть показала хорошие результаты при классификации цветных изображений из датасета CIFAR-10. Модель достигла точности классификации около 86%, что является достойным результатом для данной задачи, учитывая сложность различения объектов в низком разрешении (32x32 пикселя) и наличие 10 различных классов.

Использование батч-нормализации и dropout-регуляризации позволило улучшить обобщающую способность модели и предотвратить переобучение. Архитектура с тремя блоками сверточных слоев эффективно извлекает иерархические признаки из изображений, что подтверждается полученными метриками качества.

35 KiB Исходник Вина История