porch(2)莫烦python 笔记

版权声明：欢迎大佬指正！ https://blog.csdn.net/sinat_36215255/article/details/86313926

莫烦python

1.线性回归模型

网址

1.建立数据集

我们创建一些假数据来模拟真实的情况. 比如一个一元二次函数: y = a * x^2 + b, 我们给 y 数据加上一点噪声来更加真实的展示它.

import torch
import matplotlib.pyplot as plt

x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)  # x data (tensor), shape=(100, 1)
y = x.pow(2) + 0.2*torch.rand(x.size())                 # noisy y data (tensor), shape=(100, 1)

# 画图
plt.scatter(x.data.numpy(), y.data.numpy())
plt.show()

2.建立神经网络

只有一个输入层，一个隐藏层，一个输出层

"""
Net (
  (hidden): Linear (1 -> 10)
  (predict): Linear (10 -> 1)
)
"""

代码如下： 

import torch
from torch.autograd import Variable
import matplotlib.pyplot as plt
import torch.nn.functional as F
class Net(torch.nn.Module): #继承模块torch.nn.Module
    #定义所有的层属性
    def __init__(self,n_feature,n_hidden,n_output):  #信息
        super(Net,self).__init__() #继承
        self.hidden = torch.nn.Linear(n_feature, n_hidden) #隐藏层
        self.predict = torch.nn.Linear(n_hidden, n_output) #输出层线性输出
    def forward(self, x): #层信息传递
        x = F.relu(self.hidden(x)) #激励函数（）
        x = self.predict(x)
        return x

net = Net(1,100,1) #一个输入，一个输出，10个隐藏层
print(net)

3.训练网络，并且可视化

plt.ion() #实施打印
plt.show()

#训练优化
optimizer = torch.optim.SGD(net.parameters(),lr=0.3)
#net.parameters()网络的所有参数 ，lr学习效率<1
loss_func = torch.nn.MSELoss()
#预测值和真实值的计算误差，MSELoss均方差

#训练
for t in range(100):
    prediction = net.forward(x) #给net训练数据x输出预测值
    loss = loss_func(prediction,y)#计算误差

    optimizer.zero_grad()#先梯度降为0，清空上一步的残余更新参数值
    loss.backward() #计算梯度，误差反向传递，计算参数更新值
    optimizer.step() #优化梯度，将参数更新值施加到net的所有参数上
    if t % 10 == 1:  #画图
        # plot and show learning process
        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=%.4f' % loss.data.numpy(), fontdict={'size': 20, 'color': 'red'})#画误差
        plt.pause(0.1)

部分结果图如下： 

2.分类模型

1.建立数据集

我们创建一些假数据来模拟真实的情况. 比如两个二次分布的数据, 不过他们的均值都不一样.

# 假数据
n_data = torch.ones(100, 2)         # 数据的基本形态
x0 = torch.normal(2*n_data, 1)      # 类型0 x data (tensor), shape=(100, 2)
y0 = torch.zeros(100)               # 类型0 y data (tensor), shape=(100, 1)
x1 = torch.normal(-2*n_data, 1)     # 类型1 x data (tensor), shape=(100, 1)
y1 = torch.ones(100)                # 类型1 y data (tensor), shape=(100, 1)

# 注意 x, y 数据的数据形式是一定要像下面一样 (torch.cat 是在合并数据)
x = torch.cat((x0, x1), 0).type(torch.FloatTensor)  # FloatTensor = 32-bit floating
y = torch.cat((y0, y1), ).type(torch.LongTensor)    # LongTensor = 64-bit integer

# plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=y.data.numpy(), s=100, lw=0, cmap='RdYlGn')
# plt.show()

2.建立神经网络

方法与上诉完全相同

3.训练网络

注意此处的计算误差的函数，选择分类，计算概率已经标签误差，因为此神经网络的输出是一维数组【】

oss_func = torch.nn.CrossEntropyLoss()

4可视化

因为out输出以后，我们需要计算他的预测值，来画图，因此对于每一个【a,b】我们取最大的那个值的下标作为预测值来区分原数据

所有代码如下：

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

n_data = torch.ones(100, 2)         # 数据的基本形态
x0 = torch.normal(2*n_data, 1)      # 类型0 x data (tensor), shape=(100, 2)
y0 = torch.zeros(100)               # 类型0 y data (tensor), shape=(100, 1)
x1 = torch.normal(-2*n_data, 1)     # 类型1 x data (tensor), shape=(100, 1)
y1 = torch.ones(100)                # 类型1 y data (tensor), shape=(100, 1)

# 注意 x, y 数据的数据形式是一定要像下面一样 (torch.cat 是在合并数据)
x = torch.cat((x0, x1), 0).type(torch.FloatTensor)  # FloatTensor = 32-bit floating
y = torch.cat((y0, y1), ).type(torch.LongTensor)    # LongTensor = 64-bit integer
#画图
#plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=y.data.numpy(), s=100, lw=0, cmap='RdYlGn')
#plt.show()

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


class Net(torch.nn.Module): #继承模块torch.nn.Module
    #定义所有的层属性
    def __init__(self,n_feature,n_hidden,n_output):  #信息
        super(Net,self).__init__() #继承
        self.hidden = torch.nn.Linear(n_feature, n_hidden) #隐藏层
        self.predict = torch.nn.Linear(n_hidden, n_output) #输出层线性输出
    def forward(self, x): #层信息传递
        x = F.relu(self.hidden(x)) #激励函数（）
        x = self.predict(x)
        return x

net = Net(2,10,2) #两个特征，两个输出，10个隐藏层
#输出[0,1],认为是第一个，[1,0]认为是第二个
print(net)

plt.ion() #实施打印
plt.show()

#训练优化
optimizer = torch.optim.SGD(net.parameters(),lr=0.5)
#net.parameters()网络的所有参数 ，lr学习效率<1
loss_func = torch.nn.CrossEntropyLoss()
#预测值和真实值的计算误差，计算概率，计算标签误差

#训练
for t in range(100):
    out = net.forward(x) #给net训练数据x输出预测值
    loss = loss_func(out,y)#计算误差

    optimizer.zero_grad()#先梯度降为0，清空上一步的残余更新参数值
    loss.backward() #计算梯度，误差反向传递，计算参数更新值
    optimizer.step() #优化梯度，将参数更新值施加到net的所有参数上
    if t % 10 == 1:
        plt.cla()
        prediction = torch.max(out, 1)[1] #寻找为为1的下标
        pred_y = prediction.data.numpy()
        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 = float((pred_y == target_y).astype(int).sum()) / float(target_y.size)
        plt.text(1.5, -4, 'Accuracy=%.2f' % accuracy, fontdict={'size': 20, 'color': 'red'})
        plt.pause(0.1)

3.神经网络构建方法二

快速搭建，直接建神经层

net2 = torch.nn.Sequential(
    torch.nn.Linear(2,10),
    torch.nn.ReLU(),
    torch.nn.Linear(10,2)
)
print(net1)
print(net2)