pytorch记录

1. 免费使用pycharm专业版
   参考链接：https://www.cnblogs.com/cripplepx/p/12310265.html

2. torch.view()
   重构tensor的维度，类似numpy里的reshape()
   torch.view(a,b) -> a行b列
   torch.view(-1) -> 1维
   torch.view(a,-1,b)，-1代表不确定，让计算机计算对应维度

3. torch.cat()
   torch.cat((a,b),0) ->竖着拼
   torch.cat((a,b),1) ->横着拼
   默认为1

4. argparse
   解析命令行参数的工具包

5. dataset & dataloader
   dataset：pytorch中表示数据集的一个抽象类
   dataloader：迭代器，传入dataset对象，根据batchsize生成一个batch的数据

#官方数据集
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,download=True,transform=transform)
trainloader = torch.utils.data.Dataloader(trainset, batch_size=16, shuffle=True, num_workers=2)
#自定义数据集

6. torch.nn.Sequential

net = torch.nn.Sequential(
            nn.Linear(1,20),
            torch.nn.Relu(),
            nn.Linear(20,20),
            torch.nn.Relu(),
            nn.Linear(20,1)
)
print(net)

7. torch.save &load

#模型的保存
torch.save(model, 'model.pkl') #保存模型网络结构及参数
torch.save(model.state_dict(), 'model_parameters.pkl') #保存模型的参数
#模型的加载
net1 = torch.load('model.pkl')
model.load_state_dict(torch.load(model_parameters.pkl))

8. dataset & dataloader

import torch.utils.data as Data
torch_dataset = Data.TensorDataset(x,y)
loader = Data.DataLoader(torch_dataset, batch_size=BATCH_SIZE, shuffle=True)

9. torch.unsequeeze
   扩展维度，返回一个新的张量，对输入的位置插入维度1

torch.unsequeeze(input, dim, out=none) # dim为插入维度的索引
#相反---降维
torch.sequeeze(input, dim, out=none)

10. torch.max

torch.max(input, dim)
#返回的是两个值，一个是每一行最大值的tensor组，另一个是最大值所在的位置
max_value,index = torch.max(x,dim=1) 
torch.max(x,dim=0)[0].numpy() #每一列最大值
torch.max(x,dim=1)[0].numpy() #每一行最大值
torch.max(x,dim=0)[1].numpy() #每一列最大值的索引
torch.max(x,dim=1)[1].numpy() #每一行最大值的索引

11. type & dtype & astype

---

darts & pc-darts

1. DARTS代码解析
2. DARTS代码解析
3. DARTS代码解析
4. DARTS源码阅读
5. PC-DARTS 网络结构搜索程序分析
6. PC-DARTS源码分析
7. PC-DARTS部分代码

---

PYNQ-Z1开发板支持python

1. vivado配置环境
2. 配置代码环境
3. 模型部署

---

1. pytorch optimizer应用
   SGD：为了改善训练数据N太大导致计算总的cost function来求解梯度代价很大的问题，计算训练数据中的小批量（minibatches），minibatch是一个为2的指数的超参数。

torch.optim.SGD(params, lr, momentum, dampening, weight_decay, nesterov=False)
#Momentum update
v = mu * v - learning_rate * dx # integrate velocity
x += v #integrate position

AdaGrad:
RMSProp:
Adam:

torch.optim.Adam(params, lr, betas=(a,b), weight_decay, amsgrad=False)
#Adam update
m = beta1*m + (1‐beta1)*dx
v = beta2*v + (1‐beta2)*(dx**2)
x += ‐ learning_rate * m / (np.sqrt(v) + eps)

---

一：pytorch编写代码步骤：
四大部分：数据定义、model定义、优化器&损失函数定义、主函数代码逻辑

训练流程

1. 输入处理模块 --- 输入数据x变成tensor
2. 模型构建模块 --- 输入数据变成预测的y’，前向传播过程
3. 定义代价函数和优化器的模块 --- 将前向传播得到的y’进行自动求导和更新
4. 构建训练过程 --- 迭代训练

数据处理：
torch.utils.data.Dataset

from torch.utils.data import Dataset
class trainDataset(Dataset):
      def __init__(self):
      # constructor

      def __getiem__(self, index):
      # 获得第index号的数据和标签

      def __len__(self):
      # 获得数据量

torch.utils.data.DataLoader

from torch.utils.data import DataLoader
dataLoader = DataLoader(dataset, shuffle=True, batch_size=16)
for i, data in enumerate(dataLoaderr, 0):
        x, y = data

模型构建：
torch.nn.Module

class MyModule(torch.nn.Module):
      def __init__(self):
              super(MyModule, self).__init__()
               ...
      def forward(self, x):
              ...
              return ...
model = MyModule()

搭建模型时， 只需考虑前向传播，不需要考虑反向传播。

定义代价函数和优化器：

criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameterd(), lr = 0.0001, betas=(0.9,0.99), weight_decay, amsgrad=False)
optimizer.zero_grad
output = model(input)
output.backward(output)
optimizer.step()

损失函数loss可以看作nn的某一个特殊的层，也是nn.Module的一个子类。但习惯上将损失函数不放在model中定义，而是单独定义。损失函数和优化器都有许多种，具体实际应用时参照官方doc。
在finretune过程中，利用optimizer对网络的不同层设置不同的学习率。

torch.optim.SDG([{'params':net.feature.parameters()},{'params':net.classifier.parameters(), 'lr': 1-5e}], 'lr':1-3e)

构建训练过程：

def train(epoch): # 进行一个epoch的训练
      for i, data in enumerate(dataLoader, 0);
            x, y = data # 取出minibatch的数据和标签
            y_pred = model(x) # 前向传播
            loss = criterion(y_pred, y) # 计算损失函数
            optimizer.zero_grad # 清零梯度，准备计算
            loss.backward() # 反向传播
            optimizer.step() # 更新训练参数

---

实操

1. regression

import torch
import torch.nn.functional as F
import torch.nn as nn
import matplotlib.pyplot as plt
from torch.autograd import Variable


# x_data = torch.randn(100,1,requires_grad=True)
# y_data = torch.empty(100,1).random_(2)
x = torch.unsqueeze(torch.linspace(-1,1,100),dim=1)
y = x.pow(3) + torch.randn(x.size())*0.1
x, y = (Variable(x),Variable(y))
plt.scatter(x, y)
plt.show()

class regressionNet(torch.nn.Module):
    def __init__(self, n_input, n_hidden, n_output):
        super(regressionNet, self).__init__()
        self.hidden1 = torch.nn.Linear(n_input, n_hidden)
        self.hidden2 = torch.nn.Linear(n_hidden,n_hidden)
        self.predict = torch.nn.Linear(n_hidden, n_output)

    def forward(self, x):
        y_pred = self.hidden1(x)
        y_pred = F.relu(y_pred)
        y_pred = self.hidden2(y_pred)
        y_pred = F.relu(y_pred)
        y_pred = self.predict(y_pred)
        return y_pred
model = regressionNet(1,20,1)
print(regressionNet)

criterion = torch.nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(),lr=0.05)

plt.ion()
plt.show()

for epoch in range(1000):
    y_pred = model(x)
    loss = criterion(y_pred, y)
    print(epoch, loss.item())

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    if epoch%20 == 0:
        plt.cla()
        plt.scatter(x.data.numpy(),y.data.numpy())
        plt.plot(x.data.numpy(),y_pred.data.numpy(),'r-',lw=5)
        plt.text(0.5,0,'loss = %.4f' %loss.data,fontdict={'size':20,'color':'red'})
        plt.pause(0.05)
plt.ioff()
plt.show()

2. mnist