PyTorch零基礎(chǔ)入門之構(gòu)建模型基礎(chǔ)
一、神經(jīng)網(wǎng)絡(luò)的構(gòu)造
- PyTorch中神經(jīng)網(wǎng)絡(luò)構(gòu)造一般是基于
Module類的模型來完成的，它讓模型構(gòu)造更加靈活。Module類是nn模塊里提供的一個模型構(gòu)造類，是所有神經(jīng)網(wǎng)絡(luò)模塊的基類，我們可以繼承它來定義我們想要的模型。 - 下面繼承
Module類構(gòu)造多層感知機(jī)。這里定義的 MLP 類重載了Module類的init函數(shù)和forward函數(shù)。它們分別用于創(chuàng)建模型參數(shù)和定義前向計(jì)算。前向計(jì)算也即正向傳播。
# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 09:43:21 2021
@author: 86493
"""
import torch
from torch import nn
class MLP(nn.Module):
# 聲明帶有模型參數(shù)的層，此處聲明了2個全連接層
def __init__(self, **kwargs):
# 調(diào)用MLP父類Block的構(gòu)造函數(shù)來進(jìn)行必要的初始化
# 這樣在構(gòu)造實(shí)例時還可以指定其他函數(shù)
super(MLP, self).__init__(**kwargs)
self.hidden = nn.Linear(784, 256)
self.act = nn.ReLU()
self.output = nn.Linear(256, 10)
# 定義模型的前向計(jì)算
# 即如何根據(jù)輸入x計(jì)算返回所需要的模型輸出
def forward(self, x):
o = self.act(self.hidden(x))
return self.output(o)
X = torch.rand(2, 784)
net = MLP()
print(net)
print('-' * 60)
print(net(X))
結(jié)果為：
MLP(
(hidden): Linear(in_features=784, out_features=256, bias=True)
(act): ReLU()
(output): Linear(in_features=256, out_features=10, bias=True)
)
------------------------------------------------------------
tensor([[ 0.1836, 0.1946, 0.0924, -0.1163, -0.2914, -0.1103, -0.0839, -0.1274,
0.1618, -0.0601],
[ 0.0738, 0.2369, 0.0225, -0.1514, -0.3787, -0.0551, -0.0836, -0.0496,
0.1481, 0.0139]], grad_fn=<AddmmBackward>)
注意：
（1）上面的MLP類不需要定義反向傳播函數(shù)，系統(tǒng)將通過自動求梯度而自動生成反向傳播所需的backward函數(shù)。
（2）將數(shù)據(jù)X傳入實(shí)例化MLP類后得到的net對象，會做一次前向計(jì)算，并且net(X)會調(diào)用MLP類繼承自父類Module的call函數(shù)——該函數(shù)調(diào)用我們定義的子類MLP的forward函數(shù)完成前向傳播計(jì)算。
（3）這里沒將Module類命名為Layer（層）或者M(jìn)odel（模型）等，是因?yàn)樵擃愂且粋€可供自由組建的部件， 它的子類既可以是一個層（如繼承父類nn的子類線性層Linear），也可以是一個模型（如此處的子類MLP），也可以是模型的一部分。
二、神經(jīng)網(wǎng)絡(luò)中常見的層
有全連接層、卷積層、池化層與循環(huán)層等，下面學(xué)習(xí)使用Module定義層。
2.1 不含模型參數(shù)的層
下面構(gòu)造的 MyLayer 類通過繼承 Module 類自定義了一個將輸入減掉均值后輸出的層，并將層的計(jì)算定義在了 forward 函數(shù)里。這個層里不含模型參數(shù)。
# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 10:19:59 2021
@author: 86493
"""
import torch
from torch import nn
class MyLayer(nn.Module):
def __init__(self, **kwargs):
# 調(diào)用父類的方法
super(MyLayer, self).__init__(**kwargs)
def forward(self, x):
return x - x.mean()
# 測試，實(shí)例化該層，做前向計(jì)算
layer = MyLayer()
layer1 = layer(torch.tensor([1, 2, 3, 4, 5],
dtype = torch.float))
print(layer1)
結(jié)果為：
tensor([-2., -1., 0., 1., 2.])
2.2 含模型參數(shù)的層
可以自定義含模型參數(shù)的自定義層。其中的模型參數(shù)可以通過訓(xùn)練學(xué)出。
Parameter 類其實(shí)是 Tensor 的子類，如果一個 Tensor 是 Parameter ，那么它會自動被添加到模型的參數(shù)列表里。所以在自定義含模型參數(shù)的層時，我們應(yīng)該將參數(shù)定義成 Parameter ，除了直接定義成 Parameter 類外，還可以使用 ParameterList 和 ParameterDict 分別定義參數(shù)的列表和字典。
PS：下面出現(xiàn)torch.mm是將兩個矩陣相乘，如
# -*- coding: utf-8 -*- """ Created on Sat Oct 16 10:56:03 2021 @author: 86493 """ import torch a = torch.randn(2, 3) b = torch.randn(3, 2) print(torch.mm(a, b)) # 效果相同 print(torch.matmul(a, b)) #tensor([[1.8368, 0.4065], # [2.7972, 2.3096]]) #tensor([[1.8368, 0.4065], # [2.7972, 2.3096]])
（1）代碼栗子1
# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 10:33:04 2021
@author: 86493
"""
import torch
from torch import nn
class MyListDense(nn.Module):
def __init__(self):
super(MyListDense, self).__init__()
# 3個randn的意思
self.params = nn.ParameterList([nn.Parameter(torch.randn(4, 4)) for i in range(3)])
self.params.append(nn.Parameter(torch.randn(4, 1)))
def forward(self, x):
for i in range(len(self.params)):
# mm是指矩陣相乘
x = torch.mm(x, self.params[i])
return x
net = MyListDense()
print(net)
打印得：
MyListDense(
(params): ParameterList(
(0): Parameter containing: [torch.FloatTensor of size 4x4]
(1): Parameter containing: [torch.FloatTensor of size 4x4]
(2): Parameter containing: [torch.FloatTensor of size 4x4]
(3): Parameter containing: [torch.FloatTensor of size 4x1]
)
)
（2）代碼栗子2
這回用變量字典：
# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 11:03:29 2021
@author: 86493
"""
import torch
from torch import nn
class MyDictDense(nn.Module):
def __init__(self):
super(MyDictDense, self).__init__()
self.params = nn.ParameterDict({
'linear1': nn.Parameter(torch.randn(4, 4)),
'linear2': nn.Parameter(torch.randn(4, 1))
})
# 新增
self.params.update({'linear3':
nn.Parameter(torch.randn(4, 2))})
def forward(self, x, choice = 'linear1'):
return torch.mm(x, self.params[choice])
net = MyDictDense()
print(net)
打印得：
MyDictDense(
(params): ParameterDict(
(linear1): Parameter containing: [torch.FloatTensor of size 4x4]
(linear2): Parameter containing: [torch.FloatTensor of size 4x1]
(linear3): Parameter containing: [torch.FloatTensor of size 4x2]
)
)
2.3 二維卷積層
二維卷積層將輸入和卷積核做互相關(guān)運(yùn)算，并加上一個標(biāo)量偏差來得到輸出。卷積層的模型參數(shù)包括了卷積核和標(biāo)量偏差。在訓(xùn)練模型的時候，通常我們先對卷積核隨機(jī)初始化，然后不斷迭代卷積核和偏差。
卷積窗口形狀為 p × q p \times q p×q 的卷積層稱為 p × q p \times q p×q 卷積層。同樣， p × q p \times q p×q 卷積或 p × q p \times q p×q 卷積核說明卷積核的高和寬分別為 p p p 和 q q q。
（1）填充可以增加輸出的高和寬。這常用來使輸出與輸入具有相同的高和寬。
（2）步幅可以減小輸出的高和寬，例如輸出的高和寬僅為輸⼊入的高和寬的 ( 為大于1的整數(shù))。
# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 11:20:57 2021
@author: 86493
"""
import torch
from torch import nn
# 卷積運(yùn)算(二維互相關(guān))
def corr2d(X, K):
h, w = K.shape
X, K = X.float(), K.float()
Y = torch.zeros((X.shape[0] - h + 1, X.shape[1] - w + 1))
for i in range(Y.shape[0]):
for j in range(Y.shape[1]):
Y[i, j] = (x[i: i + h, j: j + w] * K).sum()
return Y
# 二維卷積層
class Conv2D(nn.Module):
def __init__(self, kernel_size):
super(Conv2D, self).__init__()
self.weight = nn.Parameter(torch.randn(kernel_size))
self.bias = nn.Parameter(torch.randn(1))
def forward(self, x):
return corr2d(x, self.weight) + self.bias
conv2d = nn.Conv2d(in_channels = 1,
out_channels = 1,
kernel_size = 3,
padding = 1)
print(conv2d)
得：
Conv2d(1, 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
填充(padding)是指在輸入高和寬的兩側(cè)填充元素(通常是0元素)。
下個栗子：創(chuàng)建一個高和寬為3的二維卷積層，設(shè)輸入高和寬兩側(cè)的填充數(shù)分別為1。給定一高和寬都為8的input，輸出的高和寬會也是8。
# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 11:54:29 2021
@author: 86493
"""
import torch
from torch import nn
# 定義一個函數(shù)計(jì)算卷積層
# 對輸入和輸出左對應(yīng)的升維和降維
def comp_conv2d(conv2d, X):
# (1, 1)代表批量大小和通道數(shù)
X = X.view((1, 1) + X.shape)
Y = conv2d(X)
# 排除不關(guān)心的前2維：批量和通道
return Y.view(Y.shape[2:])
# 注意這里是兩側(cè)分別填充1行或列，所以在兩側(cè)共填充2行或列
conv2d = nn.Conv2d(in_channels = 1,
out_channels = 1,
kernel_size = 3,
padding = 1)
X = torch.rand(8, 8)
endshape = comp_conv2d(conv2d, X).shape
print(endshape)
# 使用高為5，寬為3的卷積核，在高和寬兩側(cè)填充數(shù)為2和1
conv2d = nn.Conv2d(in_channels = 1,
out_channels = 1,
kernel_size = (5, 3),
padding = (2, 1))
endshape2 = comp_conv2d(conv2d, X).shape
print(endshape2)
結(jié)果為：
torch.Size([8, 8])
torch.Size([8, 8])
stride
在二維互相關(guān)運(yùn)算中，卷積窗口從輸入數(shù)組的最左上方開始，按從左往右、從上往下 的順序，依次在輸⼊數(shù)組上滑動。我們將每次滑動的行數(shù)和列數(shù)稱為步幅(stride)。
# 步幅stride
conv2d = nn.Conv2d(in_channels = 1,
out_channels = 1,
kernel_size = (3, 5),
padding = (0, 1),
stride = (3, 4))
endshape3 = comp_conv2d(conv2d, X).shape
print(endshape3)
# torch.Size([2, 2])
2.4 池化層
- 池化層每次對輸入數(shù)據(jù)的一個固定形狀窗口(又稱池化窗口)中的元素計(jì)算輸出。不同于卷積層里計(jì)算輸入和核的互相關(guān)性，池化層直接計(jì)算池化窗口內(nèi)元素的最大值或者平均值。該運(yùn)算也 分別叫做最大池化或平均池化。
- 在二維最大池化中，池化窗口從輸入數(shù)組的最左上方開始，按從左往右、從上往下的順序，依次在輸入數(shù)組上滑動。當(dāng)池化窗口滑動到某⼀位置時，窗口中的輸入子數(shù)組的最大值即輸出數(shù)組中相應(yīng)位置的元素。
下面把池化層的前向計(jì)算實(shí)現(xiàn)在pool2d函數(shù)里。
最大池化：
# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 18:49:27 2021
@author: 86493
"""
import torch
from torch import nn
def pool2d(x, pool_size, mode = 'max'):
p_h, p_w = pool_size
Y = torch.zeros((X.shape[0] - p_h + 1, X.shape[1] - p_w + 1))
for i in range(Y.shape[0]):
for j in range(Y.shape[1]):
if mode == 'max':
Y[i, j] = X[i: i + p_h, j: j + p_w].max()
elif mode == 'avg':
Y[i, j] = X[i: i + p_h, j: j + p_w].mean()
return Y
X = torch.Tensor([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
end = pool2d(X, (2, 2)) # 默認(rèn)是最大池化
# end = pool2d(X, (2, 2), mode = 'avg')
print(end)
tensor([[4., 5.],
[7., 8.]])
平均池化：
# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 18:49:27 2021
@author: 86493
"""
import torch
from torch import nn
def pool2d(x, pool_size, mode = 'max'):
p_h, p_w = pool_size
Y = torch.zeros((X.shape[0] - p_h + 1, X.shape[1] - p_w + 1))
for i in range(Y.shape[0]):
for j in range(Y.shape[1]):
if mode == 'max':
Y[i, j] = X[i: i + p_h, j: j + p_w].max()
elif mode == 'avg':
Y[i, j] = X[i: i + p_h, j: j + p_w].mean()
return Y
X = torch.FloatTensor([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
# end = pool2d(X, (2, 2)) # 默認(rèn)是最大池化
end = pool2d(X, (2, 2), mode = 'avg')
print(end)
結(jié)果如下，注意上面如果mode是avg模式（平均池化）時，不能寫X = torch.tensor([[0, 1, 2], [3, 4, 5], [6, 7, 8]])，否則會報(bào)錯Can only calculate the mean of floating types. Got Long instead.。把tensor改成Tensor或FloatTensor后就可以了（Tensor是FloatTensor的縮寫）。
tensor([[2., 3.],
[5., 6.]])
三、LeNet模型栗子
一個神經(jīng)網(wǎng)絡(luò)的典型訓(xùn)練過程如下：
1 定義包含一些可學(xué)習(xí)參數(shù)(或者叫權(quán)重）的神經(jīng)網(wǎng)絡(luò)
2. 在輸入數(shù)據(jù)集上迭代
3. 通過網(wǎng)絡(luò)處理輸入
4. 計(jì)算 loss (輸出和正確答案的距離）
5. 將梯度反向傳播給網(wǎng)絡(luò)的參數(shù)
6. 更新網(wǎng)絡(luò)的權(quán)重，一般使用一個簡單的規(guī)則：weight = weight - learning_rate * gradient
# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 19:21:19 2021
@author: 86493
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
class LeNet(nn.Module):
# 需要把網(wǎng)絡(luò)中具有可學(xué)習(xí)參數(shù)的層放在構(gòu)造函數(shù)__init__
def __init__(self):
super(LeNet, self).__init__()
# 輸入圖像channel：1；輸出channel：6
# 5*5卷積核
self.conv1 = nn.Conv2d(1, 6, 5)
self.conv2 = nn.Conv2d(6, 16, 5)
# an affine operation:y = Wx + b
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
# 2 * 2 最大池化
x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
# 如果是方陣，則可以只使用一個數(shù)字進(jìn)行定義
x = F.max_pool2d(F.relu(self.conv2(x)), 2)
# 做一次flatten
x = x.view(-1, self.num_flat_features(x))
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
def num_flat_features(self, x):
# 除去批處理維度,得到其他所有維度
size = x.size()[1:]
num_features = 1
# 將剛才得到的維度之間相乘起來
for s in size:
num_features *= s
return num_features
net = LeNet()
print(net)
# 一個模型的可學(xué)習(xí)參數(shù)可以通過`net.parameters()`返回
params = list(net.parameters())
print("params的len:", len(params))
# print("params:\n", params)
print(params[0].size()) # conv1的權(quán)重
print('-' * 60)
# 隨機(jī)一個32×32的input
input = torch.randn(1, 1, 32, 32)
out = net(input)
print("網(wǎng)絡(luò)的output為：", out)
print('-' * 60)
# 隨機(jī)梯度的反向傳播
net.zero_grad() # 清零所有參數(shù)的梯度緩存
end = out.backward(torch.randn(1, 10))
print(end) # None
print的結(jié)果為：
LeNet(
(conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
(conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
(fc1): Linear(in_features=400, out_features=120, bias=True)
(fc2): Linear(in_features=120, out_features=84, bias=True)
(fc3): Linear(in_features=84, out_features=10, bias=True)
)
params的len: 10
torch.Size([6, 1, 5, 5])
------------------------------------------------------------
網(wǎng)絡(luò)的output為： tensor([[ 0.0904, 0.0866, 0.0851, -0.0176, 0.0198, 0.0530, 0.0815, 0.0284,
-0.0216, -0.0425]], grad_fn=<AddmmBackward>)
------------------------------------------------------------
None
三點(diǎn)提醒：
（1）只需要定義 forward 函數(shù)，backward函數(shù)會在使用autograd時自動定義，backward函數(shù)用來計(jì)算導(dǎo)數(shù)。我們可以在 forward 函數(shù)中使用任何針對張量的操作和計(jì)算。
（2）在backward前最好net.zero_grad()，即清零所有參數(shù)的梯度緩存。
（3）torch.nn只支持小批量處理 (mini-batches）。整個 torch.nn 包只支持小批量樣本的輸入，不支持單個樣本的輸入。比如，nn.Conv2d 接受一個4維的張量，即nSamples x nChannels x Height x Width如果是一個單獨(dú)的樣本，只需要使用input.unsqueeze(0) 來添加一個“假的”批大小維度。
torch.Tensor：一個多維數(shù)組，支持諸如backward()等的自動求導(dǎo)操作，同時也保存了張量的梯度。nn.Module：神經(jīng)網(wǎng)絡(luò)模塊。是一種方便封裝參數(shù)的方式，具有將參數(shù)移動到GPU、導(dǎo)出、加載等功能。nn.Parameter：張量的一種，當(dāng)它作為一個屬性分配給一個Module時，它會被自動注冊為一個參數(shù)。autograd.Function：實(shí)現(xiàn)了自動求導(dǎo)前向和反向傳播的定義，每個Tensor至少創(chuàng)建一個Function節(jié)點(diǎn)，該節(jié)點(diǎn)連接到創(chuàng)建Tensor的函數(shù)并對其歷史進(jìn)行編碼。
四、AlexNet模型栗子
# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 21:00:39 2021
@author: 86493
"""
import torch
from torch import nn
class AlexNet(nn.Module):
def __init__(self):
super(AlexNet, self).__init__()
self.conv = nn.Sequential(
# in_channels,out_channels,kernel_size,stride,padding
nn.Conv2d(1, 96, 11, 4),
nn.ReLU(),
# kernel_size, stride
nn.MaxPool2d(3, 2),
# 見笑卷積窗口，但使用padding=2來使輸入和輸出的高寬相同
# 且增大輸出通道數(shù)
nn.Conv2d(96, 256, 5, 1, 2),
nn.ReLU(),
nn.MaxPool2d(3, 2),
# 連續(xù)3個卷積層，且后面使用更小的卷積窗口
# 除了最后的卷積層外，進(jìn)一步增大了輸出
# 注:前2個卷積層后不使用池化層來減少輸入的高和寬
nn.Conv2d(256, 384, 3, 1, 1),
nn.ReLU(),
nn.Conv2d(384, 383, 3, 1, 1),
nn.ReLU(),
nn.Conv2d(384, 256, 3, 1, 1),
nn.ReLU(),
nn.MaxPool2d(3, 2)
)
# 這里的全連接層的輸出個數(shù)比LeNet中的大數(shù)倍。
# 使用丟棄層來緩解過擬合
self.fc = nn.Sequential(
nn.Linear(256 *5 * 5, 4096),
nn.ReLU(),
nn.Dropout(0.5),
nn.Linear(4096, 4086),
nn.ReLU(),
nn.Dropout(0.5),
# 輸出層，下次會用到Fash-MNIST，所以此處類別設(shè)為10,
# 而非論文中的1000
nn.Linear(4096, 10),
)
def forward(self, img):
feature = self.conv(img)
output = self.fc(feature.view(img.shape[0], -1))
return output
net = AlexNet()
print(net)
可以看到該網(wǎng)絡(luò)的結(jié)構(gòu)：
AlexNet(
(conv): Sequential(
(0): Conv2d(1, 96, kernel_size=(11, 11), stride=(4, 4))
(1): ReLU()
(2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
(3): Conv2d(96, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
(4): ReLU()
(5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
(6): Conv2d(256, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(7): ReLU()
(8): Conv2d(384, 383, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(9): ReLU()
(10): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(11): ReLU()
(12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
)
(fc): Sequential(
(0): Linear(in_features=6400, out_features=4096, bias=True)
(1): ReLU()
(2): Dropout(p=0.5, inplace=False)
(3): Linear(in_features=4096, out_features=4086, bias=True)
(4): ReLU()
(5): Dropout(p=0.5, inplace=False)
(6): Linear(in_features=4096, out_features=10, bias=True)
)
)
Reference
（1）官方文檔：https://pytorch.org/docs/stable/_modules/torch/nn/modules/conv.html#Conv2d
（2）datawhale notebook
到此這篇關(guān)于PyTorch零基礎(chǔ)入門之構(gòu)建模型基礎(chǔ)的文章就介紹到這了,更多相關(guān)PyTorch 構(gòu)建模型基礎(chǔ)內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
Python實(shí)現(xiàn)查看系統(tǒng)啟動項(xiàng)功能示例
這篇文章主要介紹了Python實(shí)現(xiàn)查看系統(tǒng)啟動項(xiàng)功能,涉及Python針對系統(tǒng)注冊表啟動項(xiàng)的相關(guān)讀取操作實(shí)現(xiàn)技巧,需要的朋友可以參考下2018-05-05
Python強(qiáng)大郵件處理庫Imbox安裝及用法示例
這篇文章主要給大家介紹了關(guān)于Python強(qiáng)大郵件處理庫Imbox安裝及用法的相關(guān)資料,Imbox是一個Python 庫,用于從IMAP郵箱中讀取郵件,它提供了簡單易用的接口,幫助開發(fā)者處理郵件,需要的朋友可以參考下2024-03-03
python3文件復(fù)制、延遲文件復(fù)制任務(wù)的實(shí)現(xiàn)方法
這篇文章主要給大家介紹了關(guān)于python3文件復(fù)制、延遲文件復(fù)制任務(wù)的實(shí)現(xiàn)方法，文中通過示例代碼介紹的非常詳細(xì)，對大家學(xué)習(xí)或者使用python3具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面來一起學(xué)習(xí)學(xué)習(xí)吧2019-09-09
python實(shí)現(xiàn)字符串和字典的轉(zhuǎn)換
這篇文章主要為大家詳細(xì)介紹了python實(shí)現(xiàn)字符串和字典的轉(zhuǎn)換，具有一定的參考價(jià)值，感興趣的小伙伴們可以參考一下2018-09-09
使用PyTorch將數(shù)據(jù)從CPU移動到GPU的四個方法
這篇文章給大家介紹了在 PyTorch 中,將數(shù)據(jù)從 CPU 移動到 GPU 的幾種方法,使用 .to() 方法,使用 .cuda() 方法,使用 torch.Tensor 構(gòu)造函數(shù)和使用 torch.tensor 構(gòu)造函數(shù)這四個方法,通過代碼示例介紹非常詳細(xì),需要的朋友可以參考下2024-01-01
python flask實(shí)現(xiàn)分頁的示例代碼
這篇文章主要介紹了python flask實(shí)現(xiàn)分頁的示例代碼，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2018-08-08
python導(dǎo)出requirements.txt的幾種方法以及環(huán)境配置詳細(xì)流程
這篇文章主要給大家介紹了關(guān)于python導(dǎo)出requirements.txt的幾種方法以及環(huán)境配置詳細(xì)流程,requirements.txt 文件是一個文本文件,用于列出你的Python項(xiàng)目所依賴的軟件包及其版本,需要的朋友可以參考下2023-11-11
這篇文章主要介紹了Python httplib模塊使用實(shí)例,httplib模塊是一個底層基礎(chǔ)模塊,本文講解了httplib模塊的常用方法及使用實(shí)例,需要的朋友可以參考下2015-04-04
這篇文章主要介紹了深入了解Python iter() 方法的知識,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友可以參考下2019-07-07
PyTorch中clone()、detach()及相關(guān)擴(kuò)展詳解
這篇文章主要給大家介紹了關(guān)于PyTorch中clone()、detach()及相關(guān)擴(kuò)展的相關(guān)資料，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2020-12-12