一、PyTorch 簡介

1、Why PyTorch？

PyTorch 的優(yōu)勢(shì)是建立的神經(jīng)網(wǎng)絡(luò)是動(dòng)態(tài)的，比如 RNN 變化時(shí)間長度的輸出。而且深入 API，是可能看懂底層在干嘛。.
Tensorflow 的優(yōu)勢(shì)是在分布式訓(xùn)練上下了很多功夫。高度工業(yè)化使得很難看懂底層代碼。

二、PyTorch 神經(jīng)網(wǎng)絡(luò)基礎(chǔ)

1、Torch 或 Numpy

Torch 可以將 tensor 放在 GPU 中加速運(yùn)算(前提是有合適的 GPU)，就像 Numpy 會(huì)把 array 放在 CPU 中加速運(yùn)算。而且 torch 做的和 numpy 能夠很好的兼容，這樣就能自由地轉(zhuǎn)換 numpy array 和 torch tensor 了。

其實(shí) torch 中 tensor 的運(yùn)算和 numpy array 的如出一轍，我們就以對(duì)比的形式來看。如果想了解 torch 中其它更多有用的運(yùn)算符，API就是你要去的地方。

import torch
import numpy as np
# abs 絕對(duì)值計(jì)算
data = [-1, -2, 1, 2]
tensor = torch.FloatTensor(data)  # 轉(zhuǎn)換成32位浮點(diǎn) tensor
print(
    '\nabs',
    '\nnumpy: ', np.abs(data),          # [1 2 1 2]
    '\ntorch: ', torch.abs(tensor)      # [1 2 1 2]
)

# sin   三角函數(shù) sin
print(
    '\nsin',
    '\nnumpy: ', np.sin(data),      # [-0.84147098 -0.90929743  0.84147098  0.90929743]
    '\ntorch: ', torch.sin(tensor)  # [-0.8415 -0.9093  0.8415  0.9093]
)

# mean  均值
print(
    '\nmean',
    '\nnumpy: ', np.mean(data),         # 0.0
    '\ntorch: ', torch.mean(tensor)     # 0.0

除了簡單的計(jì)算，矩陣運(yùn)算才是神經(jīng)網(wǎng)絡(luò)中最重要的部分。

import torch
import numpy as np
data = [[1, 2], [3, 4]]
tensor = torch.FloatTensor(data)

# 矩陣乘法
print('\n', np.matmul(data, data), '\n', torch.mm(tensor, tensor))

# 矩陣乘法
# numpy 和 torch 對(duì)于 dot 的不同之處
data = np.array(data)
print('\n', data.dot(data))
# 錯(cuò)誤寫法，因?yàn)樾掳姹镜?tensor.dot() 只能針對(duì)于一位數(shù)組，即轉(zhuǎn)換成向量乘法
# print('\n', tensor.dot(tensor))
print(torch.tensordot(tensor, tensor))

# 對(duì)應(yīng)元素相乘  x^2
data = np.array(data)
print('\n', data * data)
print('\n', tensor * tensor)

2、變量 Variable

在 Torch 中的 Variable 就是一個(gè)存放會(huì)變化的值的地理位置，里面的值會(huì)不停的變化。就像一個(gè)裝雞蛋的籃子，雞蛋數(shù)會(huì)不停變動(dòng)。那誰是里面的雞蛋呢，自然就是 Torch 的 Tensor 咯。如果用一個(gè) Variable 進(jìn)行計(jì)算，那返回的也是一個(gè)同類型的 Variable。

import torch
from torch.autograd import Variable
tensor = torch.FloatTensor([[1, 2], [3, 4]])
# requires_grad 是參與不參與誤差反向傳播，要不要計(jì)算梯度
var = Variable(tensor, requires_grad = True)
print(tensor)
print(var)
t_out = torch.mean(tensor * tensor)   # x^2
v_out = torch.mean(var * var)            # x^2
print(t_out)
print(v_out)

到目前為止我們看不出什么不同，但是時(shí)刻記住，Variable 計(jì)算時(shí)，它在背景幕布后面一步步默默地搭建著一個(gè)龐大的系統(tǒng)，叫做計(jì)算圖 computational graph。這個(gè)圖是用來干嘛的? 原來是將所有的計(jì)算步驟 (節(jié)點(diǎn)) 都連接起來，最后進(jìn)行誤差反向傳遞的時(shí)候，一次性將所有 variable 里面的修改幅度 (梯度) 都計(jì)算出來，而 tensor 就沒有這個(gè)能力啦。

v_out = torch.mean(variable*variable) 就是在計(jì)算圖中添加的一個(gè)計(jì)算步驟，計(jì)算誤差反向傳遞的時(shí)候有他一份功勞，我們就來舉個(gè)例子：

v_out.backward()  # 模擬 v_out 的誤差反向傳遞
# 下面兩步看不懂沒關(guān)系, 只要知道 Variable 是計(jì)算圖的一部分, 可以用來傳遞誤差就好.
# v_out = 1/4 * sum(variable*variable) 這是計(jì)算圖中的 v_out 計(jì)算步驟
# 針對(duì)于 v_out 的梯度就是, d(v_out)/d(variable) = 1/4*2*variable = variable/2
print(var.grad)    # 初始 Variable 的梯度

那如何獲取 Variable 里面的數(shù)據(jù)呢？直接print(variable)只會(huì)輸出 Variable 形式的數(shù)據(jù)，在很多時(shí)候是用不了的(比如想要用 plt 畫圖)，所以我們要轉(zhuǎn)換一下, 將它變成 tensor 形式：

print(variable)     #  Variable 形式
print(variable.data)    # tensor 形式
print(variable.data.numpy())    # numpy 形式

3、什么是激勵(lì)函數(shù) Activation Function

為什么要使用激勵(lì)函數(shù)？
因?yàn)榧?lì)函數(shù)可以解決日常生活中不能用線性方程 linear function 所概括的問題。

