PyTorch安装与学会建立第一个神经网络

本文链接：https://blog.csdn.net/qq_45724216/article/details/115981521

PyTorch

安装

1 创建conda虚拟环境
conda create -n PyTorch python=3.6
2 进入PyTorch虚拟环境
conda activate PyTorch
3 安装PyTorch
conda install pytorch torchvision torchaudio cpuonly -c pytorch

numpy与torch的转换与运算

import torch
import numpy as np

# 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数据
print("\nnumpy", np_data, '\ntorch', torch_data,'\nnumpy',tensor2array)

# numpy 与 torch 的运算
data = [-1,-2,1,2]
tensor=torch.FloatTensor(data)  # 将数字转换为32位的浮点数
# abs
print(
    '\nabs',
    '\nnumpy',np.abs(data),
    '\ntorch',torch.abs(tensor)
)
# sin
print(
    '\nsin',
    '\nnumpy_sin',np.sin(data),
    '\ntorch_sin',torch.sin(tensor)
)
# mean 
print(
    '\nmean',
    '\nnumpy_mean',np.mean(data),
    '\ntorch_mean',torch.mean(tensor)
)
# matmul 乘
data = [[1,2],[3,4]]
tensor= torch.FloatTensor(data)
# data = np.array(data)
print(type(data))
# np.matmul(data,data) = data.dot(data)
# torch.mm(tensor,tensor) != tensor.dot(tensor) 后者是转换为一维向量的平方和
print(
    '\nnumpy:',np.matmul(data,data),
    '\ntorch:',torch.mm(tensor,tensor)
)

神经网络中的变量参数 Variable

import torch
from torch.autograd import Variable
# Variable 神经网络中的变量参数
tensor = torch.FloatTensor([[1,2],[2,3]])
variable = Variable(tensor,requires_grad=True)

t_out = torch.mean(tensor*tensor)  # x^2
v_out = torch.mean(variable*variable)

# 求误差的反向传递,variable会受影响
v_out.backward()
# v_out = 1/4*sum(var*var)
# 梯度 d(v_out)/d(var)=1/4*2*variable = varible/2
print(variable)
print(variable.data)
# variable.data 为 tensor 的形式
print(variable.data.numpy())
print(variable.grad)
print(t_out)
print(v_out)

激励函数

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

# fake data
x = torch.linspace(-5,5,200)  # -5 到 5 之间的200个数
x = Variable(x)
x_np = x.data.numpy()

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

plt.figure(1,figsize=(8,6))
plt.subplot(221)
plt.plot(x_np,y_relu,c='red',label='relu')
plt.ylim((-1,5))
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()

建立第一个回归神经网络

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


# 制造数据
x = torch.unsqueeze(torch.linspace(-1,1,100),dim=1)  # 将得到的一维数据转化为二维数据
y = x.pow(2) + 0.2*torch.rand(x.size())  # y值为x^2加噪点值
print(x)
print(y)
# plt.scatter(x.data.numpy(), y.data.numpy())
# plt.show()

class Net(torch.nn.Module):
    # 搭建这些层所需要的信息
    def __init__(self,n_features,n_hidden,n_output):
        super(Net, self).__init__()
        # n_features 输入层个数
        # n_hidden 隐藏层个数
        # n_output 输出层个数
        self.hidden = torch.nn.Linear(n_features,n_hidden)  # 构建一层神经网络（隐藏层
        self.predict = torch.nn.Linear(n_hidden, n_output)


    # 神经网络前向传递的过程，将前面的层信息放在foeward上一个一个组合起来。 搭流程图
    def forward(self,x):
        x = F.relu(self.hidden(x))  # 使用激励函数嵌套住隐藏层输出的信息
        x = self.predict(x)  # 获取输出层结果
        return x
net = Net(1, 10, 1)
print(net)
# 优化神经网络
# net.parameters() 神经网络的参数 lr 学习效率
optimizer = torch.optim.SGD(net.parameters(),lr=0.5)
# loss_func 计算误差的手段 
# MSELoss() 均方差 处理回归问题
loss_func = torch.nn.MSELoss()
for t in range(100):
    #训练
    prediction = net(x)
    # 计算误差
    loss = loss_func(prediction,y) 
    # 优化过程
    optimizer.zero_grad()  # 将所有参数的梯度降为 0 
    loss.backward()  # 反向传递计算结点梯度
    optimizer.step()  # 以学习效率0.5来优化节点中的梯度