莫烦教程pytorch基础

**********生成随机数的方法总结***********

均匀分布

torch.rand(*sizes, out=None) → Tensor

返回一个张量，包含了从区间[0, 1)的均匀分布中抽取的一组随机数。张量的形状由参数sizes定义。

参数:

• sizes (int…) - 整数序列，定义了输出张量的形状
• out (Tensor, optinal) - 结果张量

例子：

torch.rand(2, 3)
0.0836 0.6151 0.6958
0.6998 0.2560 0.0139
[torch.FloatTensor of size 2x3]

标准正态分布

torch.randn(*sizes, out=None) → Tensor

返回一个张量，包含了从标准正态分布（均值为0，方差为1，即高斯白噪声）中抽取的一组随机数。张量的形状由参数sizes定义。

参数:

• sizes (int…) - 整数序列，定义了输出张量的形状
• out (Tensor, optinal) - 结果张量

例子：

torch.randn(2, 3)
0.5419 0.1594 -0.0413
-2.7937 0.9534 0.4561
[torch.FloatTensor of size 2x3]

离散正态分布

torch.normal(means, std, out=None) → → Tensor

返回一个张量，包含了从指定均值means和标准差std的离散正态分布中抽取的一组随机数。

标准差std是一个张量，包含每个输出元素相关的正态分布标准差。

参数:

• means (float, optional) - 均值
• std (Tensor) - 标准差
• out (Tensor) - 输出张量

例子：

torch.normal(mean=0.5, std=torch.arange(1, 6))
-0.1505
-1.2949
-4.4880
-0.5697
-0.8996
[torch.FloatTensor of size 5]

 

***************************************************

1.numpy和torch的转化

np_data=np.arange(6).reshape((2,3))
torch_data=torch.from_numpy(np_data) #numpy转化为torch
tensor2array=torch_data.numpy()#torch转化为numpy

torch.abs(torch.tensor([-1,2,1,-3])) #abs输出绝对值

torch.sin(tensor)#输出sin值

torch.mm(tensor,tensor)#矩阵乘法 （输入参数为tensor。tensor=torch.FloatTensor(data)）

2、variable变量

import torch
from torch.autograd import Variable

tensor=torch.FloatTensor([[1,2],[3,4]])
variable=Variable(tensor,requires_grad=True) #variable可以理解为神经网络中的一个神经元

t_out=torch.mean(tensor*tensor)
v_out=torch.mean(variable*variable)

v_out.backward() #反向传播
print(variable)
print(variable.grad)  #反向传播之后输出 variable的变量
print(variable.data.numpy())

3、激励函数

 

import torch
import torch.nn.functional as F  #nn神经网络模块
from torch.autograd import Variable
import matplotlib.pyplot as plt

x=torch.linspace(-5,5,200)  #-5到5之间的数据取200个线断点的数据
x=Variable(x)
x_np=x.data.numpy()#画图的时候要转化成numpy的数据

y_relu=torch.relu(x).data.numpy()
y_sigmoid=torch.sigmoid(x).data.numpy()
y_tanh=torch.tanh(x).data.numpy()
y_softplus=F.softplus(x).data.numpy()

plt.figure(1,figsize=(8,6))     #画图的一个画布，figsize画布大小
plt.subplot(221)
plt.plot(x_np,y_relu,c='red',label='relu')
plt.ylim((-1,5)) #y轴的范围
plt.legend(loc='best') #展示每条线的标识

plt.subplot(222)
plt.plot(x_np,y_sigmoid,c='red',label='sigmoid')
plt.ylim((-0.2,1.2))
plt.legend(loc='best')

plt.subplot(223)
plt.plot(x_np,y_tanh,c='red',label='tanh')
plt.ylim((-1.2,1.2))
plt.legend(loc='best')

plt.subplot(224)
plt.plot(x_np,y_softplus,c='red',label='softplus')
plt.ylim((-0.2,6))
plt.legend(loc='best')

plt.show()

4、回归

import torch
import torch.nn.functional as F  #nn神经网络模块
from torch.autograd import Variable
import matplotlib.pyplot as plt

x=torch.unsqueeze(torch.linspace(-1,1,100),dim=1)#unsqueeze把一维数据变为二维
y=x.pow(2)+0.2*torch.rand(x.size())

