Сверточная нейронная сеть — реализация PyTorch на наборе данных CIFAR-10

Переиздано Платоном

Читают: 0

Эта статья была опубликована в рамках Блогатон по Data Science

Введение

Cifar 10 | Сверточные нейронные сети pytorch — изображение 1

Сверточные нейронные сети, также называемые ConvNets, были впервые представлены в 1980-х Янном ЛеКуном, исследователем в области компьютерных наук, который работал в фоновом режиме. ЛеКун построил на основе работы Кунихико Фукусима, японского ученого, базовую сеть для распознавания изображений.

Старая версия CNN, названная LeNet (в честь LeCun), может видеть рукописные цифры. CNN помогает найти пин-коды по почте. Но, несмотря на свой опыт, ConvNets оставались близкими к компьютерному зрению и искусственному интеллекту, потому что столкнулись с серьезной проблемой: они не могли сильно масштабироваться. CNN требует большого количества данных и интеграции ресурсов, чтобы хорошо работать с большими изображениями.

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

Сверточные нейронные сети pytorch — изображение 2

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

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

Импорт библиотеки PyTorch

импортировать numpy как np импортировать pandas как pd

import torch import torch.nn.functional as F из наборов данных импорта torchvision, преобразования из torch import nn import matplotlib.pyplot as plt import numpy as np import seaborn as sns # from tqdm.notebook import tqdm from tqdm import tqdm

На этом этапе мы импортируем необходимые библиотеки. Мы видим, что используем NumPy для числовых операций и pandas для операций с фреймами данных. Библиотека torch используется для импорта Pytorch.

Pytorch имеет компонент nn, который используется для абстракции операций и функций машинного обучения. Он импортируется как F. Библиотека torchvision используется для импорта набора данных CIFAR-10. Эта библиотека содержит множество наборов данных изображений и широко используется для исследований. Преобразования можно импортировать, чтобы мы могли изменить размер изображения до одинакового размера для всех изображений. Tqdm используется для отслеживания прогресса во время обучения и используется для визуализации.

Прочтите необходимый набор данных

trainData = pd.read_csv ('cifar-10 / trainLabels.csv') trainData.head ()

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

Анализ данных с помощью PyTorch

print ("Количество точек:", trainData.shape [0]) print ("Количество функций:", trainData.shape [1]) print ("Возможности:", trainData.columns.values) print ("Количество Уникальные значения ") для col в trainData: print (col,": ", len (trainData [col] .unique ())) plt.figure (figsize = (12,8))

Вывод:

Количество точек: 50000 Количество функций: 2 Функции: ['id' 'label'] Количество уникальных значений id: 50000 label: 10

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

Получение набора проверки с помощью PyTorch

из torch.utils.data import random_split val_size = 5000 train_size = len (dataset) - val_size train_ds, val_ds = random_split (dataset, [train_size, val_size]) len (train_ds), len (val_ds)

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

(45000, 5000)

