自学教程：pytorch 搭建神经网路的实现

import torchfrom torchvision import datasetsfrom torchvision.transforms import ToTensorimport matplotlib.pyplot as pltimport osos.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE'	# 没有这句会报错，具体原因我也不知道training_data = datasets.FashionMNIST(    root="../data",    train=True,    download=True,    transform=ToTensor())test_data = datasets.FashionMNIST(    root="../data",    train=False,    download=True,    transform=ToTensor())

labels_map = {    0: "T-Shirt",    1: "Trouser",    2: "Pullover",    3: "Dress",    4: "Coat",    5: "Sandal",    6: "Shirt",    7: "Sneaker",    8: "Bag",    9: "Ankle Boot",}figure = plt.figure(figsize=(8, 8))cols, rows = 3, 3for i in range(1, cols * rows + 1):    # 从0-len(training_data)中随机生成一个数字（不包括右边界）    sample_idx = torch.randint(len(training_data), size=(1,)).item()     img, label = training_data[sample_idx] # 获得图片和标签    figure.add_subplot(rows, cols, i)    plt.title(labels_map[label])    plt.axis("off")                        # 坐标轴不可见    plt.imshow(img.squeeze(), cmap="gray") # 显示灰度图plt.show()

import osimport pandas as pdfrom torch.utils.data import Datasetfrom torchvision.io import read_imageclass CustomImageDataset(Dataset):    def __init__(self, annotations_file, img_dir, transform=None, target_transform=None):        self.img_labels = pd.read_csv(annotations_file)        self.img_dir = img_dir        self.transform = transform        self.target_transform = target_transform    def __len__(self):        return len(self.img_labels)    def __getitem__(self, idx):        img_path = os.path.join(self.img_dir, self.img_labels.iloc[idx, 0])        image = read_image(img_path)        label = self.img_labels.iloc[idx, 1]        if self.transform:            image = self.transform(image)        if self.target_transform:            label = self.target_transform(label)        return image, label

from torch.utils.data import DataLoadertrain_dataloader = DataLoader(training_data, batch_size=64, shuffle=True) # train_dataloader是一个DataLoader类的对象test_dataloader = DataLoader(test_data, batch_size=64, shuffle=True)

for batch_index, (features, label) in enumerate(train_dataloader):    print(batch_index)    print(f"Feature batch shape: {features.size()}")    print(f"Labels batch shape: {label.size()}")    img = features[0].squeeze()    label = label[0]    plt.imshow(img, cmap="gray")    plt.show()    print(f"Label: {label}")    break

for batch_index, (features, label) in enumerate(train_dataloader):    print(batch_index)    print(f"Feature batch shape: {features.size()}")    print(f"Labels batch shape: {label.size()}")    img = features[0].squeeze()    label = label[0]    plt.imshow(img, cmap="gray")    plt.show()    print(f"Label: {label}")    break

import torchfrom torchvision import datasetsfrom torchvision.transforms import ToTensor, Lambdads = datasets.FashionMNIST(    root="data",    train=True,    download=True,    transform=ToTensor(),    target_transform=Lambda(lambda y: torch.zeros(10, dtype=torch.float).scatter_(dim=0, index=torch.tensor(y), value=1)))

class NeuralNetwork(nn.Module):    def __init__(self):        super(NeuralNetwork, self).__init__()        self.flatten = nn.Flatten()				# 打平        self.linear_relu_stack = nn.Sequential(            nn.Linear(28*28, 512),		# 线性层            nn.ReLU(),					# 激活层            nn.Linear(512, 512),            nn.ReLU(),            nn.Linear(512, 10),            nn.ReLU()        )    def forward(self, x):        x = self.flatten(x)					# 打平层        logits = self.linear_relu_stack(x)	# 线性激活层        return logits

model = NeuralNetwork()print(model)

X = torch.rand(1, 28, 28)	# 生成一个样本logits = model(X)							# 将样本输入到模型中，自动调用forward方法print(logits.size())						pred_probab = nn.Softmax(dim=1)(logits)		# 实例化一个Softmax对象，并通过对象调用y_pred = pred_probab.argmax(1)				# 获得概率最大索引print(f"Predicted class: {y_pred}")

input_image = torch.rand(3,28,28)print(input_image.size())

