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()
