Глубокое обучение, Программирование

Посмотрим, как видит компьютер…

У людей есть несколько этапов понимания визуальной информации, и компьютер также следует за этим процессом.

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

  • Эй, это новая пиццерия.
  • Эй, посмотри на эту собаку.
  • Эта новая машина выглядит потрясающе.

И этот замечательный список продолжается …….

Что ж, теперь у меня к вам вопрос. Вы когда-нибудь задумывались, как вы можете классифицировать вещи?

Это ваша система виртуальной коры к вашим услугам, и эта система отвечает за обработку визуальной информации.

Если вы помните, мы говорили об этапах. Итак, первая стадия, на которую попадает изображение, называется V1.

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

Теперь давайте посмотрим, как изображения классифицируются компьютером. Это концепция Сверточные нейронные сети (CNN), и мы собираемся изучить эту концепцию в этой статье.

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

Здесь изображения являются нашими входными данными, а изображения могут быть,

  • Изображения в оттенках серого
  • Цветные изображения (эти изображения представляют собой комбинацию трех каналов (красного, зеленого и синего))

Теперь вам должно быть интересно, что такое свертка в CNN?

Свертка в CNN - это операция, при которой изображения и веса проходят через скалярное произведение.

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

Вес

Эти веса также называются фильтрами. Они также представлены в виде матрицы.

Давайте рассмотрим сценарий, чтобы понять фильтры. Мы все интересуемся спортом, правда? Итак, в каждом виде спорта есть разные позиции. Например, в крикете есть игроки с битой и мячом. Эти 2 специализируются в своей области. То же самое и с фильтрами, и есть много разных фильтров, которые специализируются в своей области.

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

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

Как и в кулинарном шоу, участники сначала готовят блюда в соответствии с их пониманием, а затем меняют или корректируют в соответствии с требованиями.

В этом блоге мы будем использовать набор данных CIFAR10. В нем есть классы: «самолет», «автомобиль», «птица», «кошка», «олень», «собака», «лягушка», «лошадь», «корабль», «грузовик». Изображения в CIFAR-10 имеют размер 3x32x32, т. Е. Трехканальные цветные изображения размером 32x32 пикселя.

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

Приступим

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

После создания учетной записи вам нужно будет ее установить. Я использую записные книжки Google Colab для этого набора данных.

# Installing the package
!pip install wandb -q
# importing the library
import wandb
# login
wandb.login()

Набор данных доступен в torchvision.datasets PyTorch.

давайте импортируем библиотеки

import torch
import torchvision
from torchvision.transforms as transforms

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

transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
trainset = torchvision.datasets.CIFAR10(root = './data', train = True, download = True, transform=transform)
testset = torchvision.datasets.CIFAR10(root = './data', train = False, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle = True, num_workers=2)
testloader = torch.utils.data.DataLoader(testset, batch_size=4, shuffle=False, num_workers=2)
classes = ('plane', 'car', 'bird', 'cat','deer', 'dog', 'frog', 'horse', 'ship', 'truck')

Давайте разбираться в коде,

1] transforms.Compose

transforms используется для преобразования изображений, мы можем использовать множество различных преобразований с помощью преобразований. Compose аналогичен sklearn.compose (с помощью Compose мы можем связать различные преобразования)

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

Мы использовали transforms.ToTensor () в качестве нашего первого преобразователя, он преобразует наши изображения в тензор. Тензорное изображение - это тензор с формой (C, H, W), где C - количество каналов, H и W - высота и ширина изображения.

Второй преобразователь, который мы использовали, - transforms.Normalize (). Мы передаем значения 0,5 и 0,5 в преобразование нормализации, чтобы преобразовать пиксели в значения от 0 до 1, что означает -распределение со средним значением. 0,5 и стандартное отклонение 0,5.

2] Наборы данных

Теперь мы загрузили наш набор данных из torchvision.Datasets и разделили их на два набора - Trainset и Testset.

Теперь мы использовали torch.utils.data.Dataloader, этот загрузчик данных берет данные из созданных нами наборов и обслуживает их партиями.

Сеть

Теперь давайте определим нашу сеть,

import torch.nn as nn
import torch.nn.functional as Fclass Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2) 
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)
    
    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x
net = Net()

Здесь я использую два сверточных слоя и три линейных слоя.

Первый слой свертки принимает 3 параметра: 1] in_channels 2] out_channels 3] kernel_size

1] in_channels = Количество каналов во входном изображении, если изображения в оттенках серого, тогда in_channels = 1, а когда входные данные окрашены, то оно равно 3, потому что цветные изображения имеют три канала, т. Е. (Красный, зеленый , и синий)

2] out_channels = Количество каналов, созданных операцией свертки

3] kernel_size = Это размер матрицы, которая будет свернута.

Вторые сверточные слои имеют такие же параметры.

Мы применили Max pooling к нашему свернутому изображению. nn.MaxPool2d берет максимальное значение из матрицы.

Теперь мы использовали три линейных слоя после применения вторых сверточных слоев.

nn.Linear = Применяет линейное преобразование к нашим входным и выходным выборкам.
Это полностью связанный слой, который имеет вход и выход. Теперь к входу будет применен вес; его вывод будет [XW + b], поскольку он полностью линейный, без функции активации.

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

Отличная статья о суперфункции, которую я использовал здесь https://realpython.com/python-super/.

Теперь мы определяем нашу функцию потерь и оптимизатор,

import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters())

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

Обучение сети

Перед обучением мы должны запустить wandb.init (). Это инициализирует запущенный процесс.

Он принимает множество параметров, но мы будем использовать здесь самый важный, а именно: «Entity» = ваше имя пользователя, «Project» = имя вашего проекта.

wandb.init(entity = 'pratik_raut', project = 'Image Classification with Pytorch 2')
epochs = 40
# reference - https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html
for epoch in range(1, epochs+1):  # loop over the dataset multiple times
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):    # get the inputs; data is a list of [inputs, labels]
        inputs, labels = data    # zero the parameter gradients
        optimizer.zero_grad()    # forward + backward + optimize
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()    # print statistics
        running_loss += loss.item()
        if i % 2000 == 1999:    # print every 2000 mini-batches
            print('[%d, %5d] loss: %.3f' % 
                 (epoch + 1, i + 1, running_loss /2000))
        running_loss = 0.0    # Log the loss and accuracy values at the end of each epoch
    wandb.log({"Epoch": epoch, "Train Loss":running_loss})
print('Finished Training')

Вот график, созданный для учетной записи wandb, это простой взгляд на то, насколько полезен wandb для отслеживания производительности вашей модели.

Давайте попробуем предугадать по некоторым изображениям,

dataiter = iter(testloader)
images, labels = dataiter.next()
# print images
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))

Код доступен на Google Colab. Вот и все, я надеюсь, вам понравится и вы узнаете. Это простая сеть, надеюсь, вы добавите в нее еще кое-что, спасибо.

Заявление об ограничении ответственности - изображения без ссылок в подписи принадлежат автору; в противном случае предоставляется ссылка.