layer1 = nn.Linear(in_features=28*28, out_features=20)hidden1 = layer1(flat_image)print(hidden1.size())

w = torch.rand(784, 20)b = torch.rand((1, 20))hidden2 = flat_image @ w + bprint(hidden2.size())

seq_modules = nn.Sequential(    flatten,		# 在nn.Sequential中可以调用其他模块    layer1,    nn.ReLU(),    nn.Linear(20, 10))input_image = torch.rand(3,28,28)logits = seq_modules(input_image)

para_list = list(model.parameters())# 将参数生成器转换成列表之后，列表的第一个元素是w，第二个元素是bprint(type(para_list[0]))print(f'number of linear_layers :{len(para_list)/2}')print('weights:')print(para_list[0][:2])  # 只切出两个样本来显示print('bias:')print(para_list[1][:2]) print('/nthe shape of first linear layer:', para_list[0].shape)

print("Model structure: ", model, "/n/n")for name, param in model.named_parameters():    print(f"Layer: {name} | Size: {param.size()} | Values : /n{param[:2]} /n")    # 只切出前两行显示

learning_rate = 1e-3batch_size = 64epochs = 5

# Initialize the loss functionloss_fn = nn.CrossEntropyLoss()

optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

def train_loop(dataloader, model, loss_fn, optimizer):    size = len(dataloader.dataset)    for batch, (X, y) in enumerate(dataloader):        # Compute prediction and loss，下面两步相当于绘制计算图        pred = model(X)        loss = loss_fn(pred, y)        # Backpropagation        optimizer.zero_grad()	# 梯度信息清零        loss.backward()			# 反向传播        optimizer.step()		# 一旦有了梯度，就可以更新参数        if batch % 100 == 0:            loss, current = loss.item(), batch * len(X)            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")def test_loop(dataloader, model, loss_fn):    size = len(dataloader.dataset)    num_batches = len(dataloader)    test_loss, correct = 0, 0    with torch.no_grad():		# 禁用梯度跟踪，后面会讲        for X, y in dataloader:            pred = model(X)            test_loss += loss_fn(pred, y).item()            correct += (pred.argmax(1) == y).type(torch.float).sum().item()    test_loss /= num_batches    correct /= size    print(f"Test Error: /n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} /n")

for t in range(epochs):    print(f"Epoch {t+1}/n-------------------------------")    train_loop(train_dataloader, model, loss_fn, optimizer)    test_loop(test_dataloader, model, loss_fn)print("Done!")

test_features, test_labels = next(iter(test_dataloader))logits = model(test_features[0])pred_probab = nn.Softmax(dim=1)(logits)pred = pred_probab.argmax(1)img = test_features[0].squeeze()    # 将长度为1的维度去掉true_label = test_labels[0]plt.imshow(img, cmap="gray")plt.show()print(f"True label: {true_label}")print(f"Predict: {pred.item()}")

z = torch.matmul(x, w)+bprint(z.requires_grad)with torch.no_grad():    z = torch.matmul(x, w)+b	print(z.requires_grad)

# 保存模型参数torch.save(model.state_dict(), './model_weights.pth')# 保存模型结构torch.save(model, './model.pth')

# 导入模型结构model_loaded = torch.load('./model.pth') # 如果原来的model在cuda:0上，那么导入之后，model_loaded也在cuda:0上# 导入模型参数model_loaded.load_state_dict(torch.load('model_weights.pth'))

# 实例化一个NeuralNetwork对象model_loaded = NeuralNetwork() # model_loaded默认是CPU中# 导入模型参数model_loaded.load_state_dict(torch.load('./gdrive/MyDrive/model_weights.pth'))

test_features, test_labels = next(iter(test_dataloader))logits = model_loaded(test_features[0])   # 使用导入的模型pred_probab = nn.Softmax(dim=1)(logits)pred = pred_probab.argmax(1)img = test_features[0].squeeze()    # 将长度为1的维度去掉true_label = test_labels[0]plt.imshow(img, cmap="gray")plt.show()print(f"True label: {true_label}")print(f"Predict: {pred.item()}")

# We can move our tensor to the GPU if availabledevice = 'cuda' if torch.cuda.is_available() else 'cpu'print('Using {} device'.format(device))

model = NeuralNetwork().to(device)

X = torch.rand(1, 28, 28, device=device)	# 创建时指定设备Y = torch.rand(10).to(device)				# 创建后转移

device = torch.device(‘cuda:2')# 2是设备号，假如有八张显卡，那么编号就是0—7

# coding=utf-8import torchimport torch.nn as nnfrom torchvision import datasetsfrom torch.utils.data import DataLoaderfrom torchvision.transforms import ToTensorimport matplotlib.pyplot as pltimport osos.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE'	# 没有这句会报错，具体原因我也不知道# 导入数据training_data = datasets.FashionMNIST(    root="../data",    train=True,    download=True,    transform=ToTensor())test_data = datasets.FashionMNIST(    root="../data",    train=False,    download=True,    transform=ToTensor())# 定义超参数# 之所以在这个地方定义，是因为在初始化DataLoader时需要用到batch_sizelearning_rate = 1e-3batch_size = 64epochs = 5train_dataloader = DataLoader(training_data, batch_size=batch_size, shuffle=True)# train_dataloader是一个DataLoader类的对象test_dataloader = DataLoader(test_data, batch_size=batch_size, shuffle=True)# 搭建神经网络class NeuralNetwork(nn.Module):    def __init__(self):        super(NeuralNetwork, self).__init__()        self.flatten = nn.Flatten()				# 打平        self.linear_relu_stack = nn.Sequential(            nn.Linear(28*28, 512),		# 线性层            nn.ReLU(),					# 激活层            nn.Linear(512, 512),            nn.ReLU(),            nn.Linear(512, 10),            nn.ReLU()        )    def forward(self, x):        x = self.flatten(x)					# 打平层        logits = self.linear_relu_stack(x)	# 线性激活层        return logits# 确定使用设备device = 'cuda' if torch.cuda.is_available() else 'cpu'# 实例化一个神经网络类model = NeuralNetwork().to(device)# 确定损失函数loss_fn = nn.CrossEntropyLoss()# 确定优化器optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)# 封装训练过程def train_loop(dataloader, model, loss_fn, optimizer):    size = len(dataloader.dataset)    for batch, (X, y) in enumerate(dataloader):        X, y = X.to(device), y.to(device) # 将样本和标签转移到device中        # Compute prediction and loss，下面两步相当于绘制计算图        pred = model(X)        loss = loss_fn(pred, y)        # Backpropagation        optimizer.zero_grad()	# 梯度信息清零        loss.backward()			# 反向传播        optimizer.step()		# 一旦有了梯度，就可以更新参数        if batch % 100 == 0:            loss, current = loss.item(), batch * len(X)            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")            # 封装测试过程def test_loop(dataloader, model, loss_fn):    size = len(dataloader.dataset)    num_batches = len(dataloader)    test_loss, correct = 0, 0    with torch.no_grad():        for X, y in dataloader:            X, y = X.to(device), y.to(device)  # 将样本和标签转移到device中            pred = model(X)            test_loss += loss_fn(pred, y).item()            correct += (pred.argmax(1) == y).type(torch.float).sum().item()    test_loss /= num_batches    correct /= size    print(f"Test Error: /n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} /n")# 训练for t in range(epochs):    print(f"Epoch {t+1}/n-------------------------------")    train_loop(train_dataloader, model, loss_fn, optimizer)    test_loop(test_dataloader, model, loss_fn)print("Done!")# 保存模型参数torch.save(model.state_dict(), './model_weights.pth')# 保存模型结构torch.save(model, './model.pth')# 导入模型结构model_loaded = torch.load('./model.pth')    # 模型自动导入到GPU当中# 导入模型参数model_loaded.load_state_dict(torch.load('model_weights.pth'))# 用导入的模型测试test_features, test_labels = next(iter(test_dataloader))test_features = test_features.to(device)logits = model_loaded(test_features[0])   # 使用导入的模型pred_probab = nn.Softmax(dim=1)(logits)pred = pred_probab.argmax(1)# 可视化img = test_features[0].squeeze()    # 将长度为1的维度去掉img = img.to('cpu')              # 绘图时，需要将张量转回到CPU当中true_label = test_labels[0]   # 标签是否转移到CPU无所谓，因为没有用于plt的方法中plt.imshow(img, cmap="gray")plt.show()print(f"True label: {true_label}")print(f"Predict: {pred.item()}")