resnet

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


class ResBlk(nn.Module):
    '''
    resnet block
    '''
    def __init__(self, ch_in, ch_out):
        '''
        
        :param ch_in: 
        :param ch_out: 
        '''
        super(ResBlk, self).__init__()

        self.conv1 = nn.Conv2d(ch_in,ch_out,kernel_size=3,stride=1,padding=1)
        self.bn1 = nn.BatchNorm2d(ch_out)
        self.conv2 = nn.Conv2d(ch_out,ch_out,kernel_size=3,stride=1,padding=1)
        self.bn2 = nn.BatchNorm2d(ch_out)
        self.extra = nn.Sequential()
        if ch_out!=ch_in:
            self.extra = nn.Sequential(
                nn.Conv2d(ch_in,ch_out,kernel_size=1,stride=1),
                nn.BatchNorm2d(ch_out)
            )

    def forward(self,x):
        '''

        :param x:
        :return:
        '''
        out = F.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        # short cut
        # element-wise add: [b, ch_in, h, w] with [b,ch_out,h,w]

        out = self.extra(x) + out

        return  out


class ResNet18(nn.Module):

    def __init__(self):
        super(ResNet18, self).__init__()

        self.conv1 = nn.Sequential(
            nn.Conv2d(3,64,kernel_size=3,stride=1,padding=1),
            nn.BatchNorm2d(64)
        )
        # followed 4 blocks
        # [b, 64 ,h, w ]=>[b, 128, h, w]
        self.blk1 = ResBlk(64,128)
        # [b, 128, h, w]=>[b, 256, h, w]
        self.blk2 = ResBlk(128,128)
        # # [b, 256, h, w]=>[b, 512, h, w]
        self.blk3 = ResBlk(128,256)
        self.blk4 = ResBlk(256,512)
        # [b, 512, h, w]=>[b, 1024, h, w]

        self.outlayer = nn.Linear(512*32*32,10)
    def forward(self, x):
        '''

        :param x:
        :return:
        '''
        x = F.relu(self.conv1(x))
        # [b,64,h,w]
        x = self.blk1(x)
        x = self.blk2(x)
        x = self.blk3(x)
        x = self.blk4(x)

        x = x.view(x.size(0),-1)
        x = self.outlayer(x)

        return x


def main():
    blk = ResBlk(64,128)
    tmp = torch.randn(2,64,32,32)
    out = blk(tmp)

    print('bllk',out.shape)
    model = ResNet18()
    print(model)
    tmp = torch.randn(2,3,32,32)
    out = model(tmp)
    print("resnet:", out.shape)



if __name__ == '__main__':
    main()

import torch
from torch.utils.data import DataLoader
from torchvision  import datasets
from torchvision  import  transforms
#from lenet5 import Lenet5
from torch import nn,optim
from resnet import ResNet18


def main():
    batchsz = 256
    cifar_train = datasets.CIFAR10('cifar', True,transform=transforms.Compose([
        transforms.Resize((32,32)),
        transforms.ToTensor()
    ]), download=True)
    cifar_train = DataLoader(cifar_train, batch_size=batchsz,shuffle=True)

    cifar_test = datasets.CIFAR10('cifar', False, transform=transforms.Compose([
        transforms.Resize((32, 32)),
        transforms.ToTensor()
    ]), download=True)
    cifar_test = DataLoader(cifar_test, batch_size=batchsz, shuffle=True)
    x, label = iter(cifar_train).next()
    print('x:', x.shape,'label: ',label.shape)
    print(torch.cuda.is_available())
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    #  model = Lenet5().to(device)
    model = ResNet18().to(device)
    print(model)
    criteon = nn.CrossEntropyLoss().to(device)
    optimizer = optim.Adam(model.parameters(), lr=1e-3)
    for epoch in range(1000):
        model.train()
        for batchidx, (x,label) in enumerate(cifar_train):
            # [b,3,32,32]
            # [b]
            x,label = x.to(device),label.to(device)

            logits = model(x)
            # logits[b,10]
            # label:[b]
            # predict 与logits的区别 ，前者经过softmax
            # loss : tensor  scalar
            loss = criteon(logits, label)

            # back pro
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
        #
        print('epoch: ',epoch,'loss:',loss.item())

        model.eval()
        with torch.no_grad():
            # test
            total_correct = 0
            total_num =0
            for x,label in cifar_test:
                # [b,3,32,32]
                # [b]
                x, label = x.to(device),label.to(device)
                # [b,10]
                logits = model(x)
                #
                pred = logits.argmax(dim=1)
                total_correct += torch.eq(pred, label).float().sum().item()
                total_num += x.size(0)
            acc = total_correct/total_num
            print(epoch, acc)

if __name__ == '__main__':
    main()