AlexNet обучен работе с набором данных Mnsit (реализация и теория Python Tensorflow)

Привет, это Арвин. Сегодня я собираюсь написать об AlexNet, еще одной модели нейронной сети, которая очень популярна, и мы хотим реализовать ее в наборе данных Mnist, как мы сделали с LeNet, но на этот раз я собираюсь смешать теорию и реализацию в одну статью. сначала мы приступим к реализации для тех, кто просто хочет завершить свой проект. Вот ссылка на полный код:



YouTube/alexnet.ipynb на главной · ArthasMenethil-A/YouTube
Вы не можете выполнить это действие в данный момент. Вы вошли в другую вкладку или окно. Вы вышли на другой вкладке или…github.com



Краткий обзор наших предметов: (Я уже объяснял это в предыдущей статье, но я собираюсь взглянуть на них по-другому. Может быть, я смогу сделать это еще лучше).

  • Реализация AlexNet
  • Сверточный слой
  • Макс. объединяющий слой
  • Слой пакетной нормализации
  • Сгладить слой
  • Плотный слой
  • Выпадающий слой

РЕАЛИЗАЦИЯ КОДА

У нас есть 6 основных шагов в реализации модели в каждой модели NN:

  1. Импорт пакетов
  2. Загрузка набора данных
  3. Набор данных предварительной обработки
  4. Построить структуру модели
  5. Модель поезда
  6. Оцените производительность

мы проходим все эти шаги в каждой реализации

ИМПОРТ ПАКЕТОВ

Сначала мы импортируем numpy и matplotlib.pyplot, как обычно, потому что мы хотим иметь возможность манипулировать данными, подобными массиву, и отображать изображения и графики.

import numpy as np 
import matplotlib.pyplot as plt

Теперь пришло время для импорта Tensorflow, как обычно. Давайте импортируем набор данных Mnist и функцию горячего кодировщика (to_categorical). Затем мы импортируем класс Sequential, который позволит нам строить структуру модели слой за слоем. И, наконец, мы должны импортировать слои.

import tensorflow 
from tensorflow.keras.datasets import mnist 
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.models import Sequential 
from tensorflow.keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D, BatchNormalization

ЗАГРУЗКА ДАННЫХ

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

(X_train, y_train), (X_valid, y_valid) = mnist.load_data()

Вывод Colab будет:

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11490434/11490434 [==============================] - 1s 0us/step

ПРЕДВАРИТЕЛЬНАЯ ОБРАБОТКА ДАННЫХ

Первое, что мы делаем в процессе предварительной обработки, — это преобразуем данные из 3D в 4D. Таким образом, команда будет выглядеть так:

X_train = X_train.reshape(-1, 28, 28, 1).astype("float32")
X_valid = X_valid.reshape(-1, 28, 28, 1).astype("float32")

Четыре измерения:

(количество_выборок, высота_изображения, ширина_изображения, количество_каналов)

Затем нормализуем данные.

X_train /= 255
X_valid /= 255

наконец пришло время для одноразового кодирования.

