霹雳吧啦学习笔记 用pytroch搭建 AlexNet

定义AlexNet模型 

import torch
import torchvision
from torch import nn

class AlexNet(nn.Module):
    def __init__(self,num_classes=1000,init_weights=False):
        super(AlexNet,self).__init__()
        self.feature=nn.Sequential(
            nn.Conv2d(3,48,kernel_size=11,stride=4,padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3,stride=2),
            nn.Conv2d(48,128,kernel_size=5,padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3,stride=2),
            nn.Conv2d(128,192,kernel_size=3,padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(192,192,kernel_size=3,padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(192,128,kernel_size=3,padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3,stride=2)
        )
        self.classifier=nn.Sequential(
            nn.Dropout(p=0.5),
            nn.Linear(128*6*6,2048),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5),
            nn.Linear(2048,2048),
            nn.ReLU(inplace=True),
            nn.Linear(2048,num_classes)
        )
        if init_weights:
            self._initialize_weights()

    def forward(self,x):
        x=self.feature(x)
        x=torch.flatten(x,start_dim=1)
        x=self.classifier(x)
        return x
    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m,nn.Conv2d):
                nn.init.kaiming_uniform_(m.weight,mode='fan_out',nonlinearity='relu')
                if m.bias is not None:
                    nn.init.constant_(m.bias,0)
            elif isinstance(m,nn.Linear):
                nn.init.normal_(m.weight,0,0.01)
                nn.init.constant_(m.bias,0)

训练代码 

import json
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

from AlexNetmodule import AlexNet
import torch
import torchvision

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)

#对数据集的操作（数据集的获取方式在视频中）
data_transform={
    "train":torchvision.transforms.Compose([
        torchvision.transforms.RandomResizedCrop(224),
        torchvision.transforms.RandomHorizontalFlip(),
        torchvision.transforms.ToTensor(),
        torchvision.transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))
    ]),
    "val":torchvision.transforms.Compose([
        torchvision.transforms.Resize((244,244)),
        torchvision.transforms.ToTensor(),
        torchvision.transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))
    ])}

image_path = "D:\pycharm project\噼里啪啦pytroch\\flower_data"
train_dataset = torchvision.datasets.ImageFolder(image_path+"/train",transform=data_transform["train"])
train_num=len(train_dataset)
flower_list= train_dataset.class_to_idx
cla_dict = dict((val,key) for key,val in flower_list.items())
json_str=json.dumps(cla_dict,indent=4)
with open('class_indices.json','w') as json_file:
    json_file.write(json_str)


batch_size=32
train_loader = DataLoader(train_dataset,batch_size=batch_size,shuffle=True)

valdata_dataset=torchvision.datasets.ImageFolder(image_path+"/val",transform=data_transform["val"])
val_num=len(valdata_dataset)
valdaat_loader = DataLoader(valdata_dataset,batch_size=batch_size,shuffle=True)

net=AlexNet(num_classes=5,init_weights=True)
net.to(device)
loss_function = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(),lr=0.0002)
save_path = 'AlexNet.pth'
best_acc=0.0
step=0
writer=SummaryWriter("keshihua")
for epoch in range(10):
    net.train()
    running_loss=0.0
    for data in train_loader:
        images,labels=data
        optimizer.zero_grad()
        outputs=net(images.to(device))
        loss=loss_function(outputs,labels.to(device))
        loss.backward()
        optimizer.step()
        running_loss+=loss.item()
        writer.add_scalar("train_loss",running_loss,step)
        step+=1
    net.eval()
    acc=0.0
    with torch.no_grad():
        for data_test in valdaat_loader:
            test_images,test_labels=data_test
            outputs=net(test_images.to(device))
            predict=torch.max(outputs,dim=1)[1]
            acc+=(predict==test_labels.to(device)).sum().item()
        accuracy=acc/val_num
        writer.add_scalar("accuracy",accuracy,epoch)
        print("第{0}轮精确度={1},训练损失={2}".format(epoch+1,accuracy,running_loss))

        if accuracy>best_acc:
            best_acc=accuracy
            torch.save(net.state_dict(),save_path)
print("训练完成")
writer.close()

运行结果

tensorboard可视化

 视频链接

【3.2 使用pytorch搭建AlexNet并训练花分类数据集】https://www.bilibili.com/video/BV1W7411T7qc?vd_source=4b9725fafb65bf3e723e89bdb52843cb