x,y=Variable(x),Variable(y)

class Net(torch.nn.Module): #继承神经网络中的module模块
        def __init__(self,n_feature,n_hidden,n_output):   #搭建层所需要的信息
            super(Net,self).__init__()
            self.hidden=torch.nn.Linear(n_feature,n_hidden)#输入为n_features个值，输出为n_hidden个神经元
            self.predict=torch.nn.Linear(n_hidden,n_output)#输入为n_hidden个神经元，输出为n_output个输出
        
        def forward(self,x):  #前向传播过程
            x=torch.relu(self.hidden(x))  #将隐藏层输出的x个神经元经过激励函数
            x=self.predict(x)
            return x

net=Net(1,10,1)
#print(net)

plt.ion() #画图
plt.show()

optimizer=torch.optim.SGD(net.parameters(),lr=0.5)#lr学习率 一般定义一个小于1的值
loss_func=torch.nn.MSELoss()#损失函数定义为均方差函数

for t in range(100): #开始训练
        prediction=net(x)

        loss=loss_func(prediction,y)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if t%5==0:
                plt.cla() 
                plt.scatter(x.data.numpy(),y.data.numpy())
                plt.plot(x.data.numpy(),prediction.data.numpy(),'r-',lw=5)
                plt.text(0.5,0,'Loss=%0.4f'%loss.data[0],fontdict={'size':20,'color':'red'})
                plt.pause(0.1)
plt.ioff()
plt.show()

 5、分类

import torch
import torch.nn.functional as F  #nn神经网络模块
from torch.autograd import Variable
import matplotlib.pyplot as plt

n_data=torch.ones(100,2)
x0=torch.normal(2*n_data,1) #生成离散正态分布随机数 参数为均值、标准差
y0=torch.zeros(100)     #x0的标签
x1=torch.normal(-2*n_data,1)
y1=torch.ones(100)    #x1的标签
x=torch.cat((x0,x1),0).type(torch.FloatTensor)
y=torch.cat((y0,y1),).type(torch.LongTensor)

x,y=Variable(x),Variable(y)

#plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=y.data.numpy(), s=100, lw=0, cmap='RdYlGn')
#plt.show()
class Net(torch.nn.Module): #继承神经网络中的module模块
        def __init__(self,n_feature,n_hidden,n_output):   #搭建层所需要的信息
            super(Net,self).__init__()
            self.hidden=torch.nn.Linear(n_feature,n_hidden)#输入为n_features个值，输出为n_hidden个神经元
            self.predict=torch.nn.Linear(n_hidden,n_output)#输入为n_hidden个神经元，输出为n_output个输出
        
        def forward(self,x):  #前向传播过程
            x=torch.relu(self.hidden(x))  #将隐藏层输出的x个神经元经过激励函数
            x=self.predict(x)
            return x

net=Net(2,10,2)  #输入x y值 输出10表示第一类，01表示第二类
#print(net)

plt.ion() #画图
plt.show()

optimizer=torch.optim.SGD(net.parameters(),lr=0.02)#lr学习率 一般定义一个小于1的值
loss_func=torch.nn.CrossEntropyLoss()#交叉熵作为损失函数

for t in range(100): #开始训练
        out=net(x)

        loss=loss_func(out,y)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if t%2==0:
                plt.cla()
                prediction=torch.max(F.softmax(out),1)[1]  #max返回两个值 0表示最大值 1表示最大值的位置
                pred_y=prediction.data.numpy().squeeze()
                target_y=y.data.numpy()
                plt.scatter(x.data.numpy()[:,0],x.data.numpy()[:,1],c=pred_y, s=100, lw=0, cmap='RdYlGn')
                accuracy=sum(pred_y==target_y)/200
                plt.text(1.5,-4,'Accuracy=%.2f'%accuracy,fontdict={'size':20,'color':'red'})
                plt.pause(0.1)
plt.ioff()
plt.show()

6、快速搭建