из torch.utils.data.dataloader import DataLoader batch_size = 64 train_dl = DataLoader (train_ds, batch_size, shuffle = True, num_workers = 4, pin_memory = True) val_dl = DataLoader (val_ds, batch_size, num_workmory = 4,

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

Определение требуемых функций

@ torch.no_grad () def precision (выходы, метки): _, preds = torch.max (output, dim = 1) return torch.tensor (torch.sum (preds == labels) .item () / len (preds )) class ImageClassificationBase (nn.Module): def training_step (self, batch): images, labels = batch out = self (images) # Генерировать прогнозы loss = F.cross_entropy (out, labels) # Вычислить погрешность потерь = точность (out , labels) return loss, accu def validation_step (self, batch): images, labels = batch out = self (images) # Генерировать прогнозы потерь = F.cross_entropy (out, labels) # Расчет потерь acc = precision (out, labels) # Вычислить точность return {'Loss': loss.detach (), 'Accuracy': acc} def validation_epoch_end (self, output): batch_losses = [x ['Loss'] для x в выходах] epoch_loss = torch.stack (batch_losses ) .mean () # Объединить потери batch_accs = [x ['Accuracy'] для x в выходных данных] epoch_acc = torch.stack (batch_accs) .mean () # Объединить точность return {'Loss': epoch_loss.item (), ' Точность ': epoch_acc.item ()} def epoch_end (self, epoch, result): pr int ("Epoch:", epoch + 1) print (f'Train Accuracy: {result ["train_accuracy"] * 100: .2f}% Точность проверки: {result ["Accuracy"] * 100: .2f}% ' ) print (f'Train Loss: {result ["train_loss"] :. 4f} Validation Loss: {result ["Loss"] :. 4f} ')

Как мы видим здесь, мы использовали реализацию класса ImageClassification, и он принимает один параметр - nn.Module. В этом классе мы можем реализовать различные функции или различные шаги, такие как обучение, проверка и т. Д. Функции здесь являются простыми реализациями Python.

На этапе обучения изображения и этикетки создаются партиями. мы используем кросс-энтропию для функции потерь, вычисляем потерю и возвращаем потерю. Это похоже на этап проверки, как мы можем видеть в функции. Конец эпохи сочетает в себе потери и точности, и, наконец, мы печатаем точности и потери.

Реализация модуля сверточной нейронной сети

class Cifar10CnnModel (ImageClassificationBase): def __init __ (self): super () .__ init __ () self.network = nn.Sequential (nn.Conv2d (3, 32, kernel_size = 3, padding = 1), nn.ReLU (), nn.Conv2d (32, 64, размер_ядра = 3, шаг = 1, отступ = 1), nn.ReLU (), nn.MaxPool2d (2, 2), # вывод: 64 x 16 x 16 nn.BatchNorm2d (64) , nn.Conv2d (64, 128, размер_ядра = 3, шаг = 1, отступ = 1), nn.ReLU (), nn.Conv2d (128, 128, размер_ядра = 3, шаг = 1, отступ = 1), nn .ReLU (), nn.MaxPool2d (2, 2), # output: 128 x 8 x 8 nn.BatchNorm2d (128), nn.Conv2d (128, 256, kernel_size = 3, stride = 1, padding = 1), nn.ReLU (), nn.Conv2d (256, 256, kernel_size = 3, stride = 1, padding = 1), nn.ReLU (), nn.MaxPool2d (2, 2), # вывод: 256 x 4 x 4 nn.BatchNorm2d (256), nn.Flatten (), nn.Linear (256 * 4 * 4, 1024), nn.ReLU (), nn.Linear (1024, 512), nn.ReLU (), nn.Linear (512, 10)) def forward (self, xb): вернуть self.network (xb)

Это самая важная часть реализации нейронной сети. На всем протяжении мы используем модуль nn, импортированный из torch. Как мы видим в первой строке, Conv2d - это модуль, который помогает реализовать сверточную нейронную сеть. Первый параметр 3 здесь означает, что изображение цветное и в формате RGB. Если бы это было изображение в градациях серого, мы бы выбрали 1.

32 - это размер исходного выходного канала, и когда мы перейдем к следующему слою conv2d, у нас будет 32 как входной канал и 64 как выходной канал.

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

Операция свертки связана с активационным слоем и здесь Relu. После двух слоев Conv2d у нас есть операция max-pooling размером 2 * 2. Выходное значение нормализовано для стабильности и во избежание внутреннего ковариатного сдвига. Эти операции повторяются с большим количеством слоев, чтобы углубить сеть и уменьшить размер. Наконец, мы сглаживаем слой, чтобы мы могли построить линейный слой для сопоставления значений с 10 значениями. Вероятность каждого нейрона из этих 10 нейронов будет определять, к какому классу принадлежит конкретное изображение, на основе максимальной вероятности.

Тренируй модель

@ torch.no_grad () def Assessment (model, data_loader): model.eval () output = [model.validation_step (batch) for batch in data_loader] return model.validation_epoch_end (output) def fit (model, train_loader, val_loader, epochs) = 10, скорость обучения = 0.001): best_valid = Нет history = [] optimizer = torch.optim.Adam (model.parameters (), learning_rate, weight_decay = 0.0005) для эпохи в диапазоне (эпохи): # Фаза обучения model.train ( ) train_losses = [] train_accuracy = [] для партии в tqdm (train_loader): loss, exc = model.training_step (batch) train_losses.append (loss) train_accuracy.append (accu) loss.backward () optimizer.step () optimizer .zero_grad () # Результат фазы проверки = оценка (модель, val_loader) результат ['train_loss'] = torch.stack (train_losses) .mean (). item () result ['train_accuracy'] = torch.stack (train_accuracy). mean (). item () model.epoch_end (эпоха, результат) if (best_valid == None или best_valid

history = fit (модель, train_dl, val_dl)

Это основной шаг для обучения нашей модели для получения требуемого результата. функция подгонки подгонит данные поезда и Val к созданной нами модели. Функция соответствия изначально принимает список, называемый историей, который заботится об итерационных данных каждой эпохи. Мы запускаем цикл for, чтобы можно было перебирать каждую эпоху. Для каждой партии мы убеждаемся, что показываем прогресс с помощью tqdm. Мы называем шаг обучения, который мы реализовали ранее, и вычисляем точность и потери. Оптимизатор обратного распространения и запуска, который мы определили ранее. Как только мы это сделаем, мы будем отслеживать наш список, и функции помогают нам распечатать детали и прогресс.

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

Построение результатов

На этом этапе мы визуализируем точность для каждой эпохи. Мы можем наблюдать, что с увеличением эпохи точность системы продолжает расти, и аналогично потери продолжают уменьшаться. Красная линия здесь указывает на прогресс данных обучения, а синяя - на проверку. Мы можем видеть, что в наших результатах было много переобучения, поскольку обучающие данные значительно превосходят результат проверки, а также в случае потери. После 10 эпох данные поезда, кажется, обходят 90% точности, но имеют потерю около 0.5. Тестовые данные составляют около 81%, а потери - около 0.2.

def plot_accuracies (history): Validation_accuracies = [x ['Accuracy'] для x в истории] Training_Accuracies = [x ['train_accuracy'] для x в истории] plt.plot (Training_Accuracies, '-rx') plt.plot (Validation_accuracies , '-bx') plt.xlabel ('эпоха') plt.ylabel ('точность') plt.legend (['Обучение', 'Проверка']) plt.title ('Точность по сравнению с количеством эпох') ; plot_accuracies (история)

def plot_losses (history): train_losses = [x.get ('train_loss') для x в истории] val_losses = [x ['Loss'] для x в истории] plt.plot (train_losses, '-bx') plt.plot (val_losses, '-rx') plt.xlabel ('epoch') plt.ylabel ('loss') plt.legend (['Training', 'Validation']) plt.title ('Loss vs. No. of epochs '); plot_losses (история)

test_dataset = ImageFolder (data_dir + '/ test', transform = ToTensor ()) test_loader = DeviceDataLoader (DataLoader (test_dataset, batch_size), устройство) результат = оценить (final_model, test_loader) print (f'Test Accuracy: {result ["Accuracy" ] * 100: .2f}% ')

Точность теста: 81.07%

Мы видим, что в итоге получаем точность 81.07%.

Вывод:

Фото товара: https: //unsplash.com/photos/5L0R8ZqPZHk

Обо мне: Я студент-исследователь, интересующийся областью глубокого обучения и обработки естественного языка, и в настоящее время учусь в аспирантуре по искусственному интеллекту.

Image Source

Image 1: https://becominghuman.ai/cifar-10-image-classification-fd2ace47c5e8
Изображение 2: https://www.analyticsvidhya.com/blog/2021/05/convolutional-neural-networks-cnn/

Не стесняйтесь связаться со мной по: