Python pytorch的一个简单封装(最简调参,自适应Size)
文章目录
- 什么是Pytorch
- TorchTools
-
- 功能及其简介
- 构成
- 实例代码
- 可使用对象
-
- 数据
- 网络结构
- Utils代码
什么是Pytorch
PyTorch是一个开源的Python机器学习库，基于Torch，用于自然语言处理等应用程序。
2017年1月，由Facebook人工智能研究院（FAIR）基于Torch推出了PyTorch。它是一个基于Python的可续计算包，提供两个高级功能：
1、具有强大的GPU加速的张量计算（如NumPy）。
2、包含自动求导系统的深度神经网络。
TorchTools
功能及其简介
这是一个基于Pytorch的框架
在神经网络中,最难的就是对于张量Size的掌控,而这个框架可以对Tensor的Size进行自适应调整,让工作重点从对Size的调整转到对网络主干的理解
构成
Size类,包括channel,width,height三个属性,可以储存图片和向量的信息
Layer类,储存层级的单位,包括了in_size和out_size两个数据
Options类,储存所有的层级信息和其他信息
Block类,代替nn.Module,有自动前馈的功能
Utils类,包括了Train和Draw两个函数,可以实现低代码调参训练
实例代码
CNN网络
class CNN(Block):
def __init__(self, options):
super(CNN, self).__init__(options)
self.UseConv2d(8) \
.UseReLU() \
.UseBatchNorm2d() \
.UseMaxPool2d()
self.UseConv2d(16) \
.UseReLU() \
.UseBatchNorm2d() \
.UseMaxPool2d()
self.UseConv2d(32) \
.UseReLU() \
.UseBatchNorm2d() \
.UseMaxPool2d()
self.UseView(0)
self.UseLinear(1000) \
.UseLinear(100) \
.UseLinear(10)
训练代码
data_tf = Compose([ToTensor(), Normalize([0.5], [0.5])])
data_path = 'C:\\0_data\\MNIST_DATA_PyTorch' # minist数据集的下载路径
# 获取数据集
train_data = mnist.MNIST(data_path, train=True, transform=data_tf, download=False)
test_data = mnist.MNIST(data_path, train=False, transform=data_tf, download=False)
train_loader = data.DataLoader(train_data, batch_size=128, shuffle=True)
test_loader = data.DataLoader(test_data, batch_size=128, shuffle=True)
model, loss, accuracy = Utils.Train(model_name=CNN,
options=Options(1, 28, 28, 'cuda'),
train_loader=train_loader,
test_loader=test_loader,
accuracy_calculate=lambda x, y: (max(x, 1)[1].numpy() == y.numpy()).mean(),
epoch_cout=10,
loss_func_name=nn.CrossEntropyLoss,
optimizer_name=optim.Adam,
learn_rate=0.001)
Utils.Draw('LOSS', Loss=loss, Accuracy=accuracy)
save(model, 'model/cnn')
结构展示
可使用对象
数据
一维向量,二维图片
网络结构
| 名称 | 介绍 | 对象 |
|---|---|---|
| Conv2d | 2维卷积层 | 图片 |
| MaxPool2d | 2维最大池化 | 图片 |
| AvgPool2d | 2维平均池化 | 图片 |
| BatchNorm2d() | 2为标准化 | 图片 |
| Linear | 全连接层 | 向量 |
| ReLU | ReLU激活函数 | * |
| Sigmoid | Sigmoid激活函数 | * |
| View | 对数据进行拉伸 | 只支持图片和向量的转换 |
Utils代码
from matplotlib import pyplot as plt
from torch import nn
from torch.autograd import Variable
import numpy as np
class Size:
def __init__(self, channel, width, height):
self.channel = channel
self.width = width
self.height = height
def __str__(self):
return f'channel:{self.channel}\twidth:{self.width}\theight:{self.height}'
class Layer:
def __init__(self, typename, **kwargs):
self.name = typename
self.args = kwargs
@property
def in_size(self) -> Size:
return self.args['in_size']
@property
def out_size(self) -> Size:
return self.args['out_size']
class Options:
def __init__(self, channel, width, height, device='cpu'):
self.__options = {}
self.__layers = [Layer('Input',
out_size=Size(channel, width, height),
in_size=Size(channel, width, height))]
self.__device = device
def Device(self, model=None):
if model is not None:
model = model.to(self.__device)
return model
else:
return self.__device
@property
def Layers(self):
return self.__layers
def __getitem__(self, item):
if item not in self.__options.keys():
raise Exception('Unknown Key')
return self.__options[item]
def __setitem__(self, key, value):
self.__options[key] = value
self.__dict__[key] = value
def __len__(self):
return len(self.__layers)
def AddProperty(self, **kwargs):
for item in kwargs.keys():
self.__options[item] = kwargs[item]
self.__dict__[item] = kwargs[item]
def AddLayer(self, typename, **kwargs):
data = Layer(typename, **kwargs)
self.__layers.append(data)
def GetIndexLayer(self, index) -> Layer:
return self.__layers[index]
def GetLastLayerSize(self) -> Size:
return self.GetIndexLayer(-1).out_size
class Block(nn.Module):
def __init__(self, options: Options = None):
super(Block, self).__init__()
self.options = options if options is not None else Options()
self.layer = nn.Sequential()
self._start = len(self.options)
self._count = 0
def SetDevice(self):
self.options.Device(self)
def GetOptions(self):
return self.options
def UseConv2d(self, out_channels, kernel_size=3, padding=0, stride=1):
in_size = self.options.GetLastLayerSize()
self.layer.append(nn.Conv2d(in_channels=in_size.channel,
out_channels=out_channels,
kernel_size=kernel_size,
padding=padding,
stride=stride))
self.options.AddLayer('Conv2d',
in_channels=in_size.channel,
out_channels=out_channels,
kernel_size=kernel_size,
padding=padding,
stride=stride,
in_size=in_size,
out_size=Size(out_channels,
int((in_size.width + 2 * padding - kernel_size) / stride + 1),
int((in_size.height + 2 * padding - kernel_size) / stride + 1)))
self._count += 1
return self
def UseMaxPool2d(self, kernel_size=2, padding=0, stride=1):
self.layer.append(nn.MaxPool2d(kernel_size=kernel_size, padding=padding, stride=stride))
in_size = self.options.GetLastLayerSize()
self.options.AddLayer('MaxPool2d',
kernel_size=kernel_size,
padding=padding,
stride=stride,
in_size=in_size,
out_size=Size(in_size.channel,
int((in_size.width + 2 * padding - kernel_size) / stride + 1),
int((in_size.height + 2 * padding - kernel_size) / stride + 1)))
self._count += 1
return self
def UseAvgPool2d(self, kernel_size=2, padding=0, stride=1):
self.layer.append(nn.AvgPool2d(kernel_size=kernel_size, padding=padding, stride=stride))
in_size = self.options.GetLastLayerSize()
self.options.AddLayer('AvgPool2d',
kernel_size=kernel_size,
padding=padding,
stride=stride,
in_size=in_size,
out_size=Size(in_size.channel,
int((in_size.width + 2 * padding - kernel_size) / stride + 1),
int((in_size.height + 2 * padding - kernel_size) / stride + 1)))
self._count += 1
return self
def UseLinear(self, out_features):
in_size = self.options.GetLastLayerSize()
in_features = in_size.width
if in_size.channel != 0: # 如果是0通道,代表是线性的
raise Exception('in_features is None')
self.layer.append(nn.Linear(in_features=in_features, out_features=out_features))
self.options.AddLayer('Linear',
in_features=in_features,
out_features=out_features,
in_size=in_size,
out_size=Size(0, out_features, 0))
self._count += 1
return self
def UseBatchNorm2d(self, channel=None):
in_size = self.options.GetLastLayerSize()
if in_size.channel == 0:
raise Exception('This Layer Could Not Be 0')
channel = in_size.channel
self.layer.append(nn.BatchNorm2d(channel))
self.options.AddLayer('BatchNorm2d',
channel=channel,
in_size=in_size,
out_size=in_size)
self._count += 1
return self
def UseView(self, channel, width=0, height=0):
# 只支持图像或者向量
in_size = self.options.GetLastLayerSize()
if channel == 0:
width = in_size.channel * in_size.width * in_size.height
self.options.AddLayer('View',
channel=channel,
width=width,
height=height,
in_size=in_size,
out_size=Size(channel, width, height))
self._count += 1
return self
def UseReLU(self):
in_size = self.options.GetLastLayerSize()
self.layer.append(nn.ReLU())
self.options.AddLayer('ReLU',
in_size=in_size,
out_size=in_size)
self._count += 1
return self
def UseSigmoid(self):
in_size = self.options.GetLastLayerSize()
self.layer.append(nn.Sigmoid())
self.options.AddLayer('Sigmoid',
in_size=in_size,
out_size=in_size)
self._count += 1
return self
def forward(self, data):
cnt = 0
for index in range(self._count):
layer = self.options.Layers[self._start + index]
if layer.name == 'View':
if layer.args['channel'] == 0:
# 转换为向量
data = data.view(data.size(0), -1)
else:
data = data.view(data.size(0), layer.args['width'], layer.args['height'])
elif layer.name == 'Input':
data = data.to(self.options.Device)
continue
else:
data = self.layer[cnt](data)
cnt += 1
return data
class Utils:
@staticmethod
def Train(model_name,
options: Options,
train_loader,
test_loader,
accuracy_calculate,
epoch_cout,
loss_func_name,
optimizer_name,
learn_rate):
loss_func = loss_func_name()
model = model_name(options)
model.SetDevice()
optimizer = optimizer_name(model.parameters(), lr=learn_rate)
loss_value = []
accuracy_value = []
for epoch in range(epoch_cout):
for index, (x, y) in enumerate(train_loader):
batch_x = options.Device(Variable(x))
batch_y = options.Device(Variable(y))
out = model(batch_x)
loss = loss_func(out, batch_y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
loss = loss.cpu()
loss_value.append(loss.data)
accuracy = []
accuracy.clear()
for index, (x, y) in enumerate(test_loader):
batch_x = options.Device(Variable(x))
batch_y = Variable(y)
out = model(batch_x).cpu()
accuracy.append(accuracy_calculate(out, batch_y))
accuracy_value.append(np.array(accuracy).mean())
return model, loss_value, accuracy_value
@staticmethod
def Draw(name, **kwargs):
plt.figure('LOSS')
for key in kwargs.keys():
plt.plot(kwargs[key], label=key)
plt.legend()
plt.show()