Le plus facile --- comprendre la profondeur de processus d'apprentissage et la formation pour renforcer

import torche
 import torchvision
 import matplotlib.pyplot comme plt
 import torch.nn comme nn
 import torch.nn.functional comme F
 de torch.utils.data import DataLoader
 de torchvision.transforms importer transforme 
dispositif = torch.device ( " cuda: 0 "  si torch.cuda.is_available () autre  " cpu " ) 

# 定义ResBlock,见Resnet apprentissage图
classe ResBlock (nn.Module):
     def  __init__(auto, in_channel, out_channel, foulée = 1, raccourci = Aucun): 
        super (ResBlock, auto). __init__ () 
        self.left = nn.Sequential ( 
            nn.Conv2d (in_channel, out_channel, 3, foulée, 1, biais = False), 
            nn.BatchNorm2d (out_channel), 
            nn.ReLU (vrai), 
            nn.Conv2d (out_channel, out_channel, 3, 1, 1, polarisation = Faux), 
            nn.BatchNorm2d (out_channel) 
        ) 
        self.right = raccourci 

    def vers l' avant (self, x): 
        out = self.left (x) 
        résiduel = xsi self.right est Aucun autre self.right (x) 
        sur + = résiduel
         retour F.relu (out) 

# 定义make_layer 
def make_layer (in_channel, out_channel, block_num, foulée = 1 ): 
    raccourci = nn.Sequential ( 
        nn.Conv2d (in_channel, out_channel, 1 , foulée), 
        nn.BatchNorm2d (out_channel)) 
    couches = list () 
    layers.append (ResBlock (in_channel, out_channel, foulée, raccourci)) 

    pour i en série (1 , block_num):
        layers.append (ResBlock (out_channel, out_channel)) 
    retour nn.Sequential (* couches) 

# 堆叠Resnet,见上表所示结构
classe Resnet (nn.Module):
     def  __init__ (self): 
        super (Resnet, auto). __init__ () 
        self.pre = nn.Sequential ( 
            nn.Conv2d ( 3, 64, 7, 2, 3, polarisation = Faux), nn.BatchNorm2d (64 ), 
            nn.ReLU (True), nn.MaxPool2d ( 3, 2, 1 )) 
        self.layer1 = make_layer (64, 64, 2 ) 
        self.layer2 = make_layer (64, 128, 2, foulée = 2 ) 
        self.layer3= Make_layer (128, 256, 2, stride = 2 ) 
        self.layer4 = make_layer (256, 512, 2, stride = 2 ) 
        self.avg = nn.AvgPool2d (7 ) 
        self.classifier = nn.Sequential (nn.Linear (512, 10 )) 

    def avant (self, x): 
        x = self.pre (x) 
        x = self.layer1 (x) 
        x = self.layer2 (x) 
        x = self.layer3 (x) 
        x = soi. layer4 (x) 
        x = self.avg (x) 
        x = x.view (x.size (0), -1  )
        out= Self.classifier (X)
         retour OUT 

# fonction de formation de train 
DEF net_train (): 
    net.train () 
    running_loss = 0,0
     pour I, données dans la enumerate (trainloader, 0):
         # entrée passer le GPU 
        Entrées, étiquettes = données 
        entrées , étiquettes = inputs.to (Device), labels.to (Device) 

        # gradient zéro 
        optimizer.zero_grad () 

        # de propagation vers l' avant - optimisation - calculer une erreur - rétropropagation 
        sorties = NET (entrées) 
        Perte =  Criterion ( sorties, étiquettes)
        loss.backward () 
        optimizer.step () 

        # calculer une erreur et affiche 
        running_loss + = loss.item ()
         IF I 127% == 0:   # Imprimer Chaque mini-batchs 
            Imprimer (
                 ' [% D,% 5D] Perte:% .3f ' % (.. + Epoch 1, I + 1, running_loss / 128 )) 
            running_loss = 0.0 Imprimer ( ' Training Epoch Terminé ' ) # test de fonctionnement de test DEF net_test (): 
    correct = 0 
    total = 0
     # gradient Fermer

    



    avec torch.no_grad ():
         pour les données danstestloader: 
            images, étiquettes = données 
            images, les étiquettes = images.to (périphérique), labels.to (device) 
            sorties = net (images) 
            _, prédit = torch.max (outputs.data, 1 ) 
            totale + = labels.size (0) 
            correct + = (prédites == étiquettes) .sum () item (). 

    print ( ' Précision du réseau sur les 10000 images de test:% d %% ' % 
          ( 100 * correct / totale))
     retour 


# 数据集函数data_loader 
defnet_dataloader (racine, train_transform, test_transform): 
    trainset = torchvision.datasets.CIFAR10 ( 
        racine, train = True, transform = train_transform, download = True) 
    Testset = torchvision.datasets.CIFAR10 ( 
        racine, train = False, transform = test_transform, télécharger = True) 
    trainloader = DataLoader ( 
        trainset, batch_size = 128, lecture aléatoire = True, num_workers = 4 ) 
    testloader = DataLoader ( 
        Testset, batch_size = 16, lecture aléatoire = faux, num_workers = 4 )
     print ( '... un Dataset Initializing ' )
     retour trainloader, testloader 


# principale 
SI  le __name__ == " __main__ " :
     # Créer instance et envoyé au GPU 
    NET = . Resnet () à (Device)
     # Erreur de sélection Perte 
    Critère = nn.CrossEntropyLoss ()
     # sélection optimiseur 
    optimiseur = torch.optim.Adam (net.parameters () = 1E-LR. 3 )
     # position de données 
    la racine = ' ./pydata/data/ ' 
    # traitement de données d' augmentation transforms.Compose ([
    train_transform = net_dataloader (racine, train_transform,
        transforms.RandomResizedCrop ( 224 ), 
        transforms.RandomHorizontalFlip (), 
        transforms.ToTensor (), 
        transforms.Normalize (( 0,5, 0,5, 0,5), (0,5, 0,5, 0,5 )) 
    ]) 
    test_transform = transforms.Compose ([ 
        transformées. redimensionnement ( 224 ), 
        transforms.ToTensor (), 
        transforms.Normalize (( 0,5, 0,5, 0,5), (0,5, 0,5, 0,5 )) 
    ]) 
    # 创建数据loader 
    trainloader, testloader = 
                                             test_transform) 
    # run 
    n_epoch = 5   #Changement de l' époque 
    pour l' époque dans la gamme (n_epoch):
         Imprimer ( ' Formation ... ' ) 
        net_train ()   # chaque époque une fois formé, test une fois 
        Imprimer ( ' test ... ' ) 
        net_test ()