1. Tareas de clasificación

Construir un modelo de red de clasificación

Debe heredar nn.Module y llamar al constructor de nn.Module en su constructor.
No es necesario escribir la función de retropropagación, nn.Module puede usar autograd para implementar automáticamente la retropropagación
Los parámetros que se pueden aprender en el módulo pueden devolver un iterador a través de name_parameters()

from torch import nn
import torch.nn.functional as F

# 构建自己的网络
class Mnist_NN(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden1 = nn.Linear(784,128)
        self.hidden2 = nn.Linear(128,256)
        self.out = nn.Linear(25,10)

    # 前向传播
    def forward(self,x):
        x = F.relu(self.hidden1(x))
        x = F.relu(self.hidden2(x))
        x = self.out(x)
        return x

net = Mnist_NN()
print(net)

# 打印定义好的名字里的权重和偏置项
for name,parameter in net.named_parameters():
    print(name,parameter,parameter.size())

Dos, conjunto de datos y cargador de datos

from torch.utils.data import TensorDataset
from torch.utils.data import DataLoader
from torch import optim

train_ds = TensorDataset(x_train,y_train)
train_dl = DataLoader(train_ds,batch_size=bs,shuffle=True)

valid_ds = TensorDataset(x_valid,y_valid)
valid_dl = DataLoader(valid_ds,batch_size=bs * 2)

def get_data(train_ds,valid_ds):
    return (
        DataLoader(train_ds,batch_size=bs,shuffle=True),
        DataLoader(valid_ds,batch_size=bs * 2),
    )

def get_model():
    model = Mnist_NN()
    return model,optim.SGD(model.parameters(),lr = 0.01)
train_dl,valid_dl = get_data(train_ds,valid_ds)
model,opt = get_model()

3. Red neuronal convolucional

3.1 Aplicaciones de redes convolucionales

tarea de detección
Clasificación y Búsqueda
reconstrucción de súper resolución
sin personal
Reconocimiento facial

3.2 La diferencia entre red convolucional y red tradicional

Izquierda: red neuronal tradicional

Derecha: red neuronal convolucional

Estructura general:

Capa de entrada: entrada de datos

Capa convolucional: extracción de características

Capa de agrupación: características de compresión

Capa completamente conectada: conecte la capa de entrada a la capa oculta a través de un conjunto de parámetros de peso

El valor obtenido después de la convolución debe agregarse con sesgo de valor

La capa convolucional implica parámetros:

Paso de ventana deslizante: el número de cuadrículas que la ventana mueve y salta
Tamaño del núcleo de convolución: Ejemplo 3*3
Acolchado de bordes:
Número de núcleos de convolución:

3.3 Capa de agrupación:

Agrupación máxima:

3.4 Construcción de red convolucional

La capa de convolución general, la capa relu y la capa de agrupación se pueden escribir como un paquete
Tenga en cuenta que la estructura final de la convolución sigue siendo un mapa de características, que debe convertirse en un vector para realizar tareas de clasificación o regresión.

El código del caso es el siguiente:

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Sequential(
            nn.Conv2d(
                in_channels=1, #灰度图
                out_channels=16, #要得到多少个特征图
                kernel_size=5, #卷积核大小
                stride=1, #步长
                padding=2,
            ),
            nn.ReLU(), #relu层
            nn.MaxPool2d(kernel_size=2),  #进行池化操作
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(16,32,5,1,2), #输出(32,14,14)
            nn.ReLU(),
            nn.MaxPool2d(2),
        )
        self.out = nn.Linear(32 * 7 * 7 * 10)  #全连接层得到的结果

    def forward(self,x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0),-1)
        output = self.out(x)
        return output

Pytorch (2)