class Net(torch.nn.Module): #继承神经网络中的module模块
        def __init__(self,n_feature,n_hidden,n_output):   #搭建层所需要的信息
            super(Net,self).__init__()
            self.hidden=torch.nn.Linear(n_feature,n_hidden)#输入为n_features个值，输出为n_hidden个神经元
            self.predict=torch.nn.Linear(n_hidden,n_output)#输入为n_hidden个神经元，输出为n_output个输出
        
        def forward(self,x):  #前向传播过程
            x=torch.relu(self.hidden(x))  #将隐藏层输出的x个神经元经过激励函数
            x=self.predict(x)
            return x

net=Net(2,10,2)  #输入x y值 输出10表示第一类，01表示第二类
print(net)

上面的写法可以改成下面的写法：
net2=torch.nn.Sequential(
    torch.nn.Linear(2,10),
    torch.nn.ReLU(),
    torch.nn.Linear(10,2),
    )
print(net2)

7、快速提取

搭建好一个神经网络可以保存起来，下次使用的时候直接提取

torch.save(net1,'net.pkl')#保存整个神经网络

net.save(net1.state_dict(),'net_param.pkl')#保存神经网络的参数

提取：

net2=torch.load('net.pkl')

net3先建立与net1相同的结构

net3=torch.load_state_dict(torch.load('net_param.pkl'))

8、批数据训练

import torch
import torch.utils.data as Data

BATCH_SIZE=5#每次训练的数据量

x=torch.linspace(1,10,10)
y=torch.linspace(10,1,10)

torch_dataset=Data.TensorDataset(x,y)
#数据集，data_tensor表示训练的数据，targer_tensor表示模拟的数据

loader=Data.DataLoader(
    dataset=torch_dataset,
    batch_size=BATCH_SIZE,
    shuffle=True,#训练时 是否乱序
    )

for epoch in range(3):
    for step,(batch_x,batch_y) in enumerate(loader):
        print('epoch:',epoch,'|step:',step,'|batchx:',
              batch_x.numpy(),'|batch_y:',batch_y.numpy())
 

9、optimizer优化器

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

LR=0.01
BATCH_SIZE=100
EPOCH=10

x=torch.unsqueeze(torch.linspace(-1,1,1000),dim=1)
y=x.pow(2)+0.1*torch.normal(torch.zeros(*x.size()))

my_dataset=Data.TensorDataset(x,y)
loader=Data.DataLoader(dataset=my_dataset,
                       batch_size=BATCH_SIZE,
                       shuffle=True,)

class Net(torch.nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.hidden=torch.nn.Linear(1,20)#输入为n_features个值，输出为n_hidden个神经元
        self.predict=torch.nn.Linear(20,1)#输入为n_hidden个神经元，输出为n_output个输出       
    def forward(self,x):#前向传播过程
        x=torch.relu(self.hidden(x))#将隐藏层输出的x个神经元经过激励函数
        x=self.predict(x)
        return x
net_SGD=Net()
net_Momentum=Net()
net_RMSprop=Net()
net_Adam=Net()
nets=[net_SGD,net_Momentum,net_RMSprop,net_Adam]

opt_SGD=torch.optim.SGD(net_SGD.parameters(),lr=LR)
opt_Momentum=torch.optim.SGD(net_Momentum.parameters(),lr=LR,momentum=0.8)
opt_RMSprop=torch.optim.RMSprop(net_RMSprop.parameters(),lr=LR,alpha=0.9)
opt_Adam=torch.optim.Adam(net_Adam.parameters(),lr=LR,betas=(0.9,0.99))
optimizers=[opt_SGD,opt_Momentum,opt_RMSprop,opt_Adam]

loss_func=torch.nn.MSELoss()
losses_his=[[],[],[],[]]

for epoch in range(EPOCH):
    print(epoch)
    for step,(batch_x,batch_y) in enumerate(loader):
        b_x=Variable(batch_x)
        b_y=Variable(batch_y)
        
        for net,opt,l_his in zip(nets,optimizers,losses_his):
            output=net(b_x)
            loss=loss_func(output,b_y)
            opt.zero_grad()
            loss.backward()
            opt.step()
            l_his.append(loss.data[0])

#画出损失值随着训练次数的变化
labels=['SGD','Momentum','RMSprop','Adam']
for i,l_his in enumerate(losses_his):
       plt.plot(l_his,label=labels[i])
plt.legend(loc='best')
plt.xlabel('steps')
plt.ylabel('loss')
plt.ylim((0,0.2))
plt.show()

9、卷积神经网络