零基础学习人工智能—Python—Pytorch学习（六）

前言

本文主要讲神经网络的上半部分。

另外，我发现我前面文章写的有歧义的地方还是挺多，虽然，已经改了一部分，但，可能还有没发现的，大家看的时候尽量多理解着看吧。

本着目的是学会使用神经网络的开发，至于数学的部分，就能过就过吧。

神经网络

先学个例子

先结合以前的知识理解一个例子，理解了这个例子，后面理解神经网络就容易多了。

class NeuralNet1(nn.Module):
    def __init__(self, input_size, hidden_size):
        super(NeuralNet1,self).__init__()
        self,linear1 = nn.Linear(input_size, hidden_size) # x的列 转成 隐藏层的列
        self.relu = nn.ReLU() #使用了ReLU（Rectified Linear Unit） 作为激活函数
        self.linear2 = nn.Linear(hidden_size,1) #隐藏层的列转成1列
    def forward(self, x):
        out = self.linear1(x)
        out = self.relu(out)
        out = self.linear2(out)# sigmoid at the end
        y_pred = torch.sigmoid(out)
        return y_pred
model=NeuralNet1(input_size=28*28,hidden_size=5)
criterion =nn.BCELoss()

结合我们之前的知识，上面代码就是定义了一个类，该类继承了Module。

然后初始化函数接受了两参数，俩参数分别是x列，和隐藏层列，然后定义三个对象linear1，linear2，relu。

然后forward就是执行，中间的转换逻辑是x列转成hidden列，hidden列转1列，这中间再加一个激活函数，我们先不管激活函数是什么，反正，代码结构，大概就是这样的逻辑。

criterion =nn.BCELosS()是定义损失函数，BCELoss 的全称是 Binary Cross Entropy Loss（二元交叉熵损失）。

ps：大家有没有注意到，自从我们开始使用model后，就再也没使用 requires_grad来开启张量计算了，这是因为model在计算的时候自己就开了【torch.tensor(0.0, requires_grad=True)】

激活函数

激活函数其实也是函数，就是把x进行一下数据转换。

我们上篇文章已经使用过了Sigmoid把数据转换成百分比了。

下面看一下最受欢迎的激活函数都有什么，如下：

# Most popular activationfunctions
# 1. Step function
# 2. Sigmoid
# 3. TanH
# 4. ReLU （不知道用什么，就用这个）
# 5. Leaky ReLU6. Softmax

各个激活函数x转换成y的模式











激活函数使用参考下面代码

import torch
import torch.nn as nn
import numpy as np
import torch.nn.functional as F #nn不好使时，在这里找激活函数
# 方法1 (create nn modules)
class NeuralNet(nn.Module):
    def __init__(self, input_size, hidden_size):
        super(NeuralNet, self)._init ()
        self.linear1 =nn.Linear(input_size,hidden_size)
        self.relu = nn.ReLU()
        self.linear2 =nn.inear(hidden_size,1)
        self.sigmoid = nn.Sigmoid()
    def forward(self, x):
        out = self.linear1(x)
        out = self.relu(out)
        out = self.linear2(out)
        out = self.sigmoid(out)
        return out

# 方法2 (use activation functions directly in forward pass)
class NeuralNet(nn.Module):
    def __init__(self, input_size, hidden_size):
        super(NeuralNet,self).__init__()
        self.linear1 =nn.Linear(input_size,hidden_size)
        self.linear2 =nn.Linear(hidden_size,1)
    def forward(self,x):
        # F.leaky_relu() #leaky_relu使用方法

        out = torch.relu(self.linear1(x))
        out = torch.sigmoid(self.linear2(out))
        return out

函数

我们先对下面函数进行一下逻辑理解。

sigmoid,MSELoss,BCELoss

前面我们使用了MSELoss做损失函数，他的逻辑是求y预测和y差的平方的均值，如下图：



后面我们的例子里，就把MSELoss换成了BCELoss，当时我们就是把他当做一个求损失值的函数,没研究他的逻辑。

