La forma más fácil --- entender la profundidad del proceso de aprendizaje y formación para desarrollar

importación antorcha
 importación torchvision
 importación matplotlib.pyplot como plt
 importación torch.nn como nn
 importación torch.nn.functional como F
 desde torch.utils.data importación DataLoader
 de torchvision.transforms importar transformadas de 
dispositivo = torch.device ( " cuda: 0 "  si torch.cuda.is_available () otra cosa  " CPU " ) 

# 定义ResBlock,见Resnet aprendizaje图
clase ResBlock (nn.Module):
     def  __init__(self, in_channel, out_channel, paso = 1, de acceso = Ninguno): 
        super (ResBlock, uno mismo). __init__ () 
        self.left = nn.Sequential ( 
            nn.Conv2d (in_channel, out_channel, 3, zancada, 1, el sesgo = Falso), 
            nn.BatchNorm2d (out_channel), 
            nn.ReLU (True), 
            nn.Conv2d (out_channel, out_channel, 3, 1, 1, el sesgo = Falso), 
            nn.BatchNorm2d (out_channel), 
        ) 
        self.right = atajo 

    def hacia adelante (self, x): 
        cabo = self.left (x) 
        residual = xsi self.right es Ninguno otro self.right (x) 
        fuera + = residual
         retorno F.relu (out) 

# 定义make_layer 
def make_layer (in_channel, out_channel, block_num, paso = 1 ): 
    acceso directo = nn.Sequential ( 
        nn.Conv2d (in_channel, out_channel, 1 , paso), 
        nn.BatchNorm2d (out_channel)) 
    capas = list () 
    layers.append (ResBlock (in_channel, out_channel, zancada, acceso directo)) 

    para i en rango (1 , block_num):
        layers.append (ResBlock (out_channel, out_channel)) 
    volver nn.Sequential (* capas) 

# 堆叠Resnet,见上表所示结构
clase Resnet (nn.Module):
     def  __init__ (auto): 
        super (Resnet, sí). __init__ () 
        self.pre = nn.Sequential ( 
            nn.Conv2d ( 3, 64, 7, 2, 3, el sesgo = Falso), 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, paso = 2 ) 
        self.layer3= Make_layer (128, 256, 2, paso = 2 ) 
        self.layer4 = make_layer (256, 512, 2, paso = 2 ) 
        self.avg = nn.AvgPool2d (7 ) 
        self.classifier = nn.Sequential (nn.Linear (512, 10 )) 

    def hacia adelante (self, x): 
        x = self.pre (x) 
        x = self.layer1 (x) 
        x = self.layer2 (x) 
        x = self.layer3 (x) 
        x = auto. layer4 (x) 
        x = self.avg (x) 
        x = x.view (x.size (0), -1 ) 
        a cabo= Self.classifier (X)
         volver OUT 

# función de formación de trenes 
DEF net_train (): 
    net.train () 
    running_loss = 0.0
     para datos I, en la enumeración (trainloader, 0):
         # de entrada pasan las GPU 
        entradas, etiquetas = Datos 
        entradas , etiquetas = inputs.to (dispositivo), labels.to (dispositivo) 

        # gradiente cero 
        optimizer.zero_grad () 

        # propagación hacia adelante - optimización - calcular un error - backpropagation 
        Salidas = NET (Inputs) 
        Pérdida =  Criterion ( productos, etiquetas)
        loss.backward () 
        optimizer.step () 

        # calcular un error y muestra 
        running_loss + = loss.item ()
         IF I 127% == 0:   # Imprimir Cada mini-lotes 
            de impresión (
                 ' [% D,% 5D] Pérdida:% .3f ' % (.. + Epoch 1, I + 1, running_loss / 128 )) 
            running_loss = 0,0 Print ( ' Formación Epoch final ' ) # prueba de función de prueba DEF net_test (): 
    correcta = 0 
    total = 0
     # Cerrar gradiente

    



    con torch.no_grad ():
         para los datos entestloader: 
            imágenes, etiquetas = datos 
            imágenes, etiquetas = images.to (dispositivo), labels.to (dispositivo) 
            salidas = netos (imágenes) 
            _, predicho = torch.max (outputs.data, 1 ) 
            total de + = labels.size (0) 
            correcta + = (predichos == etiquetas) .sum () artículo (). 

    print ( ' la exactitud de la red en las imágenes de prueba 10000:% d %% ' % 
          ( 100 * correcta / total))
    retorno 


# 数据集函数data_loader 
def net_dataloader (raíz, train_transform, test_transform): 
    trainset = torchvision.datasets.CIFAR10 ( 
        raíz, tren = True, transformar = train_transform, descargar = True) 
    testset = torchvision.datasets.CIFAR10 ( 
        raíz, tren = falso, transformar = test_transform, descargar = true) 
    trainloader = DataLoader ( 
        trainset, batch_size = 128, barajar = true, num_workers = 4 ) 
    testloader = DataLoader ( 
        testset, batch_size = 16, aleatoria = false, num_workers = 4 )
     de impresión ( ' la inicialización de un conjunto de datos ... ' )
     de retorno trainloader, testloader 


# principal 
SI  el __name__ == " __main__ " :
     # Crear instancia y alimentado a la GPU 
    NET = . Resnet () a (dispositivo)
     # Selección de error Pérdida 
    Criterio = NN. CrossEntropyLoss ()
     # selección optimizador 
    optimizador = torch.optim.Adam (net.parameters (), = 1E-LR. 3 )
     # posición de los datos 
    de la raíz = ' ./pydata/data/ ' 
    # procesamiento de datos Augmentation
    train_transform = net_dataloader (raíz, train_transform, transforms.Compose ([
        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 ([ 
        transformadas. Modificación de tamaño ( 224 ), 
        transforms.ToTensor (), 
        transforms.Normalize (( 0,5, 0,5, 0,5), (0,5, 0,5, 0,5 )) 
    ]) 
    # 创建数据loader 
    trainloader, testloader = 
                                             test_transform) 
    # plazo 
    n_epoch = 5   #Cambio de época 
    para la época en la Cordillera (n_epoch):
         Imprimir ( ' Formación ... ' ) 
        net_train ()   # cada época entrenado una vez, una vez que la prueba 
        de impresión ( ' Probando ... ' ) 
        net_test ()