速

1，梯度：

 2，激活函数

1，sigmoid

1，torch.sigmoid

import torch

a = torch.linspace(-100,100,10)

print(a)

print(torch.sigmoid(a))

2, tanh

1,torch.tanh

b = torch.linspace(-1,1,10)

print(b)

print(torch.tanh(b))

3,Relu

3,loss的梯度

1，均方误差，mse

用pytorch求导：

import torch
from torch.nn import functional as F

x = torch.ones(1)

print(x)
w = torch.full([1],2.0)
print(w)

mse = F.mse_loss(torch.ones(1),w*x)
print(mse)

w.requires_grad_() # 对w进行更新，让它拥有求导信息

mse = F.mse_loss(torch.ones(1),w*x)

print(torch.autograd.grad(mse, [w]))

2，softmax

4，感知机

1，单层感知机

x中，上面的0表示是在第一层，下面的数字表示该层节点的编号，w中，上面的1表示层数，下面上一层的节点数，后面的表示该层层数

导数推导过程：

2，多层感知机

导数推导

这里去掉求和是因为wjk只会影响到ok和tk而其它项不影响，所以求和符号可以去掉

5，链式法则

 6，神经网络反向传播算法

推导Wij：

7，cross_entropy

流程

代码实现

import  torch
from torch.nn import functional as F

x = torch.randn(1,784)
w = torch.randn(10,784)

# 建立公式

logits = x@w.t()
print(logits)

pre = F.softmax(logits,dim=1)
print(pre)

print(F.cross_entropy(logits,torch.tensor([2])))

pre那两句可以不写

8，全连接层 

nn.Linear

class MLP(nn.Module):
    def __init__(self):
        super(MLP,self).__init__()

        self.model = nn.Sequential(  # nn.Sequential 一个容器，可以添加任何继承自nn.Module里面的类
            nn.Linear(784,200),
            nn.ReLU(inplace=True),
            nn.Linear(200,200),
            nn.ReLU(inplace=True),
            nn.Linear(200,10),
            nn.ReLU(inplace=True)

        )
    def forwaard(self,x):
        x  = self.model(x)
        return x
net = MLP()
optimizer = optim.SGD(net.parameters(),lr=0.01) # net.parameters() 装所有的参数（w,b) ,定义优化器
criteon = nn.CrossEntropyLoss() # 定义交叉熵

后续可用于训练

9，激活函数与GPU加速

tanh是sigmoid函数经过缩放得到 （rnn）

relu

能解决梯度离散的现象

Leaky ReLU

seLU

GPU加速