pytorch搭建简单网络及相关知识

import torch

b = torch.randn(2,3)
a = torch.randn(2,3)
a = torch.randn(3)

print(a)
print(b)
c=torch.abs(b)#绝对值
d=torch.add(a,b)#求和
e=torch.clamp(b,-0.1,0.1)#对B进行裁减，超过0.1的为0.1，小于-0.1的为-0.1
f=torch.div(a,b)#求商
g=torch.mul(a,b)#求积
h=torch.pow(b,10)#求幂
j=torch.mm(a,b)#矩阵求积
k=torch.mv(a,b)#a为矩阵b为向量
print(f)

 

 

 

import torch       #导入包     
#下面定义四个整形变量
batch_n=100        #一个批次中输入数据的数量
hidden_layer=100   #定义经过隐藏层后保留的数据特征的个数
input_data=1000    #每个数据包含的数据特征个数
output_data=10     #输出数据，分类结果值

#通过randn（）随机生成的浮点数，取值满足均值为0，方差为1的正太分布。
x  = torch.randn(batch_n,input_data)       #输入层参数（100,1000）
y  = torch.randn(batch_n,output_data)      #输出层参数（100,10）
w1 = torch.randn(input_data,hidden_layer)  #输入到隐藏权重参数维度（1000,100）
w2 = torch.randn(hidden_layer,output_data) #隐藏到输出权重参数维度（100,10）

epoch_n=20         #定义训练次数
learning_rate=1e-6 #定义学习率

#开始训练
for epoch in range(epoch_n):
    h1     = x.mm(w1)                                       #torch.mm(a, b)是矩阵a和b矩阵相乘，（100,1000）x（1000,100）
    h1     = h1.clamp(min =0)                               #对h1边界裁剪，最小为0，（Relu激活函数）
    y_pred = h1.mm(w2)                                      #(100,100)x(100,10)=(10,100)
    #y_pred是前向传播得到的预测结果。

    loss=(y_pred-y).pow(2).sum()                            #均方误差公式为损失函数
    print("Epoch{},Loss:{:.4f}".format(epoch,loss))

    #下面是后向传播，通过链式求导得出每个参数对应的梯度。
    #梯度是一个方向，而不是一个值。
    #该点的梯度就表示从该点出发，函数值增长最为迅猛的方向。
    #导数，就是用来分析函数“变化率”的一种度量
    #偏导数为函数在每个位置处沿着自变量坐标轴方向上的导数（切线斜率）。
    #方向导数的本质是一个数值，简单来说其定义为：一个函数沿指定方向的变化率。
    grad_y_pred  = 2*(y_pred-y)
    grad_w2      = h1.t().mm(grad_y_pred)       #t()是转置,对w2求偏导=2[yp-y]w1x

    grad_h       = grad_y_pred.clone()
    grad_h       = grad_h.mm(w2.t())
    grad_h.clamp_(min=0)
    grad_w1      = x.t().mm(grad_h)            #对w1求偏导
    w1          -= learning_rate*grad_w1
    w2          -= learning_rate*grad_w2

 

 

 

下面是自动梯度的代码

 

import torch       #导入包     
from torch.autograd import Variable

#下面定义四个整形变量
batch_n     =100        #一个批次中输入数据的数量
hidden_layer=100        #定义经过隐藏层后保留的数据特征的个数
input_data  =1000       #每个数据包含的数据特征个数
output_data =10         #输出数据，分类结果值

#通过randn（）随机生成的浮点数，取值满足均值为0，方差为1的正太分布。
#用Variable类对Tensor数据类型变量进行封装操作。
#为false该变量在自动梯度计算过程中不保留梯度值。
x  = Variable(torch.randn(batch_n,input_data      ) , requires_grad=False)
y  = Variable(torch.randn(batch_n,output_data     ) , requires_grad=False)
w1 = Variable(torch.randn(input_data,hidden_layer ) , requires_grad=True )
w2 = Variable(torch.randn(hidden_layer,output_data) , requires_grad=True )

epoch_n=20             #定义训练次数
learning_rate=1e-6     #定义学习率

#开始训练
for epoch in range(epoch_n):
    y_pred = x.mm(w1).clamp(min=0).mm(w2)
    loss   = (y_pred-y).pow(2).sum()                       #均方误差公式为损失函数
    print("Epoch:{},Loss:{:.4f}".format(epoch,loss))

    loss.backward()                                        #自动计算每个节点的梯度值
    w1.data -=learning_rate*w1.grad.data
    w2.data -=learning_rate*w2.grad.data                   #访问梯度数据：X.grad.data

    w1.grad.data.zero_()                                   #梯度值置零
    w2.grad.data.zero_()

自定义传播函数

import torch       #导入包     
from torch.autograd import Variable

#下面定义四个整形变量
batch_n     =100        #一个批次中输入数据的数量
hidden_layer=100        #定义经过隐藏层后保留的数据特征的个数
input_data  =1000       #每个数据包含的数据特征个数
output_data =10         #输出数据，分类结果值

#通过randn（）随机生成的浮点数，取值满足均值为0，方差为1的正太分布。
#用Variable类对Tensor数据类型变量进行封装操作。
#为false该变量在自动梯度计算过程中不保留梯度值。
class Model(torch.nn.Module):        #构建类，继承了Torch.nn.module                 
    def __init__(self):              #类的初始化，当创建这个类的实例时就会调用该方法；
        super(Model,self).__init__() #self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数；
                                     #self代表类的实例,表示当前对象的地址  self.__class__ 则指向类
    def forward(self,input,w1,w2):   #实现了前向传播的矩阵运算
        x=torch.mm(input,w1)
        x=torch.clamp(x,min=0)
        x=torch.mm(x,w2)
        return x

    def backward(self):              #实现了后向传播的自动梯度计算。
        pass

model=Model()                        #调用这个类

#下面是模型训练和参数优化
x  = Variable(torch.randn(batch_n,input_data      ) , requires_grad=False)
y  = Variable(torch.randn(batch_n,output_data     ) , requires_grad=False)
w1 = Variable(torch.randn(input_data,hidden_layer ) , requires_grad=True )
w2 = Variable(torch.randn(hidden_layer,output_data) , requires_grad=True )

epoch_n=20             #定义训练次数
learning_rate=1e-6     #定义学习率

#开始训练
for epoch in range(epoch_n):
    y_pred = model(x,w1,w2)
    loss   = (y_pred-y).pow(2).sum()                       #均方误差公式为损失函数
    print("Epoch:{},Loss:{:.4f}".format(epoch,loss))

    loss.backward()                                        #自动计算每个节点的梯度值
    w1.data -=learning_rate*w1.grad.data                   #访问梯度数据：X.grad.data
    w2.data -=learning_rate*w2.grad.data                   #X.data代表Tensor数据类型的变量

    w1.grad.data.zero_()                                   #梯度值置零
    w2.grad.data.zero_()