{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oZs0KGcz01BY"
      },
      "source": [
        "## Задание 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gz18QPRz03Ec"
      },
      "source": [
        "### 1) Подготовка рабочей среды и импорт библиотек\n",
        "\n",
        "Инициализируем рабочую среду Google Colab и подключаем необходимые библиотеки для работы с нейронными сетями и обработки данных."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mr9IszuQ1ANG"
      },
      "outputs": [],
      "source": [
        "# Подключение необходимых библиотек и модулей\n",
        "import os\n",
        "\n",
        "\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras import layers\n",
        "from tensorflow.keras.models import Sequential\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from sklearn.metrics import classification_report, confusion_matrix\n",
        "from sklearn.metrics import ConfusionMatrixDisplay"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FFRtE0TN1AiA"
      },
      "source": [
        "### 2) Загрузка датасета MNIST\n",
        "\n",
        "Загружаем стандартный набор данных MNIST, который содержит изображения рукописных цифр от 0 до 9 с соответствующими метками."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ixw5Sp0_1A-w"
      },
      "outputs": [],
      "source": [
        "# Импорт и загрузка датасета MNIST\n",
        "from keras.datasets import mnist\n",
        "(X_train, y_train), (X_test, y_test) = mnist.load_data()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aCo_lUXl1BPV"
      },
      "source": [
        "### 3) Разделение данных на обучающую и тестовую выборки\n",
        "\n",
        "Производим собственное разбиение датасета в соотношении 60 000:10 000. Для воспроизводимости результатов используем параметр random_state = 3 (вычисляется как 4k - 1, где k = 1 - номер нашей бригады)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BrSjcpEe1BeV"
      },
      "outputs": [],
      "source": [
        "# Создание собственного разбиения датасета\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "# Объединение исходных обучающей и тестовой выборок в единый набор\n",
        "X = np.concatenate((X_train, X_test))\n",
        "y = np.concatenate((y_train, y_test))\n",
        "\n",
        "# Разделение на обучающую и тестовую выборки согласно заданию\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y,\n",
        "                                                    test_size = 10000,\n",
        "                                                    train_size = 60000,\n",
        "                                                    random_state = 3)\n",
        "# Вывод размерностей полученных массивов\n",
        "print('Shape of X train:', X_train.shape)\n",
        "print('Shape of y train:', y_train.shape)\n",
        "print('Shape of X test:', X_test.shape)\n",
        "print('Shape of y test:', y_test.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4hclnNaD1BuB"
      },
      "source": [
        "### 4) Предобработка данных\n",
        "\n",
        "Выполняем нормализацию пикселей изображений (приведение к диапазону [0, 1]) и преобразование меток в формат one-hot encoding для корректной работы с категориальной функцией потерь."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xJH87ISq1B9h"
      },
      "outputs": [],
      "source": [
        "# Определение параметров данных и модели\n",
        "num_classes = 10\n",
        "input_shape = (28, 28, 1)\n",
        "\n",
        "# Нормализация значений пикселей: приведение к диапазону [0, 1]\n",
        "X_train = X_train / 255\n",
        "X_test = X_test / 255\n",
        "\n",
        "# Расширяем размерность входных данных, чтобы каждое изображение имело\n",
        "# размерность (высота, ширина, количество каналов)\n",
        "\n",
        "X_train = np.expand_dims(X_train, -1)\n",
        "X_test = np.expand_dims(X_test, -1)\n",
        "print('Shape of transformed X train:', X_train.shape)\n",
        "print('Shape of transformed X test:', X_test.shape)\n",
        "\n",
        "# Преобразование меток в формат one-hot encoding\n",
        "y_train = keras.utils.to_categorical(y_train, num_classes)\n",
        "y_test = keras.utils.to_categorical(y_test, num_classes)\n",
        "print('Shape of transformed y train:', y_train.shape)\n",
        "print('Shape of transformed y test:', y_test.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7x99O8ig1CLh"
      },
      "source": [
        "### 5) Построение и обучение сверточной нейронной сети\n",
        "\n",
        "Создаем архитектуру сверточной нейронной сети с использованием сверточных слоев, пулинга и регуляризации. Обучаем модель на подготовленных данных с выделением части данных для валидации."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Un561zSH1Cmv"
      },
      "outputs": [],
      "source": [
        "# Создание модели сверточной нейронной сети\n",
        "model = Sequential()\n",
        "model.add(layers.Conv2D(32, kernel_size=(3, 3), activation=\"relu\", input_shape=input_shape))\n",
        "model.add(layers.MaxPooling2D(pool_size=(2, 2)))\n",
        "model.add(layers.Conv2D(64, kernel_size=(3, 3), activation=\"relu\"))\n",
        "model.add(layers.MaxPooling2D(pool_size=(2, 2)))\n",
        "model.add(layers.Dropout(0.5))\n",
        "model.add(layers.Flatten())\n",
        "model.add(layers.Dense(num_classes, activation=\"softmax\"))\n",
        "\n",
        "model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "q_h8PxkN9m0v"
      },
      "outputs": [],
      "source": [
        "# Компиляция и обучение модели\n",
        "batch_size = 512\n",
        "epochs = 15\n",
        "model.compile(loss=\"categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"])\n",
        "model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HL2_LVga1C3l"
      },
      "source": [
        "### 6) Оценка качества модели на тестовых данных\n",
        "\n",
        "Проводим финальную оценку обученной модели на независимой тестовой выборке, получая значения функции потерь и точности классификации."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "81Cgq8dn9uL6"
      },
      "outputs": [],
      "source": [
        "# Оценка качества работы обученной модели на тестовой выборке\n",
        "scores = model.evaluate(X_test, y_test)\n",
        "print('Loss on test data:', scores[0])\n",
        "print('Accuracy on test data:', scores[1])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KzrVY1SR1DZh"
      },
      "source": [
        "### 7) Демонстрация работы модели на отдельных примерах\n",
        "\n",
        "Визуализируем результаты распознавания для двух тестовых изображений, сравнивая предсказания модели с истинными метками."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dbfkWjDI1Dp7"
      },
      "outputs": [],
      "source": [
        "# Визуализация результатов распознавания для двух тестовых изображений\n",
        "\n",
        "for n in [3,26]:\n",
        "  result = model.predict(X_test[n:n+1])\n",
        "  print('NN output:', result)\n",
        "\n",
        "  plt.imshow(X_test[n].reshape(28,28), cmap=plt.get_cmap('gray'))\n",
        "  plt.show()\n",
        "  print('Real mark: ', np.argmax(y_test[n]))\n",
        "  print('NN answer: ', np.argmax(result))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YgiVGr5_1D3u"
      },
      "source": [
        "### 8) Детальный анализ качества классификации\n",
        "\n",
        "Генерируем подробный отчет о качестве классификации и строим матрицу ошибок для визуального анализа работы модели по каждому классу."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7MqcG_wl1EHI"
      },
      "outputs": [],
      "source": [
        "# Получение истинных и предсказанных меток для всех тестовых данных\n",
        "true_labels = np.argmax(y_test, axis=1)\n",
        "\n",
        "predicted_labels = np.argmax(model.predict(X_test), axis=1)\n",
        "\n",
        "# Вывод подробного отчета о качестве классификации\n",
        "print(classification_report(true_labels, predicted_labels))\n",
        "# Построение и визуализация матрицы ошибок\n",
        "conf_matrix = confusion_matrix(true_labels, predicted_labels)\n",
        "\n",
        "display = ConfusionMatrixDisplay(confusion_matrix=conf_matrix)\n",
        "display.plot()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "amaspXGW1EVy"
      },
      "source": [
        "### 9) Тестирование на собственных изображениях\n",
        "\n",
        "Загружаем и обрабатываем собственные изображения цифр, созданные ранее, и проверяем способность модели их корректно распознавать."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ktWEeqWd1EyF"
      },
      "outputs": [],
      "source": [
        "# Загрузка и обработка собственных изображений\n",
        "from PIL import Image\n",
        "\n",
        "for name_image in ['2.png', '7.png']:\n",
        "  file_data = Image.open(name_image)\n",
        "  file_data = file_data.convert('L') # перевод в градации серого\n",
        "  test_img = np.array(file_data)\n",
        "\n",
        "  # вывод собственного изображения\n",
        "  plt.imshow(test_img, cmap=plt.get_cmap('gray'))\n",
        "  plt.show()\n",
        "\n",
        "  # предобработка\n",
        "  test_img = test_img / 255\n",
        "  test_img = np.reshape(test_img, (1,28,28,1))\n",
        "\n",
        "  # распознавание\n",
        "  result = model.predict(test_img)\n",
        "  print('I think it\\'s', np.argmax(result))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mgrihPd61E8w"
      },
      "source": [
        "### 10) Сравнение с моделью из предыдущей лабораторной работы\n",
        "\n",
        "Загружаем сохраненную полносвязную нейронную сеть из лабораторной работы №1 и оцениваем ее производительность на тех же тестовых данных для последующего сравнения."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DblXqn3l1FL2"
      },
      "outputs": [],
      "source": [
        "model_lr1 = keras.models.load_model(\"best_mnist_model.keras\")\n",
        "\n",
        "model_lr1.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0ki8fhJrEyEt"
      },
      "outputs": [],
      "source": [
        "# Подготовка данных для полносвязной сети (преобразование изображений в векторы)\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y,\n",
        "                                                    test_size = 10000,\n",
        "                                                    train_size = 60000,\n",
        "                                                    random_state = 3)\n",
        "num_pixels = X_train.shape[1] * X_train.shape[2]\n",
        "X_train = X_train.reshape(X_train.shape[0], num_pixels) / 255\n",
        "X_test = X_test.reshape(X_test.shape[0], num_pixels) / 255\n",
        "print('Shape of transformed X train:', X_train.shape)\n",
        "print('Shape of transformed X train:', X_test.shape)\n",
        "\n",
        "# Преобразование меток в формат one-hot encoding\n",
        "y_train = keras.utils.to_categorical(y_train, num_classes)\n",
        "y_test = keras.utils.to_categorical(y_test, num_classes)\n",
        "print('Shape of transformed y train:', y_train.shape)\n",
        "print('Shape of transformed y test:', y_test.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0Yj0fzLNE12k"
      },
      "outputs": [],
      "source": [
        "# Оценка качества работы обученной модели на тестовой выборке\n",
        "scores = model_lr1.evaluate(X_test, y_test)\n",
        "print('Loss on test data:', scores[0])\n",
        "print('Accuracy on test data:', scores[1])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MsM3ew3d1FYq"
      },
      "source": [
        "### 11) Сравнительный анализ моделей\n",
        "\n",
        "Сравниваем сверточную нейронную сеть с полносвязной сетью по ключевым показателям: количеству параметров, времени обучения и качеству классификации."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xxFO4CXbIG88"
      },
      "source": [
        "Таблица1:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xvoivjuNFlEf"
      },
      "source": [
        "| Модель   | Количество настраиваемых параметров | Количество эпох обучения | Качество классификации тестовой выборки |\n",
        "|----------|-------------------------------------|---------------------------|-----------------------------------------|\n",
        "| Сверточная | 34 826                              | 15                        | accuracy: 0.988; loss: 0.041                                   |\n",
        "| Полносвязная | 7 852                              | 50                        | accuracy: 0.923; loss: 0.286                                  |\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YctF8h_sIB-P"
      },
      "source": [
        "**Выводы:**\n",
        "\n",
        "На основе проведенного анализа можно заключить, что сверточная нейронная сеть демонстрирует существенные преимущества перед полносвязной сетью при решении задач распознавания изображений:\n",
        "\n",
        "1. **Эффективность параметров**: Сверточная сеть имеет больше параметров (34 826 против 7 852), но при этом показывает значительно лучшие результаты, что говорит о более эффективном использовании параметров для извлечения пространственных признаков.\n",
        "\n",
        "2. **Скорость обучения**: Для достижения высокого качества сверточной сети требуется в 3.3 раза меньше эпох обучения (15 против 50), что существенно сокращает время обучения.\n",
        "\n",
        "3. **Точность классификации**: Сверточная сеть показывает более высокую точность (98.8% против 92.3%) и значительно меньшую функцию потерь (0.041 против 0.286). Разница в точности составляет 6.5%, что является существенным улучшением.\n",
        "\n",
        "4. **Обобщающая способность**: Сверточная сеть демонстрирует лучшую способность к обобщению, что видно из более низкой функции потерь на тестовых данных.\n",
        "\n",
        "Эти результаты подтверждают, что архитектура сверточных сетей, учитывающая пространственную структуру изображений через операции свертки и пулинга, является более подходящим выбором для задач компьютерного зрения, несмотря на большее количество параметров."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wCLHZPGB1F1y"
      },
      "source": [
        "## Задание 2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DUOYls124TT8"
      },
      "source": [
        "### В новом блокноте выполнили п. 2–8 задания 1, изменив набор данных MNIST на CIFAR-10, содержащий размеченные цветные изображения объектов, разделенные на 10 классов.  \n",
        "### При этом:\n",
        "### - в п. 3 разбиение данных на обучающие и тестовые произвели в соотношении 50 000:10 000\n",
        "### - после разбиения данных (между п. 3 и 4) вывели 25 изображений из обучающей выборки с подписями классов\n",
        "### - в п. 7 одно из тестовых изображений должно распознаваться корректно, а другое – ошибочно.   "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XDStuSpEJa8o"
      },
      "source": [
        "### 1) Загрузка датасета CIFAR-10\n",
        "\n",
        "Загружаем набор данных CIFAR-10, который содержит цветные изображения размером 32x32 пикселя, разделенные на 10 классов: самолет, автомобиль, птица, кошка, олень, собака, лягушка, лошадь, корабль, грузовик."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "y0qK7eKL4Tjy"
      },
      "outputs": [],
      "source": [
        "# Импорт и загрузка датасета MNIST\n",
        "from keras.datasets import cifar10\n",
        "\n",
        "(X_train, y_train), (X_test, y_test) = cifar10.load_data()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wTHiBy-ZJ5oh"
      },
      "source": [
        "### 2) Разделение данных на обучающую и тестовую выборки\n",
        "\n",
        "Создаем собственное разбиение датасета CIFAR-10 в соотношении 50 000:10 000. Используем random_state = 3 для воспроизводимости результатов (k = 1 - номер нашей бригады)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DlnFbQogKD2v"
      },
      "outputs": [],
      "source": [
        "# Создание собственного разбиения датасета\n",
        "\n",
        "# Объединение исходных обучающей и тестовой выборок в единый набор\n",
        "X = np.concatenate((X_train, X_test))\n",
        "y = np.concatenate((y_train, y_test))\n",
        "\n",
        "# Разделение на обучающую и тестовую выборки согласно заданию\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y,\n",
        "                                                    test_size = 10000,\n",
        "                                                    train_size = 50000,\n",
        "                                                    random_state = 3)\n",
        "# Вывод размерностей полученных массивов\n",
        "print('Shape of X train:', X_train.shape)\n",
        "print('Shape of y train:', y_train.shape)\n",
        "print('Shape of X test:', X_test.shape)\n",
        "print('Shape of y test:', y_test.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pj3bMaz1KZ3a"
      },
      "source": [
        "### Визуализация примеров из обучающей выборки\n",
        "\n",
        "Отображаем сетку из 25 изображений из обучающей выборки с подписями соответствующих классов для визуального ознакомления с данными."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TW8D67KEKhVE"
      },
      "outputs": [],
      "source": [
        "class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',\n",
        "               'dog', 'frog', 'horse', 'ship', 'truck']\n",
        "\n",
        "plt.figure(figsize=(10,10))\n",
        "for i in range(25):\n",
        "    plt.subplot(5,5,i+1)\n",
        "    plt.xticks([])\n",
        "    plt.yticks([])\n",
        "    plt.grid(False)\n",
        "    plt.imshow(X_train[i])\n",
        "    plt.xlabel(class_names[y_train[i][0]])\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d3TPr2w1KQTK"
      },
      "source": [
        "### 3) Предобработка данных CIFAR-10\n",
        "\n",
        "Нормализуем значения пикселей и преобразуем метки в формат one-hot encoding для работы с категориальной функцией потерь."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iFDpxEauLZ8j"
      },
      "outputs": [],
      "source": [
        "# Определение параметров данных и модели\n",
        "num_classes = 10\n",
        "input_shape = (32, 32, 3)\n",
        "\n",
        "# Нормализация значений пикселей: приведение к диапазону [0, 1]\n",
        "X_train = X_train / 255\n",
        "X_test = X_test / 255\n",
        "\n",
        "print('Shape of transformed X train:', X_train.shape)\n",
        "print('Shape of transformed X test:', X_test.shape)\n",
        "\n",
        "# Преобразование меток в формат one-hot encoding\n",
        "y_train = keras.utils.to_categorical(y_train, num_classes)\n",
        "y_test = keras.utils.to_categorical(y_test, num_classes)\n",
        "print('Shape of transformed y train:', y_train.shape)\n",
        "print('Shape of transformed y test:', y_test.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ydNITXptLeGT"
      },
      "source": [
        "### 4) Построение и обучение сверточной сети для CIFAR-10\n",
        "\n",
        "Создаем более сложную архитектуру сверточной сети с использованием батч-нормализации и нескольких блоков свертки для работы с цветными изображениями."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YhAD5CllLlv7"
      },
      "outputs": [],
      "source": [
        "# Создание модели сверточной нейронной сети\n",
        "model = Sequential()\n",
        "\n",
        "# Блок 1\n",
        "model.add(layers.Conv2D(32, (3, 3), padding=\"same\",\n",
        "                        activation=\"relu\", input_shape=input_shape))\n",
        "model.add(layers.BatchNormalization())\n",
        "model.add(layers.Conv2D(32, (3, 3), padding=\"same\", activation=\"relu\"))\n",
        "model.add(layers.BatchNormalization())\n",
        "model.add(layers.MaxPooling2D((2, 2)))\n",
        "model.add(layers.Dropout(0.25))\n",
        "\n",
        "# Блок 2\n",
        "model.add(layers.Conv2D(64, (3, 3), padding=\"same\", activation=\"relu\"))\n",
        "model.add(layers.BatchNormalization())\n",
        "model.add(layers.Conv2D(64, (3, 3), padding=\"same\", activation=\"relu\"))\n",
        "model.add(layers.BatchNormalization())\n",
        "model.add(layers.MaxPooling2D((2, 2)))\n",
        "model.add(layers.Dropout(0.25))\n",
        "\n",
        "# Блок 3\n",
        "model.add(layers.Conv2D(128, (3, 3), padding=\"same\", activation=\"relu\"))\n",
        "model.add(layers.BatchNormalization())\n",
        "model.add(layers.Conv2D(128, (3, 3), padding=\"same\", activation=\"relu\"))\n",
        "model.add(layers.BatchNormalization())\n",
        "model.add(layers.MaxPooling2D((2, 2)))\n",
        "model.add(layers.Dropout(0.4))\n",
        "\n",
        "model.add(layers.Flatten())\n",
        "model.add(layers.Dense(128, activation='relu'))\n",
        "model.add(layers.Dropout(0.5))\n",
        "model.add(layers.Dense(num_classes, activation=\"softmax\"))\n",
        "\n",
        "\n",
        "model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3otvqMjjOdq5"
      },
      "outputs": [],
      "source": [
        "# Компиляция и обучение модели\n",
        "batch_size = 64\n",
        "epochs = 50\n",
        "model.compile(loss=\"categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"])\n",
        "model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vv1kUHWTLl9B"
      },
      "source": [
        "### 5) Оценка качества модели на тестовых данных\n",
        "\n",
        "Оцениваем финальную производительность обученной модели на тестовой выборке CIFAR-10."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SaDxydiyLmRX"
      },
      "outputs": [],
      "source": [
        "# Оценка качества работы обученной модели на тестовой выборке\n",
        "scores = model.evaluate(X_test, y_test)\n",
        "print('Loss on test data:', scores[0])\n",
        "print('Accuracy on test data:', scores[1])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OdgEiyUGLmhP"
      },
      "source": [
        "### 6) Демонстрация работы модели на отдельных примерах\n",
        "\n",
        "Визуализируем результаты распознавания для двух тестовых изображений: одно должно быть распознано корректно, другое - ошибочно."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "t3yGj1MlLm9H"
      },
      "outputs": [],
      "source": [
        "# Визуализация результатов распознавания для двух тестовых изображений\n",
        "\n",
        "for n in [3,14]:\n",
        "  result = model.predict(X_test[n:n+1])\n",
        "  print('NN output:', result)\n",
        "\n",
        "  plt.imshow(X_test[n].reshape(32,32,3), cmap=plt.get_cmap('gray'))\n",
        "  plt.show()\n",
        "  print('Real mark: ', np.argmax(y_test[n]))\n",
        "  print('NN answer: ', np.argmax(result))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3h6VGDRrLnNC"
      },
      "source": [
        "### 7) Детальный анализ качества классификации CIFAR-10\n",
        "\n",
        "Генерируем подробный отчет о качестве классификации и строим матрицу ошибок для анализа работы модели по каждому классу."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "od56oyyzM0nw"
      },
      "outputs": [],
      "source": [
        "# Получение истинных и предсказанных меток для всех тестовых данных\n",
        "true_labels = np.argmax(y_test, axis=1)\n",
        "\n",
        "predicted_labels = np.argmax(model.predict(X_test), axis=1)\n",
        "\n",
        "# Вывод подробного отчета о качестве классификации\n",
        "print(classification_report(true_labels, predicted_labels, target_names=class_names))\n",
        "# Построение и визуализация матрицы ошибок\n",
        "conf_matrix = confusion_matrix(true_labels, predicted_labels)\n",
        "\n",
        "fig, ax = plt.subplots(figsize=(6, 6))\n",
        "disp = ConfusionMatrixDisplay(confusion_matrix=conf_matrix,display_labels=class_names)\n",
        "disp.plot(ax=ax, xticks_rotation=45)  # поворот подписей по X и приятная палитра\n",
        "plt.tight_layout()  # чтобы всё влезло\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RF4xK1cxamBc"
      },
      "source": [
        "**Выводы по результатам классификации CIFAR-10:**\n",
        "\n",
        "Разработанная сверточная нейронная сеть показала хорошие результаты при классификации цветных изображений из датасета CIFAR-10. Модель достигла точности классификации около 86%, что является достойным результатом для данной задачи, учитывая сложность различения объектов в низком разрешении (32x32 пикселя) и наличие 10 различных классов.\n",
        "\n",
        "Использование батч-нормализации и dropout-регуляризации позволило улучшить обобщающую способность модели и предотвратить переобучение. Архитектура с тремя блоками сверточных слоев эффективно извлекает иерархические признаки из изображений, что подтверждается полученными метриками качества."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.11.9"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}