搭建一个简单的神经网络

# 1 算法库准备
import torch
import torch.nn as nn # 模型
import torch.optim as optim # 优化器
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms

# 2 定义简单网络
class SimpleNN(nn.Module):
    def __init__(self):
        super.__init__()
        # 常见神经网络层
        # torch.nn.Linear 全连接层 即线性变换
        # torch.nn.Conv1/2/3d 卷积层
        # torch.nn.MaxPool2d, torch.nn.AvgPool2d 池化层，降低每一层特征图的维度
        # torch.nn.RNN,LSTM,GRU 循环层
        # torch.nn.Transformer 自注意层
        # 此处相对于搭建了个MLP
        self.fc1 = nn.Linear(28*28, 128) # 第一个全连接层,输入为28*28=784维度的图像，输出的特征层的为128维
        self.fc2 = nn.Linear(128, 10) # 接在第一个fc层后的第二层全连接层，输入128维，输出10维（可以看做是10个类别）
    
    def forward(self, x):
        x = view(-1, 28*28) # 将输入的数据x，变成(n,28*28)的形状，这样相对于有n张大小为28*28的图像被展开成28*28的向量，便于批量输入图像进行推理
        x = torch.relu(self.fc1(x)) # 全连接层后要接激活函数
        x = self.fc2(x)
        return x

# 3 实例化神经网络
model = SimpleNN()
# model = SimpleNN().to(device) # 指定cpu还是cuda运行

# 3.1 查看模型的结构
for name, param in model.named_parameters():
	print(f"Parameter: {name}, Shape: {param.shape}")
# 打印模型
from torchinfo import summary
summary(model)

# 4 定义loss及优化器
# 常见loss 交叉熵--用于分类任务；MSE--用于回归任务
loss_fn = nn.CrossEntropyLoss()
# 常见优化器 
# optim.SGD
# optim.Adam
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 5 准备数据
#############################################################
# 5.1 此处以定义的随机变量作为输入
inputs = torch.randn(32, 28, 28) 
labels = torch.randint(0, 10, (32,))

# 前向传播
outputs = model(inputs)

# 计算loss
loss = loss_fn(outputs, labels)

# 反向传播
optimizer.zero_grad()
loss.backward()
optimizer.step()

print(f'Loss: {loss.item()}')

#############################################################

# 5.2 变更数据位从dataloader读取
train_ds = torchvision.datasets.MNIST(
   root='./data',
   train=True,
   transform=torchvision.transforms.ToTensor(),
   download=True)
test_ds = torchvision.datasets.MNIST(
   root='./data',
   train=False,
   transform=torchvision.transforms.ToTensor(),
   download=True)
batch_size = 32
train_dl = torch.utils.data.Dataloader(train_ds,
    batch_size=batch_size,
    shuffle=True)
test_dl = torch.utils.data.Dataloader(test_ds,
    batch_size=batch_size)
# 查看图像数据
imgs, labels = next(iter(train_dl))
import numpy as np
plt.fugure(figsize=(10,10))
 
for i, imgs in enumerate(imgs[:50]):
	npimg = np.squeeze(imgs.numpy())
	print('img.shape: ', npimg.shape)
	plt.subplot(5,10,i+1)
	plt.imshow(npimg, cmap=plt.cm.binary)
	plt.axis('off')
plt.show()

# 6 训练模型
# 6.1 设置超参数
loss_fn = nn.CrossEntropyLoss()
learn_rate = 1e-2
optimizer = torch.optim.SGD(model.parameters(), lr=learn_rate)

# 6.2 编写训练函数
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dsataset)
    num_batches = len(dataloader)
    train_loss, train_acc = 0.0
	for X, y in dataloader:
		X, y = X.to(device), y.to(device)

		pred = model(X)
	    loss = loss_fn(pred, y)

	    optimizer.zero_grad()
	    loss.backward()
	    optimizer.step()

	    train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
	    train_loss += loss.item()

	  train_acc /= size
	  train_loss /= num_batches

	  return train_acc, train_loss

# 编写测试函数

引用

[1]: https://blog.csdn.net/u013172930/article/details/145706828