Datawhale 第二次打卡第一天记录

一：torch基本代码：
import部分
import os
import numpy as np
import torch
import torch.nn as nn
from torch.utils.data import Dataset,Dataloader
import torch.optim as optimizer

其他设置
batch_size=
lr=
max_epochs(优化器学习率）

GPU 设置方式：
os.environ[‘’]=“0.1”
device=torch.device(“” if torch.cuda.is_available() else “cpu”)

数据读入
包含三个函数：
init: 向类中传入外部参数，定义样本集。
getitem 逐个读取样本集合中的元素，进行变换
__len__用于返回数据集的样本数。

class Mydataset(dataset):
def init(self,data_dir,info_csv,image_list,transform=None):
label_info=pd.read_csv(info_csv)
image_file=open(image_list).readlines()
self.data_dir=data_dir
self.image_file=image_file
self.label_info=label_info
self.transform=transform

def __getitem(self,index):
image_name=self.image_file[index].strip(‘\n’)
raw_label=self.label_info.loc[self.label_info[‘image_index’]==image_name]
label=raw_label.iloc[:,0]
image_name=os.path.join(self.data_dir,image_name)
image=Image.open(image_name).convert(‘RGB’)
if self.transform is not None:
image=self.transform(image)
returns image,label

def len(self):
return len(self.image_file)

如果dataset好了，就可以用dataset来读数据了
from torch.utils.data import dataLoader
train_loader=torch.utils.data.DataLoader(train_data,batch_size,num_workers=4,shuffle=True, drop_last=True)
val_loader=torch.utils.data.Dataloader(val_data,batch_size=batch_size,num_workers=4,shuffle=False)
batchsize 按批读
num_worker多少个进程
shuffle是否打乱
droplast最后一部分不进行训练。
可以用next和iter完成dataloader的读取
import matplotlib.pyplot as plt
images,labels=next(iter(val_loader))
plt.imshow(images[0].transpose(1,2,0))
plt.show()

MLP 定义
from torch import nn
class MLP(nn.Module):
def init(self,**kwargs):
super(MLP,self).init(**kwargs)
self.hidden=nn.Linear(784,256)
self.act=nn.ReLU()
self.output=nn.Linear(256,10)
def forward(self,x):
o=self.act(self.hidden(x))
return self.output(o)

自定义层：
import torch
from torch import nn

class Mylayer(nn.module):
def init(self,**kwargs):
super(MyLayer,self).init(**kwargs)
def forward(self,x):
return x-x.mean()
测试
layer=Mylayer()
layer(torch.tensor([1,2,3,4,5], dtype=torch.float))

将tensor定义为parameter：
分别由parameterlist 和parameterdict两种不同方式
self.params=nn.ParameterList([nn.Parameter(torch.randn(4,4)) for i in range(3)])
self.params.append(nn.Parameter(torch.randn(4,1)))

def forward(self,x):
for i in range(len(self.params)):
=torch.mm(x,self.params[i])
return x
net MyListdense()
print(net)

dict:
self.params=nn.ParameterDict({‘linear’:nn.Parameter(torch.randn(4,4)),‘Linear2’:nn.Parameter(torch.randn(4,1))})
self.params.update({linear3:nn.Parameter(torch.randn(4,2))})

def forward(self,x,choice=‘linear1’):
return torch.mm(x,self.params[choice])
net =my dictdense()
print(net)

二维卷积层，待补充。
池化层待补充。

神经网络训练过程如下：
1定义包含一些可学习参数的神经网络
2：在输入数据集上迭代
3：通过网络处理输入
4：计算loss
5：将梯度反向传播给网络的参数
6更新网络的权重，
待补充：
feed-forward network
alexnet

模型初始化：
torch.nn.init
用isinstance来判断模块属于什么类型
isinstance(conv,nn.conv2d)
isinstance(linear,nn.Conv2d)
对于不同类型层，可以采用不同的初始化方法。
torch.nn.init.kaiming_normal_(conv.weight.data)
conv.weight.data
torch.nn.init.constant_(linear.weight.data,0.3)
linear.weight.data
conv进行kaiming初始化
linear进行常数初始化

初始化更多整理待续。

损失函数
torch.nn.BCELoss(weight=None,size_average=None,reduce=None,reduction=‘mean’)

m=nn.sigmoid()
loss=nn.BCEloss()
input=torch.randn(3,requires_grad=True)
target=torch.empty(3).random_2(2)
output=loss(m(input),target)
output.backward()
print(output)

next example
loss=nn.coressentropyloss()
input=torch.randn(3,5,requires_grad=True)
target=torch.empy(3,dtype=torch.long).random_(5)
output=loss(input,target)
output.backward()

Also L1 loss
MSE loss
smooth L1 loss
poissonNLLLoss
KLDivLoss
marginRankingLoss
MultilabelmarginLoss
SoftmarginLoss
MultimarginLoss
TripletMarginloss
hingEmbeddingloss
cosineembeddingloss
CTC loss
可以用这些loss想想能否写出alpha

训练评估。
model.train()
model.eval()

for data,label in train_loader:
data,label=data.cuda(), label.cuda()
optimizer.zero_grad()
output=model(data)
loss=criterion(output,label)
loss.backward()
optimizer.step()

可视化等待

pytorch优化器
十种优化器
torch.optim.ASGD
torch.optim.Adadelta
torch.optim.Adagrad
torch.optim.Adam
torch.optim.AdamW
torch.optim.Adamax
torch.optim.LBFGS
torch.optim.RMSprop
torch.optim.Rprop
torch.optim.SGD
torch.optim.SparseAdam
optimizer三个属性
defaults：优化器的超参数
lr:0.1, momentum:0.9 dampening:0 wieght_decay:0, nesterov:false

state 参数的缓存
momentum_buffer

param_groups

优化器有待补充

具体例子将会涉及一下几个方面：
导入必要的包
配置训练环境和超参
数据读入和加载
数据变换
读入csv数据
模型设计
设定损失函数
设定优化器
训练测试
模型保存。
代码和实战有待补充