From e996935120b755112f8b1f159d66068ad6e758ff Mon Sep 17 00:00:00 2001 From: NovikovDM Date: Mon, 1 Dec 2025 23:38:08 +0300 Subject: [PATCH] 3 --- labworks/LW3/report3.md | 373 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 373 insertions(+) create mode 100644 labworks/LW3/report3.md diff --git a/labworks/LW3/report3.md b/labworks/LW3/report3.md new file mode 100644 index 0000000..507e4de --- /dev/null +++ b/labworks/LW3/report3.md @@ -0,0 +1,373 @@ +**ЛАБОРАТОРНАЯ РАБОТА №3**«Распознавание изображений»** +А-02-22 бригада №8 Левшенко Д.И., Новиков Д. М., Шестов Д.Н + +Задание1: + +**1)В среде GoogleColab создать новый блокнот(notebook). Импортировать необходимые для работы библиотеки и модули.** +```py +from google.colab import drive +drive.mount('/content/drive') +import os +os.chdir('/content/drive/MyDrive/Colab Notebooks/IS_LR3') + +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, содержащий размеченные изображения рукописных цифр.** +```py +from keras.datasets import mnist +(X_train, y_train), (X_test, y_test) = mnist.load_data() +``` +![alt text](http://uit.mpei.ru/git/NovikovDM/is_dnn/raw/branch/main/labworks/LW3/1.2.png) + +**3)Разбить набор данных на обучающие и тестовые данные в соотношении 60000:10000 элементов. При разбиении параметр random_state выбрать равным (4k–1), где k–номер бригады. Вывести размерности полученных обучающих и тестовых массивов данных.** +```py +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 = 123) + + +# вывод размерностей +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) +``` +![alt text](http://uit.mpei.ru/git/NovikovDM/is_dnn/raw/branch/main/labworks/LW3/1.3.png) +**4)Провести предобработку данных: привести обучающие и тестовые данные к формату, пригодному для обучения сверточной нейронной сети. Входные данные должны принимать значения от 0 до 1, метки цифр должны быть закодированы по принципу «one-hotencoding». Вывести размерности предобработанных обучающих и тестовых массивов данных.** +```py +# Зададим параметры данных и модели +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) +``` +![alt text](http://uit.mpei.ru/git/NovikovDM/is_dnn/raw/branch/main/labworks/LW3/1.4.png) +**5)Реализовать модель сверточной нейронной сети и обучить ее на обучающих данных с выделением части обучающих данных в качестве валидационных. Вывести информацию об архитектуре нейронной сети.** +```py +# создаем модель +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) +``` +![alt text](http://uit.mpei.ru/git/NovikovDM/is_dnn/raw/branch/main/labworks/LW3/1.5.png) +**6)Оценить качество обучения на тестовых данных. Вывести значение функции ошибки и значение метрики качества классификации на тестовых данных.** +```py +# Оценка качества работы модели на тестовых данных +scores = model.evaluate(X_test, y_test) +print('Loss on test data:', scores[0]) +print('Accuracy on test data:', scores[1]) +``` +**7)Подать на вход обученной модели два тестовых изображения. Вывести изображения, истинные метки и результаты распознавания.** +```py +# вывод тестового изображения и результата распознавания +n = 123 +result = model.predict(X_test[n:n+1]) +print('NN output:', result) +plt.show() +plt.imshow(X_test[n].reshape(28,28), cmap=plt.get_cmap('gray')) +print('Real mark: ', np.argmax(y_test[n])) +print('NN answer: ', np.argmax(result)) +``` +![alt text](http://uit.mpei.ru/git/NovikovDM/is_dnn/raw/branch/main/labworks/LW3/1.7.png) +**8)Вывести отчет о качестве классификации тестовой выборки и матрицу ошибок для тестовой выборки.** +```py +# истинные метки классов +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() +``` +![alt text](http://uit.mpei.ru/git/NovikovDM/is_dnn/raw/branch/main/labworks/LW3/1.8.1.png) +![alt text](http://uit.mpei.ru/git/NovikovDM/is_dnn/raw/branch/main/labworks/LW3/1.8.2.png) +**9)Загрузить, предобработать и подать на вход обученной нейронной сети собственное изображение, созданное при выполнении лабораторной работы No1. Вывести изображение и результат распознавания.** +```py +# загрузка собственного изображения +from PIL import Image +file_data = Image.open('test.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)) +``` +![alt text](http://uit.mpei.ru/git/NovikovDM/is_dnn/raw/branch/main/labworks/LW3/1.9.png) +**10)Сравнить обученную модель сверточной сети и наилучшую модель полносвязной сети из лабораторной работы No1** +· Количество параметров в CNN значительно меньше, чем в полносвязной сети, благодаря использованию сверток. +· CNN потребовала меньше эпох для достижения высокой точности. +· Качество классификации на тестовой выборке у CNN выше (99% против ~98% у полносвязной сети). + +Итоговый вывод: +Сверточные нейронные сети показали высокую эффективность для задачи распознавания изображений благодаря способности выделять пространственные признаки, устойчивости к сдвигам и искажениям, а также меньшему количеству обучаемых параметров по сравнению с полносвязными сетями. + + +**Задание2** + +**В новом блокноте выполнить п. 1–8 задания 1, изменив набор данных MNIST на CIFAR-10, содержащий размеченные цветные изображения объектов, разделенные на 10 классов. ** +```py +# Пункт 1-2: Импорт библиотек и загрузка данных +from keras.datasets import cifar10 +(X_train, y_train), (X_test, y_test) = cifar10.load_data() +``` +**При этом: +· в п.3 разбиение данных на обучающие и тестовые произвести в соотношении 50 000:10 000.** +```py +# Пункт 3: Разбиение данных +print("Размерности данных:") +print(f"X_train: {X_train.shape}") +print(f"y_train: {y_train.shape}") +print(f"X_test: {X_test.shape}") +print(f"y_test: {y_test.shape}") +``` +![alt text](http://uit.mpei.ru/git/NovikovDM/is_dnn/raw/branch/main/labworks/LW3/2.3.png) +```py +# Визуализация 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() +``` +![alt text](http://uit.mpei.ru/git/NovikovDM/is_dnn/raw/branch/main/labworks/LW3/2.3.2.png) + +**·после разбиения данных (между п. 3 и 4) вывести 25 изображений из обучающей выборки с подписями классов** +```py +# Пункт 4: Предобработка данных +num_classes = 10 +input_shape = (32, 32, 3) + +# Нормализация +X_train = X_train.astype('float32') / 255 +X_test = X_test.astype('float32') / 255 + +# One-hot encoding +y_train_categorical = keras.utils.to_categorical(y_train, num_classes) +y_test_categorical = keras.utils.to_categorical(y_test, num_classes) +``` + +```py +# Пункт 5: Создание и обучение модели +model = Sequential() +model.add(layers.Conv2D(32, kernel_size=(3, 3), activation="relu", input_shape=input_shape)) +model.add(layers.Conv2D(32, kernel_size=(3, 3), activation="relu")) +model.add(layers.MaxPooling2D(pool_size=(2, 2))) +model.add(layers.Dropout(0.25)) + +model.add(layers.Conv2D(64, kernel_size=(3, 3), activation="relu")) +model.add(layers.Conv2D(64, kernel_size=(3, 3), activation="relu")) +model.add(layers.MaxPooling2D(pool_size=(2, 2))) +model.add(layers.Dropout(0.25)) + +model.add(layers.Conv2D(128, kernel_size=(3, 3), activation="relu")) +model.add(layers.MaxPooling2D(pool_size=(2, 2))) +model.add(layers.Dropout(0.25)) + +model.add(layers.Flatten()) +model.add(layers.Dense(512, activation='relu')) +model.add(layers.Dropout(0.5)) +model.add(layers.Dense(256, activation='relu')) +model.add(layers.Dropout(0.5)) +model.add(layers.Dense(num_classes, activation="softmax")) + +model.summary() + +# Компиляция и обучение модели с более медленным learning rate +model.compile(loss="categorical_crossentropy", + optimizer=keras.optimizers.Adam(learning_rate=0.0005), + metrics=["accuracy"]) + +batch_size = 64 +epochs = 40 + +history = model.fit(X_train, y_train_categorical, + batch_size=batch_size, + epochs=epochs, + validation_split=0.1, + verbose=1) +``` +![alt text](http://uit.mpei.ru/git/NovikovDM/is_dnn/raw/branch/main/labworks/LW3/2.5.1.png) +![alt text](http://uit.mpei.ru/git/NovikovDM/is_dnn/raw/branch/main/labworks/LW3/2.5.2.png) +```py +# Визуализация процесса обучения +plt.figure(figsize=(12, 4)) +plt.subplot(1, 2, 1) +plt.plot(history.history['accuracy'], label='Training Accuracy') +plt.plot(history.history['val_accuracy'], label='Validation Accuracy') +plt.title('Model Accuracy') +plt.xlabel('Epoch') +plt.ylabel('Accuracy') +plt.legend() + +plt.subplot(1, 2, 2) +plt.plot(history.history['loss'], label='Training Loss') +plt.plot(history.history['val_loss'], label='Validation Loss') +plt.title('Model Loss') +plt.xlabel('Epoch') +plt.ylabel('Loss') +plt.legend() +plt.tight_layout() +plt.show() +``` +![alt text](http://uit.mpei.ru/git/NovikovDM/is_dnn/raw/branch/main/labworks/LW3/2.5.3.png) +```py +# Пункт 6: Оценка качества +test_loss, test_accuracy = model.evaluate(X_test, y_test_categorical, verbose=0) +print(f"Test loss: {test_loss:.4f}") +print(f"Test accuracy: {test_accuracy:.4f}") +``` + + +**· в п. 7 одно из тестовых изображений должно распознаваться корректно, а другое – ошибочно** +```py +# Пункт 7: Распознавание двух тестовых изображений +print("РАСПОЗНАВАНИЕ ТЕСТОВЫХ ИЗОБРАЖЕНИЙ:") + +# Функция для распознавания одного изображения из тестовой выборки +def predict_single_image(model, X, y, index, class_names): + prediction = model.predict(X[index:index+1]) + predicted_class = np.argmax(prediction[0]) + true_class = y[index][0] + + plt.figure(figsize=(8, 4)) + + plt.subplot(1, 2, 1) + plt.imshow(X[index]) + plt.title(f'Истинный класс: {class_names[true_class]}') + plt.axis('off') + + plt.subplot(1, 2, 2) + bars = plt.bar(range(10), prediction[0]) + # Подсветим предсказанный класс + bars[predicted_class].set_color('red') + plt.xticks(range(10), class_names, rotation=45) + plt.title(f'Предсказанный класс: {class_names[predicted_class]}') + plt.ylabel('Вероятность') + plt.tight_layout() + plt.show() + + print(f"Истинный класс: {class_names[true_class]}") + print(f"Предсказанный класс: {class_names[predicted_class]}") + print(f"Уверенность: {np.max(prediction[0]):.4f}") + print(f"Результат: {'Правильно' if predicted_class == true_class else 'Ошибка'}") + print("-" * 50) + + return predicted_class == true_class + +# Найдем одно правильное и одно неправильное предсказание +print("Поиск правильного и неправильного предсказания...") +all_predictions = model.predict(X_test) +all_predicted_classes = np.argmax(all_predictions, axis=1) +true_classes = y_test.flatten() + +correct_indices = [] +wrong_indices = [] + +for i in range(len(true_classes)): + if all_predicted_classes[i] == true_classes[i]: + correct_indices.append(i) + else: + wrong_indices.append(i) + + if len(correct_indices) > 0 and len(wrong_indices) > 0: + break + +if correct_indices: + print("ПРАВИЛЬНО РАСПОЗНАННОЕ ИЗОБРАЖЕНИЕ:") + predict_single_image(model, X_test, y_test, correct_indices[0], class_names) + +if wrong_indices: + print("ОШИБОЧНО РАСПОЗНАННОЕ ИЗОБРАЖЕНИЕ:") + predict_single_image(model, X_test, y_test, wrong_indices[0], class_names) +``` +![alt text](http://uit.mpei.ru/git/NovikovDM/is_dnn/raw/branch/main/labworks/LW3/2.7.1.png) +![alt text](http://uit.mpei.ru/git/NovikovDM/is_dnn/raw/branch/main/labworks/LW3/2.7.2.png) + +```py +# Пункт 8: Отчет о качестве классификации и матрица ошибок +print("ОТЧЕТ О КАЧЕСТВЕ КЛАССИФИКАЦИИ:") +true_labels = np.argmax(y_test_categorical, axis=1) +predicted_labels = np.argmax(model.predict(X_test), axis=1) + +print(classification_report(true_labels, predicted_labels, target_names=class_names)) + +print("МАТРИЦА ОШИБОК:") +conf_matrix = confusion_matrix(true_labels, predicted_labels) +display = ConfusionMatrixDisplay(confusion_matrix=conf_matrix, display_labels=class_names) +display.plot(cmap=plt.cm.Blues, xticks_rotation=45) +plt.title('Матрица ошибок - CIFAR-10') +plt.tight_layout() +plt.show() +``` +![alt text](http://uit.mpei.ru/git/NovikovDM/is_dnn/raw/branch/main/labworks/LW3/2.8.png) +![alt text](http://uit.mpei.ru/git/NovikovDM/is_dnn/raw/branch/main/labworks/LW3/2.8.2.png) + +Итоговый вывод: +CNN способна решать задачи классификации цветных изображений, однако её точность снижается при увеличении сложности данных. Для улучшения результатов требуются более глубокие архитектуры, аугментация данных и тонкая настройка гиперпараметров. + +**Общий вывод по лр 3: +Сверточные нейронные сети являются мощным инструментом для задач компьютерного зрения. CNN эффективно обрабатывают пространственные иерархии признаков, что делает их предпочтительными для работы с изображениями по сравнению с полносвязными сетями. Качество классификации зависит от сложности данных, архитектуры сети и корректности предобработки. Использование методов регуляризации (Dropout) и аугментации данных может улучшить обобщающую способность модели. Интерпретация матрицы ошибок и метрик качества позволяет анализировать слабые места модели и направлять её доработку.** \ No newline at end of file