比如說我們可以把神經(jīng)網(wǎng)絡(luò)簡化為 Y = WX，但是這樣只能描述一個(gè)線性問題，于是就需要激勵(lì)函數(shù)來將這條直線“掰彎”，即 Y = AF(WX)。

AF 其實(shí)就是激勵(lì)函數(shù)，常有的選擇是 relu sigmoid tanh，把這些掰彎利器嵌套在原有的結(jié)果就可以強(qiáng)行把原先的線性結(jié)果扭曲成曲線了。同時(shí)我們也可以自己創(chuàng)造激勵(lì)函數(shù)，不過要求是必須可微分，因?yàn)樵?back propagation 誤差反向傳遞時(shí)，只有可微分的激勵(lì)函數(shù)才能把誤差傳遞回去。

恰當(dāng)?shù)厥褂眉?lì)函數(shù)，是有竅門的。

• 少量層結(jié)構(gòu)中，對(duì)于隱藏層使用任意的激勵(lì)函數(shù)不會(huì)有很大的影響。一般地，在 CNN 的卷積層中推薦 Relu，在 RNN 中推薦 tanh 或 Relu。（具體怎么選，看之后 RNN 中詳細(xì)介紹）
• 多層神經(jīng)網(wǎng)絡(luò)中，掰彎利器不能隨意選擇，因?yàn)闀?huì)涉及到梯度爆炸和梯度消失的問題。

4、激勵(lì)函數(shù) Activation

什么是 Activation
一句話概括，就是神經(jīng)網(wǎng)絡(luò)可以描述非線性問題的步驟，讓神經(jīng)網(wǎng)絡(luò)變得更強(qiáng)大。

Torch 中的激勵(lì)函數(shù)
Torch 中的激勵(lì)函數(shù)有很多，常用的有relu``sigmoid``tanh``softplus。

import torch
import torch.nn.functional as F
from torch.autograd import Variable
import matplotlib.pyplot as plt
x = torch.linspace(-5, 5, 200)
x = Variable(x)
x_np = x.data.numpy()  # 換成 numpy array，繪圖時(shí)用
# 幾種常用的 激勵(lì)函數(shù)
y_relu = F.relu(x).data.numpy()
# y_sigmoid = F.sigmoid(x).data.numpy()  提示 nn.functional.sigmoid 已棄用
y_sigmoid = torch.sigmoid(x).data.numpy()
# y_tanh = F.tanh(x).data.numpy()    提示 nn.functional.tanh 已棄用
y_tanh = torch.tanh(x).data.numpy()
y_softplus = F.softplus(x).data.numpy()
# y_softmax = F.softmax(x)  softmax 比較特殊，不能直接顯示，不過它是關(guān)于概率的，用于分類
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()

