pytorch(二)Lenet-5

我就是我 2023-01-05 05:17 139阅读 0赞

1、输入预处理

2、特征提取（CNN）

4、损失函数

3、分类器分类

网路结构：

![b7492659ea7ab67869576d206f61ef07.png][]

[图来源][Link 1]

Lenet:输入32*32
    conv1:    In-28*28 k:5  pd:2  s:1 -----out:(28+2*2-5)/1+1=28   6*28*28
    maxpool1: In-28*28 k:2 s:2       -----out:(28-2)/2+1=14   16*14*14
    conv2:    In-14*14 k:5    s:1 -----out:(14-5)/1+1=10   16*10*10
    maxpool2: In-10*10 k:2 s:2       -----out:(10-2)/2+1=5   16*5*5
    fc1:      In:5*5                 -----out:120
    fc2:      In:120                 -----out:84
    fc3:      In:84                 -----out:10

代码部分：

class Lenet(nn.Module):
        def __init__(self):
            super().__init__()
            self.conv1=nn.Sequential(
                nn.Conv2d(3,6,5),
                nn.ReLU(),
                nn.MaxPool2d(2,2)
            )
            self.conv2 = nn.Sequential(
                nn.Conv2d(6, 16, 5),
                nn.ReLU(),
                nn.MaxPool2d(2, 2)
            )
            self.fc1=nn.Sequential(
                nn.Linear(16*5*5,120),
                nn.ReLU()
            )
            self.fc2 = nn.Sequential(
                nn.Linear(120, 84),
                nn.ReLU()
            )
            self.fc3=nn.Linear(84,2)
        def forward(self,x):
            x=self.conv1(x)
            x=self.conv2(x)
            x=x.view(x.size()[0],-1)
            x=self.fc1(x)
            x=self.fc2(x)
            x=self.fc3(x)
    
            return x

数据预处理：

# 数据预处理
    transform = tranforms.Compose([
        tranforms.RandomResizedCrop(32),
        tranforms.ToTensor(),
        tranforms.Normalize([0.5,0.5,0.5], [0.5,0.5,0.5])
    ])
    
    root = './data/dog_cat'
    dataset_train = datasets.ImageFolder(root + '/train', transform)
    dataset_test = datasets.ImageFolder(root + '/test', transform)
    
    trainloder=DataLoader(dataset_train,batch_size=batchs,shuffle=True)
    testloder=DataLoader(dataset_test,batch_size=batchs,shuffle=True)

训练：

model=Lenet().to(device)
    loss_fn=nn.CrossEntropyLoss()
    optimizer=optim.SGD(model.parameters(),lr=lr,momentum=0.9)
    
    
    
    # 训练
    if __name__=="__main__":
        for epoch in range(epochs):
            sumloss=0
            for i ,(x,y) in enumerate(trainloder):
                x,y=x.to(device),y.to(device)
                ypred=model(x)
    
                loss=loss_fn(ypred,y)
    
                optimizer.zero_grad()
                loss.backward()
                optimizer.step()
    
                sumloss+=loss.item()
    
                if i %100==99:
                    print("[%d,%d] loss:%.03f"%(epoch+1,i+1,sumloss/100))
                    sumloss=0.0
            with torch.no_grad():
                acc=0
                total=0
                for x,y in testloder:
                    x,y=x.to(device),y.to(device)
                    ypred=model(x)
    
                    _,pred=torch.max(ypred.data,1)
                    total+=y.size(0)
                    acc+=(pred==y).sum()
                print('第%d个epoch的准确率为:%d%%'%(epoch+1,(100*acc/total)))
            torch.save(model.state_dict(),'%s/lenet_model_%03d.pth'%(opt.outf,epoch+1))

测试：

classes=['dog','cat']
    if __name__=="__main__":
        # model = Lenet().to(device)
        model.load_state_dict(torch.load("model/lenet_model_100.pth"))
        # print(label)
        acc = 0.0
        total = 0.0
        with torch.no_grad():
            for x, y in testloder:
                x, y = x.to(device), y.to(device)
                ypred = model(x)
                _, pred = torch.max(ypred.data, 1)
    
                total += y.size(0)
                # (pred==y)得出true或false sum将
                acc += (pred == y).sum().item()
                # print(pred==y)
            print("Test Average accuracy is:{:.4f}%".format(100 * acc / total))
    
    
        calss_acc=[0.0 ,0.0]
        total_lb=[0,0]
        with torch.no_grad():
            acc=0
            total=0
            for x,y in testloder:
                x,y=x.to(device),y.to(device)
                ypred=model(x)
    
                _,pred=torch.max(ypred.data,1)
    
                c=(pred==y).squeeze()
    
                try:
                    for i in range(batchs):
                        lb=label[i]
                        calss_acc[lb]+=c[i].item()
                        total_lb[lb]+=1
                except IndexError:
                    continue
        for i in range(2):
            print('Accuracy of %5s : %4f %%' % (classes[i], 100 * calss_acc[i] / total_lb[i]))
    
        print(classes, total_lb)

[b7492659ea7ab67869576d206f61ef07.png]: /images/20221119/167a82d0c395480db3b1f66dadbaeb09.png
[Link 1]: https://my.oschina.net/u/3994209/blog/3003333