n_classes = 10
y_train = to_categorical(y_train, n_classes)
y_valid = to_categorical(y_valid, n_classes

ПОСТРОЕНИЕ СТРУКТУРЫ МОДЕЛИ

Теперь пришло время построить структуру модели слой за слоем. В этом блоке кода я просто пишу, как это должно выглядеть, но я объясню слои внутри теоретической части. Сначала мы инициализируем модель с помощью класса «Sequential()». Затем мы добавляем к нему каждый слой AlexNet. Наконец, мы проверяем сводку модели, в которой указывается количество параметров.

model = Sequential()

model.add(Conv2D(96, kernel_size=(11, 11), strides=(1, 1), activation="relu", input_shape=(28, 28, 1)))
model.add(MaxPooling2D(pool_size=(3, 3), strides=(1, 1,)))
model.add(BatchNormalization())

model.add(Conv2D(256, kernel_size=(5, 5), activation="relu"))
model.add(MaxPooling2D(pool_size=(3, 3), strides=(1, 1)))
model.add(BatchNormalization())

model.add(Conv2D(256, kernel_size=(3, 3), activation="relu"))
model.add(Conv2D(384, kernel_size=(3, 3), activation="relu"))
model.add(Conv2D(384, kernel_size=(3, 3), activation="relu"))
model.add(MaxPooling2D(pool_size=(3, 3), strides=(1, 1)))
model.add(BatchNormalization())

model.add(Flatten())
model.add(Dense(4096, activation="tanh"))
model.add(Dropout(0.5))
model.add(Dense(4096, activation="tanh"))
model.add(Dropout(0.5))

model.add(Dense(10, activation="softmax"))

model.summary()

Результатом будет сводка модели:

Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 conv2d (Conv2D)             (None, 18, 18, 96)        11712     
                                                                 
 max_pooling2d (MaxPooling2D  (None, 16, 16, 96)       0         
 )                                                               
                                                                 
 batch_normalization (BatchN  (None, 16, 16, 96)       384       
 ormalization)                                                   
                                                                 
 conv2d_1 (Conv2D)           (None, 12, 12, 256)       614656    
                                                                 
 max_pooling2d_1 (MaxPooling  (None, 10, 10, 256)      0         
 2D)                                                             
                                                                 
 batch_normalization_1 (Batc  (None, 10, 10, 256)      1024      
 hNormalization)                                                 
                                                                 
 conv2d_2 (Conv2D)           (None, 8, 8, 256)         590080    
                                                                 
 conv2d_3 (Conv2D)           (None, 6, 6, 384)         885120    
                                                                 
 conv2d_4 (Conv2D)           (None, 4, 4, 384)         1327488   
                                                                 
 max_pooling2d_2 (MaxPooling  (None, 2, 2, 384)        0         
 2D)                                                             
                                                                 
 batch_normalization_2 (Batc  (None, 2, 2, 384)        1536      
 hNormalization)                                                 
                                                                 
 flatten (Flatten)           (None, 1536)              0         
                                                                 
 dense (Dense)               (None, 4096)              6295552   
                                                                 
 dropout (Dropout)           (None, 4096)              0         
                                                                 
 dense_1 (Dense)             (None, 4096)              16781312  
                                                                 
 dropout_1 (Dropout)         (None, 4096)              0         
                                                                 
 dense_2 (Dense)             (None, 10)                40970     
                                                                 
=================================================================
Total params: 26,549,834
Trainable params: 26,548,362
Non-trainable params: 1,472
_________________________________________________________________

СОСТАВЛЕНИЕ МОДЕЛИ

Теперь пришло время скомпилировать модель с функцией потерь «Categorical Cross Entropy» и оптимизатором Nadam.

model.compile(loss='categorical_crossentropy', optimizer='nadam', metrics=['accuracy'])

После завершения компиляции мы перейдем к подгонке модели к нашим данным.

ОБУЧЕНИЕ МОДЕЛИ

Мы используем наши данные обучения и проверки для подбора и оценки модели. Размер пакета будет 128, а количество эпох — 10.

model.fit(X_train, y_train, batch_size=128, epochs=10, verbose=1, validation_data=(X_valid, y_valid))

Вывод будет:

Epoch 1/10
469/469 [==============================] - 37s 53ms/step - loss: 0.4085 - accuracy: 0.9322 - val_loss: 0.6785 - val_accuracy: 0.8569

...

Epoch 10/10
469/469 [==============================] - 24s 51ms/step - loss: 0.1018 - accuracy: 0.9829 - val_loss: 0.2004 - val_accuracy: 0.9737
<keras.callbacks.History at 0x7f4a900651f0>

Как вы можете видеть, к концу мы получим точность ~ 97% наших данных проверки.

ТЕОРИЯ

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

  • Сверточный слой
  • Макс. объединяющий слой
  • Слой пакетной нормализации
  • Сгладить слой
  • Плотный активационный слой
  • Выбывать

Кстати, у меня уже есть более подробное объяснение всех этих слоев внутри этой ссылки: эта ссылка

СВЕРТОЧНЫЙ СЛОЙ

Съешь эту лягушку, говорят, а? хорошо. Что это за сверточный слой:

  1. При обучении сверточный слой изучает, какие интересные особенности могут быть внутри определенного объекта.
  2. В предсказании сверточный слой ищет эти интересные функции внутри данного изображения.

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

МАКСИМАЛЬНЫЙ СЛОЙ

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

СЛОЙ ПАКЕТНОЙ НОРМАЛИЗАЦИИ

Вы, наверное, уже знаете, что означает нормализация, это означает, что мы приводим все числа в наших входных данных между -1 и 1. Почему? Потому что мы хотим сделать эффект каждой функции одинаковым. Например, если вход состоит из признака, представленного большими числами, такими как миллион или два миллиона, то эффект других признаков, представленных меньшими числами, просто исчезнет.

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

ВЫПОЛНИТЬ СЛОЙ

Слой Flatten меняет все на вектор. Например, если у вас есть матрица [28 * 28] после ее сглаживания, у вас будет вектор [784].

ДИЗАЙН АКТИВАЦИОННЫЙ СЛОЙ

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

ВЫБЫВАТЬ

Выпадающие слои предназначены для предотвращения переобучения. Что он делает, так это то, что он деактивирует некоторые нейроны случайным образом на каждом этапе. Так что это что-то вроде противоположности полностью связанным слоям.

Спасибо, что остаетесь со мной. ХОРОШЕГО ДНЯ!!!