三、建造第一個(gè)神經(jīng)網(wǎng)絡(luò)

1、關(guān)系擬合 (回歸)

import torch
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())

# 建立神經(jīng)網(wǎng)絡(luò)
# 先定義所有的層屬性 __init__()，再一層層搭建層與層的關(guān)系鏈接 forward(x)
class Net(torch.nn.Module):
    def __init__(self, n_feature, n_hidden, n_output):
        super(Net, self).__init__()   # 繼承 __init__ 功能
        self.hidden = torch.nn.Linear(n_feature, n_hidden)  # 隱藏層線性輸出
        self.predict = torch.nn.Linear(n_hidden, n_output)  # 輸出層線性輸出
    def forward(self, x):      # 這同時(shí)也是 Module 中的 forward 功能
        # 正向傳播輸入值，神經(jīng)網(wǎng)絡(luò)分析輸出值
        x = F.relu(self.hidden(x))   # 激勵(lì)函數(shù)(隱藏層的線性值)
        x = self.predict(x)          # 輸出值
        return x

net = Net(n_feature=1, n_hidden=10, n_output=1)
print(net)   # 輸出 net 的結(jié)構(gòu)

# 訓(xùn)練網(wǎng)絡(luò)
optimizer = torch.optim.SGD(net.parameters(), lr = 0.2)  # 傳入 net 的所有參數(shù)，學(xué)習(xí)率
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()
'''

# 可視化訓(xùn)練過程
plt.ion()
for t in range(200):
    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, 'Lpss=%.4f'%loss.data.numpy(), fontdict={'size':20, 'color':'red'})
        plt.pause(0.1)
plt.ioff()
plt.show()

筆記：隱藏層數(shù)量設(shè)置巨大時(shí)，應(yīng)該調(diào)小學(xué)習(xí)率，增加迭代次數(shù)。并且當(dāng)隱藏層數(shù)量設(shè)置過大時(shí)，會(huì)發(fā)生震蕩...比如，n_hidden = 100, lr = 0.05。

2、區(qū)分類型 (分類)

import torch
import matplotlib.pyplot as plt
import torch.nn.functional as F
# 構(gòu)造假數(shù)據(jù)
n_data = torch.ones(100, 2)
x0 = torch.normal(2*n_data, 1)
y0 = torch.zeros(100)
x1 = torch.normal(-2*n_data, 1)
y1 = torch.ones(100)
# 注意 x y 的數(shù)據(jù)形式一定要像下面一樣，torch.cat 是在合并數(shù)據(jù)
x = torch.cat((x0, x1), 0).type(torch.FloatTensor)
y = torch.cat((y0, y1), ).type(torch.LongTensor)

class Net(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.output = torch.nn.Linear(n_hidden, n_output)
    def forward(self, x):
        x = F.relu(self.hidden(x))
        x = self.output(x)
        return x
net = Net(2, 10, 2)  # 幾個(gè)類別就有幾個(gè) output
print(net)

optimizer = torch.optim.SGD(net.parameters(), lr = 0.02)
loss_func = torch.nn.CrossEntropyLoss()
plt.ion()
plt.show()
for t in range(100):
    output = net(x)
    loss = loss_func(output, y)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    if t%2==0:
        plt.cla()
        # 過了一道 softmax 的激勵(lì)函數(shù)后的最大概率才是預(yù)測(cè)值
        prediction = torch.max(F.softmax(output), 1)[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()

3、快速搭建法

Torch 中提供了很多方便的途徑，同樣是神經(jīng)網(wǎng)絡(luò)，能快則快，我們看看如何用更簡單的方式搭建同樣的回歸神經(jīng)網(wǎng)絡(luò)。

import torch.nn.functional as F
import torch

# 用 class 繼承一個(gè) torch 的神經(jīng)網(wǎng)絡(luò)結(jié)構(gòu)，然后對(duì)其進(jìn)行修改
class Net(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.output = torch.nn.Linear(n_hidden, n_output)
    def forward(self, x):
        x = F.relu(self.hidden(x))
        x = self.output(x)
        return x
net1 = Net(1, 10, 1)
print(net1)

# 快速搭建法
net2 = torch.nn.Sequential(
    torch.nn.Linear(1, 10),
    torch.nn.ReLU(),
    torch.nn.Linear(10, 1)
)
print(net2)

發(fā)現(xiàn)net2多顯示了一些內(nèi)容，這是為什么呢? 原來把激勵(lì)函數(shù)也一同納入進(jìn)去了，但是net1中，激勵(lì)函數(shù)實(shí)際上是在 forward()功能中才被調(diào)用的。這也就說明了，相比net2，net1 的好處就是，可以根據(jù)個(gè)人需要更加個(gè)性化前向傳播過程，比如(RNN)。不過如果不需要七七八八的過程，相信 net2 這種形式更適合。

4、保存提取

import torch
import matplotlib.pyplot as plt
torch.manual_seed(2) # reproducible。為 cpu 設(shè)置隨機(jī)種子，保證每次產(chǎn)生的隨機(jī)數(shù)相同
# 假數(shù)據(jù)
x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim = 1)
y = x.pow(2) + 0.2*torch.rand(x.size())  # noisy y data (tensor)
# 保存網(wǎng)絡(luò)
def save():
    net1 = torch.nn.Sequential(
        torch.nn.Linear(1, 10),
        torch.nn.ReLU(),
        torch.nn.Linear(10, 1)
    )
    optimizer = torch.optim.SGD(net1.parameters(), lr=0.5)
    loss_func = torch.nn.MSELoss()

    for t in range(100):
        prediction = net1(x)
        loss = loss_func(prediction, y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    # 兩種保存方式，上面保存整個(gè)網(wǎng)絡(luò)，下面只保存網(wǎng)絡(luò)中的參數(shù)(速度快，占內(nèi)存少)
    torch.save(net1, 'net.pkl')
    torch.save(net1.state_dict(), 'net_params.pkl')
    # plot result
    plt.figure(1, figsize=(10, 3))
    plt.subplot(131)
    plt.title('Net1')
    plt.scatter(x.data.numpy(), y.data.numpy())
    plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)

# 提取整個(gè)網(wǎng)絡(luò)
def restore_net():
    net2 = torch.load('net.pkl')
    prediction = net2(x)
    # plot result
    plt.subplot(132)
    plt.title('Net2')
    plt.scatter(x.data.numpy(), y.data.numpy())
    plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
# 只提取網(wǎng)絡(luò)參數(shù)
def resotre_params():
    # 新建 net3 結(jié)構(gòu)
    net3 = torch.nn.Sequential(
        torch.nn.Linear(1, 10),
        torch.nn.ReLU(),
        torch.nn.Linear(10, 1)
    )
    # 將保存的參數(shù)復(fù)制到 net3
    net3.load_state_dict(torch.load('net_params.pkl'))
    prediction = net3(x)
    # plot result
    plt.subplot(133)
    plt.title('Net3')
    plt.scatter(x.data.numpy(), y.data.numpy())
    plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
    plt.show()

save()
restore_net()
resotre_params()

5、批訓(xùn)練 Mini-batch Training

Torch 中提供了一種幫你整理你的數(shù)據(jù)結(jié)構(gòu)的好東西, 叫做 DataLoader, 我們能用它來包裝自己的數(shù)據(jù), 進(jìn)行批訓(xùn)練.

import torch
import torch.utils.data as Data
torch.manual_seed(1)    # reproducible

BATCH_SIZE = 5      # 批訓(xùn)練的數(shù)據(jù)個(gè)數(shù)

x = torch.linspace(1, 10, 10)       # x data (torch tensor)
y = torch.linspace(10, 1, 10)       # y data (torch tensor)

# 先轉(zhuǎn)換成 torch 能識(shí)別的 Dataset
torch_dataset = Data.TensorDataset(data_tensor=x, target_tensor=y)

# 把 dataset 放入 DataLoader
loader = Data.DataLoader(
    dataset=torch_dataset,      # torch TensorDataset format
    batch_size=BATCH_SIZE,      # mini batch size
    shuffle=True,               # 要不要打亂數(shù)據(jù) (打亂比較好)
    num_workers=2,              # 多線程來讀數(shù)據(jù)
)

for epoch in range(3):   # 訓(xùn)練所有!整套!數(shù)據(jù) 3 次
    for step, (batch_x, batch_y) in enumerate(loader):  # 每一步 loader 釋放一小批數(shù)據(jù)用來學(xué)習(xí)
        # 假設(shè)這里就是你訓(xùn)練的地方...

        # 打出來一些數(shù)據(jù)
        print('Epoch: ', epoch, '| Step: ', step, '| batch x: ',
              batch_x.numpy(), '| batch y: ', batch_y.numpy())

"""
Epoch:  0 | Step:  0 | batch x:  [ 6.  7.  2.  3.  1.] | batch y:  [  5.   4.   9.   8.  10.]
Epoch:  0 | Step:  1 | batch x:  [  9.  10.   4.   8.   5.] | batch y:  [ 2.  1.  7.  3.  6.]
Epoch:  1 | Step:  0 | batch x:  [  3.   4.   2.   9.  10.] | batch y:  [ 8.  7.  9.  2.  1.]
Epoch:  1 | Step:  1 | batch x:  [ 1.  7.  8.  5.  6.] | batch y:  [ 10.   4.   3.   6.   5.]
Epoch:  2 | Step:  0 | batch x:  [ 3.  9.  2.  6.  7.] | batch y:  [ 8.  2.  9.  5.  4.]
Epoch:  2 | Step:  1 | batch x:  [ 10.   4.   8.   1.   5.] | batch y:  [  1.   7.   3.  10.   6.]
"""

6、加速神經(jīng)網(wǎng)絡(luò)訓(xùn)練 Speed Up Training

英文學(xué)習(xí)資料

越復(fù)雜的神經(jīng)網(wǎng)絡(luò) , 越多的數(shù)據(jù) , 我們需要在訓(xùn)練神經(jīng)網(wǎng)絡(luò)的過程上花費(fèi)的時(shí)間也就越多. 原因很簡單, 就是因?yàn)橛?jì)算量太大了. 可是往往有時(shí)候?yàn)榱私鉀Q復(fù)雜的問題, 復(fù)雜的結(jié)構(gòu)和大數(shù)據(jù)又是不能避免的, 所以我們需要尋找一些方法, 讓神經(jīng)網(wǎng)絡(luò)聰明起來, 快起來.

Stochastic Gradient Descent (SGD)
Momentum 更新方法
AdaGrad 更新方法
RMSprop 更新方法
Adam 更新方法

7、優(yōu)化器 Optimizer

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

torch.manual_seed(2)

LR = 0.01
BATCH_SIZE = 32
EPOCH = 12

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

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

class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.hidden = torch.nn.Linear(1, 20)
        self.predict = torch.nn.Linear(20, 1)
    def forward(self, x):
        x = F.relu(self.hidden(x))
        x = self.predict(x)
        return x

if __name__ == '__main__':
    # 不實(shí)用 Adagrad 是因?yàn)樗趯W(xué)習(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: ', epoch)
        for step, (batch_x, batch_y) in enumerate(loader):
            for net, opt, l_his in zip(nets, optimizers, losses_his):
                output = net(batch_x)
                loss = loss_func(output, batch_y)
                opt.zero_grad()
                loss.backward()
                opt.step()
                l_his.append(loss.data.numpy())

    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()

四、高級(jí)神經(jīng)網(wǎng)絡(luò)結(jié)構(gòu)

1、什么是卷積神經(jīng)網(wǎng)絡(luò) CNN

CNN 適合用于處理 圖像識(shí)別、語音識(shí)別 等的任務(wù)。

2、CNN

（待填坑 ing）

3、什么是循環(huán)神經(jīng)網(wǎng)絡(luò) RNN

加了記憶功能，適合用于 語言分析，序列化數(shù)據(jù) 的任務(wù)。

4、什么是 LSTM 循環(huán)神經(jīng)網(wǎng)絡(luò)

LSTM 網(wǎng)絡(luò)是在，RNN 的結(jié)構(gòu)上加入了三個(gè)控制：輸入控制，忘記控制，輸出控制。其中忘記控制會(huì)控制將過去很久的記憶按比例更新成最新記憶。

5、RNN (分類)

6、RNN (回歸)

7、什么是自編碼 Autoencoder

8、Autoencoder 自編碼/非監(jiān)督學(xué)習(xí)

9、什么是 DQN

10、DQN 強(qiáng)化學(xué)習(xí)

11、什么是生成對(duì)抗網(wǎng)絡(luò) GAN

12、GAN

五、高階內(nèi)容

1、為什么 Torch 是動(dòng)態(tài)的

2、GPU 加速運(yùn)算

3、什么是過擬合

4、Dropout 緩解過擬合

5、什么是批標(biāo)準(zhǔn)化

6、Batch Normalization