Reconnaissance des chats à l'aide de l'apprentissage en profondeur

0 Préface

Petit devoir d'intelligence artificielle, utilisant l'apprentissage en profondeur pour identifier les chats sur les photos, l'exigence est d'utiliser uniquement un réseau de neurones à une seule couche.

1. Principe

1.1 Principe

Le principe de cette expérience consiste principalement à saisir une image, puis à aplatir l'image, à la placer dans un réseau de neurones entièrement connecté à une seule couche pour la formation et à la sortir après la formation.

1.2 Modèle linéaire

Le modèle linéaire est le type de modèle le plus courant. Dans la plupart des tâches, les modèles linéaires sont les plus efficaces.

En utilisant l'expression d'erreur la plus courante du modèle linéaire, nous devons constamment ajuster w pour réduire la perte de perte en jugeant si l'erreur est inférieure à notre seuil.

1.3 Descente en gradient

1.4 Fonction d'activation

La fonction d'activation utilisée dans cette expérience est la fonction sigmoïde. La fonction principale de la fonction d'activation est de fournir la capacité de modélisation non linéaire du réseau. S'il n'y a pas de fonction d'activation, le réseau ne peut exprimer qu'une carte linéaire.A ce moment, même s'il y a plus de couches cachées, l'ensemble du réseau équivaut à un réseau de neurones à une seule couche. Par conséquent, on peut considérer que seulement après l'ajout de la fonction d'activation, le réseau neuronal profond a la capacité d'apprendre la cartographie non linéaire hiérarchique. Vous trouverez ci-dessous la formule de la fonction d'activation.

1.2 Environnement d'exploitation

Le code utilise pytorch pour les expériences, et la version python est 3.7

python	3.7
cuda

1.3 Jeu de données

2.Code

import json
import os
import sys

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import transforms, datasets
from tqdm import tqdm
# device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# print("using {} device.".format(device))

data_transform = {
    
    
    "train": transforms.Compose([transforms.RandomResizedCrop(224),
                                     transforms.RandomHorizontalFlip(),
                                     transforms.ToTensor(),
                                     transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]),

    "val": transforms.Compose([transforms.Resize(256),
                                   transforms.CenterCrop(224),
                                   transforms.ToTensor(),
                                   transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])}

data_root = os.path.abspath(os.path.join(os.getcwd(), "./"))  # get data root path
image_path = os.path.join(data_root, "data", "cats_and_dogs_v2")  # flower data set path
#assert 在表达式条件为 False 的时候触发异常。 断言可以在条件不满足程序运行的情况下直接返回错误，而不必等待程序运行后出现崩溃的情况。
assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),
                                         transform=data_transform["train"])
train_num = len((train_dataset))
print(train_num)

train_loader = torch.utils.data.DataLoader(train_dataset,batch_size=1, shuffle=True,num_workers=0)



class Model(torch.nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.lin1 = torch.nn.Linear(150528, 800)
        self.lin2 = torch.nn.Linear(800, 400)
        self.lin3 = torch.nn.Linear(400, 2)
        self.sigmoid = torch.nn.Sigmoid()
    def forward(self, x):
        x = self.sigmoid(self.lin1(x))
        x = self.sigmoid(self.lin2(x))
        x = self.sigmoid(self.lin3(x))
        return x


model = Model()
model = model.cuda()

criterion = torch.nn.CrossEntropyLoss() #这是损失函数吗？
criterion = criterion.cuda()
#SGD是随机梯度下降（stochastic gradient descent）的首字母
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)


for epoch in range(100):
    correct = 0
    for i, data in enumerate(train_loader, 0):  # train_loader 是先shuffle后mini_batch
        inputs, labels = data #input是输入tensor，label是标签
        inputs = inputs.cuda()
        labels = labels.cuda()
        inputs = torch.reshape(inputs,[1,150528])
        y_pred = model(inputs)
        if(torch.argmax(y_pred) == labels):
            correct += 1
        loss = criterion(y_pred, labels)

        optimizer.zero_grad() # 清除网络状态
        loss.backward() # loss反向传播
        optimizer.step() # 更新参数
    print('第', epoch, '轮的准确度是:%d %%' % (100 * correct / train_num))