BCELoss的全称是 Binary Cross Entropy Loss（二元交叉熵损失）他的公式是这样的。



经过这个转换y_pred的值范围已经是(0, 1)了。

后来在写例子的时候，在前向传播的时候，又增加了torch.sigmoid做数据转换。

sigmoid的公式是这样的。

softmax和cross_entropy

cross_entropy是 交叉熵损失函数，他的公式是这样的。



结合代码理解。

loss = nn.CrossEntropyLoss()
Y= torch.tensor([0]) #这y是一行一列矩阵，但值0表示类别，如0=猫，1=狗，2=兔子
#nsamples x nclasses=1x3  1行3列
Y_pred_good = torch.tensor([[2.0,1.0, 0.1]]) # 这个预测的y里，2最大，2的索引是0.所以，这个预测的y最可能是猫
Y_pred_bad = torch.tensor([[0.5,2.0,0.3]])  # 这个预测的y里，2最大，2的索引是1.所以，这个预测的y最可能是狗
11 = loss(Y_pred_good, Y)
12 = loss(Y_pred_bad, Y)
print(l1.item())
print(l2.item())

_,predictions1 = torch.max(Y_pred_good, 1)
_,predictions2 = torch.max(Y_pred_bad, 1)
print(predictions1)
print(predictions2)

多个类别的预测如下：

loss = nn.CrossEntropyLoss()
Y= torch.tensor([2,0,1]) #这y是一行三列矩阵，但值表示的含义是类别，如2,0,1=猫，0,1,2=狗，2,1,0=兔子
#nsamples x nclasses=3x3  3行3列
Y_pred_good = torch.tensor([[2.0,1.0, 2.1],[2.0,1.0, 0.1],[2.0,3.0, 0.1]]) # 这个预测的y里，三个张量的最大值的索引分别是 2,0,1 ，他跟上面的猫的类别一致，所以是猫这个类别，因为Y的值就代表猫，所以这个是一个好的预测
Y_pred_bad = torch.tensor([[0.5,2.0,0.3],[0.5,2.0,0.3],[0.5,2.0,0.3]])  # 这个预测跟Y不匹配，所以是个不好的预测
11 = loss(Y_pred_good, Y)
12 = loss(Y_pred_bad, Y)
print(l1.item())
print(l2.item())

_,predictions1 = torch.max(Y_pred_good, 1) #values, indices = torch.max(input, dim)
_,predictions2 = torch.max(Y_pred_bad, 1)
print(predictions1)
print(predictions2)

Softmax 激活函数

假设你有一个模型输出的向量 [2.0, 1.0, 0.1]，应用 Softmax 函数可以将其转换为 [0.7, 0.2, 0.1]，表示各个类别的概率分布。

公式如下：



结合代码理解：

# 之前把预测的y都转成了0~1之间的概率值，现在可以用softmax处理
# softmax
def softmax(x):
    return np.exp(x)/np.sum(np.exp(x), axis=0)

x = np.array([2.0, 1.0, 0.1])
outputs = softmax(x)
print('softmax numpy:', outputs)

torch的softmax使用。

x= torch.tensor([2.0,1.0,0.1])
outputs = torch.softmax(x, dim=0)
print(outputs)

CrossEntropyLoss内部会先申请Softmax函数的执行，在调用自己的计算逻辑（就是对数计算那一套）。

传送门：

零基础学习人工智能—Python—Pytorch学习（一）

零基础学习人工智能—Python—Pytorch学习（二）

零基础学习人工智能—Python—Pytorch学习（三）

零基础学习人工智能—Python—Pytorch学习（四）

零基础学习人工智能—Python—Pytorch学习（五）

零基础学习人工智能—Python—Pytorch学习（六）

---

注：此文章为原创，任何形式的转载都请联系作者获得授权并注明出处！

---

---

若您觉得这篇文章还不错，请点击下方的【推荐】，非常感谢！

https://www.cnblogs.com/kiba/p/18369584