“”"
-------------------torch 函數詳解----------------------------
“”"

import numpy as np import torch from torch.autograd import Variable from torch import nn import matplotlib.pyplot as plt

“”“1.torch.is_tensor(x):如果obj 是一個pytorch張量，則返回True”""

x = torch.Tensor(2,3,4) #新建一個pytorch張量 torch.is_tensor(x) print('result:', torch.is_tensor(x))輸出結果：result: True

“”“2.torch.is_storage(x):如何x 是一個pytorch storage對象，則返回True”""

print(torch.is_storage(x)) 輸出結果：False

“”“3.torch.numel:返回x 張量中的元素個數”""

print(torch.numel(x)) 輸出結果：24

“”“4.torch.eye(n, m=None, out=None):返回一個2維張量，對角線位置全1，其它位置全0"”"

y = torch.eye(3) print(y) 輸出結果： tensor([[1., 0., 0.],[0., 1., 0.],[0., 0., 1.]])

“”“5.torch.from_numpy(ndarray):Numpy橋，將numpy.ndarray 轉換為pytorch的 Tensor。
返回的張量tensor和numpy的ndarray共享同一內存空間。修改一個會導致另外一個也被修改。返回的張量不能改變大小”""

a = np.array([1,2,3]) t = torch.from_numpy(a) print(t) 輸出結果：tensor([1, 2, 3], dtype=torch.int32)

“”“6.torch.linspace:返回一個1維張量，包含在區間start 和 end 上均勻間隔的steps個點。 輸出1維張量的長度為steps
start (float) – 序列的起始點
end (float) – 序列的最終值
steps (int) – 在start 和 end間生成的樣本數
out (Tensor, optional) – 結果張量
“””

print(torch.linspace(3, 10, steps=5)) 輸出：tensor([ 3.0000, 4.7500, 6.5000, 8.2500, 10.0000])

“”“7.torch.logspace(start, end, steps=100, out=None):返回一個1維張量，包含在區間 10^start和 10^end上以對數刻度均勻間隔的steps個點。
輸出1維張量的長度為steps
start (float) – 序列的起始點
end (float) – 序列的最終值
steps (int) – 在start 和 end間生成的樣本數
out (Tensor, optional) – 結果張量
“””

print(torch.logspace(start=-10, end=10, steps=5)) 輸出：tensor([1.0000e-10, 1.0000e-05, 1.0000e+00, 1.0000e+05, 1.0000e+10])

“”“8.torch.ones(*sizes, out=None):返回一個全為1 的張量，形狀由可變參數sizes定義。
sizes (int…) – 整數序列，定義了輸出形狀
out (Tensor, optional) – 結果張量 例子:
“””

print(torch.ones(2, 3)) 輸出結果：tensor([[1., 1., 1.],[1., 1., 1.]])

“”“9.torch.rand(*sizes, out=None):返回一個張量，包含了從區間[0,1)的均勻分布中抽取的一組隨機數，形狀由可變參數sizes 定義。
sizes (int…) – 整數序列，定義了輸出形狀
out (Tensor, optinal) - 結果張量 例子：
“””

print(torch.rand(3)) 輸出結果：tensor([0.1480, 0.2517, 0.1265])

“”“10.torch.randn:返回一個張量，包含了從標準正態分布(均值為0，方差為 1，即高斯白噪聲)中抽取一組隨機數，形狀由可變參數sizes定義”""

print("torch.randn: ", torch.randn(3)) 輸出結果：torch.randn: tensor([1.2205, 0.2615, 0.4777])

“”“11.torch.randperm:給定參數n，返回一個從0 到 n - 1 的隨機整數排列”""

print(torch.randperm(3)) 輸出結果： tensor([2, 0, 1])

“”“12.torch.arange:返回一個1維張量，長度為 floor((end?start)/step)。包含從start到end，以step為步長的一組序列值(默認步長為1)。
參數:
start (float) – 序列的起始點
end (float) – 序列的終止點
step (float) – 相鄰點的間隔大小
out (Tensor, optional) – 結果張量”""

print("torch.arange: ", torch.arange(1, 5, 1, out = x)) print("x: ", x) 輸出結果：torch.arange: tensor([1., 2., 3., 4.])x: tensor([1., 2., 3., 4.])

“”"13.torch.range：返回一個1維張量，有 floor((end?start)/step)+1 個元素。包含在半開區間[start, end）
從start開始，以step為步長的一組值。 step 是兩個值之間的間隔，即 xi+1=xi+stepxi+1=xi+step

警告：建議使用函數 torch.arange()

參數:
start (float) – 序列的起始點
end (float) – 序列的最終值
step (int) – 相鄰點的間隔大小
out (Tensor, optional) – 結果張量"""

print("torch.range: ", torch.range(1.3, 5.6)) 輸出結果：torch.range: tensor([1.3000, 2.3000, 3.3000, 4.3000, 5.3000])

“”"14.torch.zeros:返回一個全為標量 0 的張量，形狀由可變參數sizes 定義。

參數:
sizes (int…) – 整數序列，定義了輸出形狀
out (Tensor, optional) – 結果張量"""

print("torch.zeros: ", torch.zeros(5)) 輸出結果：torch.zeros: tensor([0., 0., 0., 0., 0.])

“”"15.torch.max：返回輸入張量所有元素的最大值。
a.參數:input (Tensor) – 輸入張量

b.參數:
input (Tensor) – 輸入張量
dim (int) – 指定的維度
max (Tensor, optional) – 結果張量，包含給定維度上的最大值
max_indices (LongTensor, optional) – 結果張量，包含給定維度上每個最大值的位置索引

c.參數:
input (Tensor) – 輸入張量
other (Tensor) – 輸出張量
out (Tensor, optional) – 結果張量
“”"

aa = torch.randn(5) print(aa) print("torch.max111: ", torch.max(aa)) 輸出結果:tensor([ 0.4969, -0.1609, -1.3744, -0.6532, 1.2244])torch.max111: tensor(1.2244)

“”“dim=1 :取矩陣的每一行最大的值 組成一個1維矩陣。dim的值必須小于aa1的維度，比如：如果aa1是2維矩陣那么dim得小于2， aaa1為3為矩陣 dim的值得小于3
dim > 1 :取矩陣的每一列最大的值 組成一個矩陣
“””

aa2 = torch.randn(3, 4) print(aa2) print("torch.max222: ", torch.max(aa2, dim=1)) 輸出結果：tensor([[ 1.4783, 1.5988, 0.6321, -0.8419],[-1.6461, 1.4878, 0.9888, -0.2271],[ 0.6326, 0.1875, 0.6437, -0.9330]])torch.max222: torch.return_types.max(values=tensor([1.5988, 1.4878, 0.6437]),indices=tensor([1, 1, 2]))aa1 = torch.randn(2, 5, 6) print(aa1) 輸出結果：tensor([[[ 0.4342, 2.1148, -0.5727, -0.1438, -1.2496, 0.5915],[-0.6340, -0.5718, 0.7919, -0.5353, 0.0998, -1.6941],[-0.4791, -0.3789, 1.8555, 1.3287, 0.5841, -0.4429],[-1.3211, 1.2741, -1.7600, 0.2985, -1.0295, 1.2520],[ 0.9671, -0.5196, -0.7857, -0.0560, 0.2304, 0.2697]],[[-1.0855, -0.6774, 0.5850, 0.2507, -0.4710, 1.1073],[-0.2189, -0.2839, -1.2439, 1.2105, -0.6102, -0.3298],[-0.4399, -0.3557, -0.7534, 0.4810, -1.2203, 0.7078],[-0.6699, 2.0302, -1.3209, 0.0196, 1.5503, 0.5045],[-0.7213, -0.0689, -0.4742, 2.1822, -1.0017, 1.5620]]])ddww,dede = torch.max(aa1, dim=2) print("torch.max333: ", ddww, "rfrfrf: ", dede) 輸出結果：torch.max333: tensor([[2.1148, 0.7919, 1.8555, 1.2741, 0.9671],[1.1073, 1.2105, 0.7078, 2.0302, 2.1822]]) rfrfrf: tensor([[1, 2, 2, 1, 0],[5, 3, 5, 1, 3]])

#aa2和bbb2個一維矩陣沒一個元素對比 輸出大的元素 一維矩陣

aa2 = torch.randn(5) bbb = torch.randn(5) print("aa2: ", aa2) print("bbb: ", bbb) print("torch.max2: ", torch.max(aa2, bbb)) 輸出結果：aa2: tensor([ 1.5293, 0.8364, -0.0355, 1.4288, 0.6854])bbb: tensor([-0.7501, 0.0315, 0.0835, -1.1763, 0.0222])torch.max2: tensor([1.5293, 0.8364, 0.0835, 1.4288, 0.6854])

“”"16. torch.squeeze:將輸入張量形狀中的1 去除并返回。 如果輸入是形如(A×1×B×1×C×1×D)，那么輸出形狀就為： (A×B×C×D)
當給定dim時，那么擠壓操作只在給定維度上。例如，輸入形狀為: (A×1×B), squeeze(input, 0) 將會保持張量不變，
只有用 squeeze(input, 1)，形狀會變成 (A×B)。

注意： 返回張量與輸入張量共享內存，所以改變其中一個的內容會改變另一個。

參數:
input (Tensor) – 輸入張量
dim (int, optional) – 如果給定，則input只會在給定維度擠壓
out (Tensor, optional) – 輸出張量"""

x1 = torch.zeros(2, 1, 2, 1, 3) print("squeeze: ", torch.squeeze(x1).size()) #去掉所有的1 print("squeeze1: ", torch.squeeze(x1, 1).size()) #去掉第一個1 輸出結果：squeeze: torch.Size([2, 2, 3])squeeze1: torch.Size([2, 2, 1, 3])

“”"17.MSELoss(size_average=None, reduce=None, reduction=‘mean’):很多的 loss 函數都有 size_average 和 reduce 兩個布爾類型的參數。因為一般損失函數都是直接計算 batch 的數據，因此返回的 loss 結果都是維度為 (batch_size, ) 的向量。

(1)如果 reduce = False，那么 size_average 參數失效，直接返回向量形式的 loss
(2)如果 reduce = True，那么 loss 返回的是標量:
a)如果 size_average = True，返回 loss.mean();
b)如果 size_average = False，返回 loss.sum();

注意：默認情況下， reduce = True，size_average = True
“”"

a=np.array([[1,2],[3,6]]) b=np.array([[2,3],[8,5]])#返回向量 loss_fn = nn.MSELoss(size_average=False, reduce=False)#一般要求用nn.MSELoss(reduction='none') input = Variable(torch.from_numpy(a)) target = Variable(torch.from_numpy(b)) loss = loss_fn(input.float(), target.float()) print("loss: ", loss) 輸出結果：loss: tensor([[ 1., 1.],[25., 1.]])結果怎么算的？（2-1）的平方，（3-2）的平方，（8-3）的平方，（5-6）的平方即對應位置的差的平方值。print("---------------------------------------") #返回平局值 loss_fn1 = nn.MSELoss(size_average=True, reduce=True)#一般要求nn.MSELoss(reduction='mean')這樣寫 input = Variable(torch.from_numpy(a)) target = Variable(torch.from_numpy(b)) loss = loss_fn1(input.float(), target.float()) print("loss: ", loss) 輸出結果為：loss: tensor(7.) 怎么來的？上面算的（1+1+25+1）/4得到的

“”“18. item(): 一個tensor如果想要轉換為標準的python對象數值，需要調用tensor.item()，這個方法只對包含一個元素的tensor適用.
實際就是講張量轉為數字，如下：
如果超過1個元素 必報錯。
“””

x_train = np.array([[3.3]]) z1 = torch.from_numpy(x_train) print("21212: ", z1.item()) 輸出結果：21212: 3.3

“”"19. plot() :畫圖
plot函數的一般的調用形式：
#單條線：
plot([x], y, [fmt], data=None, **kwargs)
#多條線一起畫
plot([x], y, [fmt], [x2], y2, [fmt2], …, **kwargs)
可選參數[fmt] 是一個字符串來定義圖的基本屬性如：顏色（color），點型（marker），線型（linestyle），

具體形式 fmt = ‘[color][marker][line]’

fmt接收的是每個屬性的單個字母縮寫，例如： plot(x, y, ‘bo-’) # 藍色圓點實線
label :標記每條線或點的 一般是名字之類的
“”"
import matplotlib.pyplot as plt

x = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168],[9.779], [6.182], [7.59], [2.167], [7.042],[10.791], [5.313], [7.997], [3.1]], dtype=np.float32)y = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573],[3.366], [2.596], [2.53], [1.221], [2.827],[3.465], [1.65], [2.904], [1.3]], dtype=np.float32) plt.plot(x, y, 'ro', label='swswsw') plt.legend() plt.show()

“”“20.交叉熵損失函數： CrossEntropyLoss()：公式 loss(x, class) = -x[class] + log(exp(x[0]) + …+ exp(x[j]))
“””
“”“單維度測試--------------------------------------------”""

import torch import torch.nn as nn import math loss = nn.CrossEntropyLoss() input = torch.randn(1, 5, requires_grad=True) target = torch.empty(1, dtype=torch.long).random_(4) output = loss(input, target)print("輸入為5類:") print(input) print("要計算loss的類別:") print(target) print("計算loss的結果:") print(output)first = 0 for i in range(1):first -= input[i][target[i]] #************** -x[class]second = 0 for i in range(1):for j in range(5):second += math.exp(input[i][j]) #************* exp(x[0]) + ...+ exp(x[j])res = 0 res += first + math.log(second) #********* -x[class] + log(exp(x[0]) + ...+ exp(x[j])) print("自己的計算結果：") print(res)輸出結果：輸入為5類:tensor([[-1.0431, -0.1981, 1.3219, -1.8172, -0.4636]], requires_grad=True)要計算loss的類別:tensor([0])計算loss的結果:tensor(2.7861, grad_fn=<NllLossBackward>)自己的計算結果：tensor(2.7861, grad_fn=<AddBackward0>)

“”"------------------------------------------------------"""
“”“多維度測試-------------------------------------------”""

import torch import torch.nn as nn import math loss = nn.CrossEntropyLoss() input = torch.randn(3, 5, requires_grad=True) target = torch.empty(3, dtype=torch.long).random_(5) output = loss(input, target)print("輸入為3個5類:") print(input) print("要計算loss的類別:") print(target) print("計算loss的結果:") print(output)first = [0,0,0] for i in range(3):first[i] -= input[i][target[i]] second = [0,0,0] for i in range(3):for j in range(5):second[i] += math.exp(input[i][j]) res = 0 for i in range(3):res += first[i] +math.log(second[i]) print("自己的計算結果：") print(res/3)輸出結果： 輸入為3個5類: tensor([[ 0.9773, -0.8612, -0.7163, 0.6097, 0.0114],[-0.2555, -1.4427, 1.9644, -0.7308, 2.1826],[ 0.3451, -1.3543, 0.0665, 0.5910, 0.2061]], requires_grad=True) 要計算loss的類別: tensor([1, 3, 2]) 計算loss的結果: tensor(2.6667, grad_fn=<NllLossBackward>) 自己的計算結果： tensor(2.6667, grad_fn=<DivBackward0>)

3維測試：

import torch import torch.nn as nn import math loss = nn.CrossEntropyLoss()#計算公式：loss(x, class) = -x[class] + log(exp(x[0]) + ...+ exp(x[j])) input = torch.randn(3, 5, 2, requires_grad=True) #input就是x target = torch.empty(3, 2, dtype=torch.long).random_(5) #target就是class output = loss(input, target)print("輸入為3個5類:") print(input) print("要計算loss的類別:") print(target) print("計算loss的結果:") print(output)first = [[0,0],[0,0],[0,0]] for i in range(3):for j in range(2):first[i][j] -= input[i][target[i][j]][j] #************** -x[class]second = [[0,0],[0,0],[0,0]] for i in range(3):for j in range(5):for k in range(2):second[i][k] += math.exp(input[i][j][k])#************* exp(x[0]) + ...+ exp(x[j])res = 0 for i in range(3):for j in range(2):res += first[i][j] +math.log(second[i][j]) #********* -x[class] + log(exp(x[0]) + ...+ exp(x[j])) print("自己的計算結果：") print(res/6)輸出結果：輸入為3個5類:tensor([[[-0.8542, -0.2139],[ 1.7634, 0.8149],[-0.4763, -0.5300],[-1.3903, -0.4187],[ 1.4105, -0.3344]],[[-0.8880, -0.4785],[-2.3293, -1.0082],[ 1.3367, 0.6445],[-0.6875, 0.9052],[-0.4579, -0.1773]],[[-0.8935, 1.4309],[ 0.9779, -0.4425],[-0.0809, -1.0523],[-0.3746, -0.2991],[ 0.4313, -1.3516]]], requires_grad=True)要計算loss的類別:tensor([[2, 4],[3, 4],[1, 2]])計算loss的結果:tensor(2.1585, grad_fn=<NllLoss2DBackward>)自己的計算結果：tensor(2.1585, grad_fn=<DivBackward0>)

“”“21.torch.random_(from=0, to=None, *, generator=None)
將tensor用從在[from, to-1]上的正態分布或離散正態分布取樣值進行填充。如果沒有明確說明，則填充值僅由本tensor的數據類型限定。
random_(x):從[0, x-1]區間取任意一個數填充。
random_(x, y):從[x, y-1]區間取任意一個數填充。
“””

ss = torch.empty(1).random_(6) print("212121: ", ss) ss1 = torch.empty(1).random_(6, 9) print("212121222: ", ss1)

“”"22. SGD:隨機梯度下降法
keras.optimizers.SGD(lr=0.01, momentum=0.0, decay=0.0, nesterov=False)
隨機梯度下降法，支持動量參數，支持學習衰減率，支持Nesterov動量
參數：
lr：大或等于0的浮點數，學習率
momentum：大或等于0的浮點數，動量參數
decay：大或等于0的浮點數，每次更新后的學習率衰減值
nesterov：布爾值，確定是否使用Nesterov動量

有3組數據：
x1 = [2, 3, 4, 5]
x2 = [5, 6, 7, 8]
y = [30, 40 ,50 ,60]

h(x) = ax1 + bx2
梯度算法就是要獲取a和b的值 讓h(x)的值更接近y的值，同時讓隨時函數l = loss(x, class)的值l 最小。這就是梯度算法的核心

最終公式是：Q := Q - ρ∑((Yi - H(x^i))xi) Q從0到j每一個Q這么算

優點：
隨機梯度下降在計算下降最快的方向時時隨機選一個數據進行計算，而不是掃描全部訓練數據集，這樣就加快了迭代速度。

隨機梯度下降并不是沿著J(θ)下降最快的方向收斂，而是震蕩的方式趨向極小點。
“”"

# -*- coding: utf-8 -*- import random# 用y = Θ1*x1 + Θ2*x2來擬合下面的輸入和輸出 # input1 1 2 5 4 # input2 4 5 1 2 # output 19 26 19 20 input_x = [[1, 4], [2, 5], [5, 1], [4, 2]] # 輸入 y = [19, 26, 19, 20] # 輸出theta = [1, 1] # θ參數初始化 loss = 10 # loss先定義一個數，為了進入循環迭代 step_size = 0.01 # 步長 eps = 0.0001 # 精度要求 max_iters = 10000 # 最大迭代次數 error = 0 # 損失值 iter_count = 0 # 當前迭代次數while (loss > eps and iter_count < max_iters): # 迭代條件loss = 0i = random.randint(0, 3) # 每次迭代在input_x中隨機選取一組樣本進行權重的更新pred_y = theta[0] * input_x[i][0] + theta[1] * input_x[i][1] # 預測值theta[0] = theta[0] - step_size * (pred_y - y[i]) * input_x[i][0]theta[1] = theta[1] - step_size * (pred_y - y[i]) * input_x[i][1]for i in range(3):pred_y = theta[0] * input_x[i][0] + theta[1] * input_x[i][1] # 預測值error = 0.5 * (pred_y - y[i]) ** 2loss = loss + erroriter_count += 1print('iters_count', iter_count) print('theta: ', theta) print('final loss: ', loss) print('iters: ', iter_count)

“”“23.torch.view():返回一個有相同數據但大小不同的tensor。 返回的tensor必須有與原tensor相同的數據和相同數目的元素，
但可以有不同的大小。一個tensor必須是連續的contiguous()才能被查看。
另外，參數不可為空。參數中的-1就代表這個位置由其他位置的數字來推斷，只要在不致歧義的情況的下，view參數就可以推斷出來，也就是人可以推斷出形狀的情況下
“””

x = torch.randn(4, 4) print("x: ", x) print("x.size(): ", x.size()) y = x.view(16) print("yyy: ", y) print("y.size(): ", y.size())z = x.view(-1, 8) # the size -1 is inferred from other dimensions print("zzzz: ", z) print("z.size(): ", z.size())

“”“24.train_loader = DataLoader()”""

from torchvision import datasets from torch.utils.data import DataLoader from torchvision import transformstrain_dataset = datasets.MNIST(root='F:/PycharmProjects/pytorch-beginner-master/02-Logistic Regression/data', train=True, transform=transforms.ToTensor(), download=True) test_dataset = datasets.MNIST(root='F:/PycharmProjects/pytorch-beginner-master/02-Logistic Regression/data', train=False, transform=transforms.ToTensor()) batch_size = 32 train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) print("訓練集總長度： ", len(train_dataset)) print("每個mini_batch的size為32，一共有: ", len(train_loader), "個")# for i, data in enumerate(train_loader, 1): # img, label = data #j將數據從train_loader讀出來 一次讀取的樣本數是32個 # img, label = Variable(img), Variable(label) # print("img.data.size(): ", img.data.size(), "img.data.size(): ", label.data.size())

“”"25.torch.sum(): 返回輸入張量input 所有元素的和。

輸出形狀與輸入相同，除了給定維度上為1"""

a = torch.randn(2, 5) print("cdcdcd: ", a) print("sum: ", a.sum())b = torch.randn(2, 5) num_correct = (a == b).sum() print("num_correct: ", num_correct)

“”“26.torch.nn.Linear():線形圖存， 對傳入數據應用線性變換：y = weight* x+ bias，PyTorch的nn.Linear（）是用于設置網絡中的全連接層的，需要注意的是全連接層的輸入與輸出都是二維張量，一般形狀為[batch_size, size]，不同于卷積層要求輸入輸出是四維張量。
參數：
in_features指的是輸入的二維張量的大小，即輸入的[batch_size, size]中的size的值
out_features指的是輸出的二維張量的大小，即輸出的二維張量的形狀為[batch_size，output_size]，當然，它也代表了該全連接層的神經元個數。
從輸入輸出的張量的shape角度來理解，相當于一個輸入為[batch_size, in_features]的張量變換成了[batch_size, out_features]的輸出張量。
bias - 如果設置為False，則圖層不會學習附加偏差。默認值：True”""

x = torch.randn(2, 3)#輸入[batch_size=2, size=3] m = torch.nn.Linear(3, 2)#這里的3就是size，2是要輸出的output_size。所以輸出是[batch_size,2] output = m(x) print('m.weight.shape:\n ', m.weight.shape) print('m.bias.shape:\n', m.bias.shape)#m.bias由batch_size決定，batch_size的值來源于in_features print('output.shape:\n', output.shape) 輸出結果：m.weight.shape:torch.Size([2, 3])m.bias.shape: torch.Size([2])output.shape:torch.Size([2, 2])

“”"27.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1,
padding=0, dilation=1, groups=1,
bias=True, padding_mode=‘zeros’):2d卷積。
參數：
Input Channels：這個很好理解，就是輸入的四維張量[N, C, H, W]中的C了，即輸入張量的channels數。也就是輸入圖像的通道數
（如灰度圖像就是1通道，RGB圖像忽略alpha通道后就是3通道）。

out_channels：也很好理解，即期望的四維輸出張量的channels數，不再多說

Kernel_Size：filter（卷積核）的大小(F)，一般我們會使用5x5、3x3這種左右兩個數相同的卷積核，因此這種情況只需要寫kernel_size = 5這樣的就行了。
如果左右兩個數不同，比如3x5的卷積核，那么寫作kernel_size = (3, 5)，注意需要寫一個tuple，而不能寫一個列表（list）

Stride：步長(S),Stride指每次移動卷積核的步長，顯然這個值會大幅影響輸出的Feature Map的shape。

Padding：邊界補充§,Padding指為輸入圖像外圍補充的圈數，注意如28乘28的圖像，補充Padding=1就變成30乘30的了（而不是29乘29）。這個值一般直接在卷積時候定義，
不必手動為輸入圖像加Padding。

計算公式：
輸入的大小：W1 H1 D1
輸出大小：W2 = ((W1-F+2P)/S) + 1
H2 = ((H1-F+2P)/S) + 1
D2 = K
“”"

"""2維的卷積層,用于圖片的卷積""" # 輸入圖像的通道數=1(灰度圖像),卷積核的種類數=3(K) # 卷積核的shape是3乘3的,掃描步長為1,不加padding layer = nn.Conv2d(in_channels=1, out_channels=3, kernel_size=3, stride=1, padding=0)"""要輸入的原始圖像""" # 樣本數=1,通道數=1,圖像的shape是28乘28的 w=28,F=3 S=1，根據W2 = ((W1-F+2P)/S) + 1算得w2 = (28 - 3)/1 + 1 = 26 x = torch.rand(1, 1, 28, 28)#根據計算公式 輸出為：26*26*3 """使用上面定義的卷積層layer和輸入x,完成一次卷積的前向運算""" out = layer.forward(x) # 得到的還是1張圖片,因為用了3種kernel所以輸出的通道數變成3了 # 因為沒加padding,原來28乘28的圖像在3乘3卷積下得到的邊長是28-3+1=26 print("out.shape: ", out.shape) # torch.Size([1, 3, 26, 26])"""添加padding看看""" # 這次使用padding為1.所以原始圖像上下左右都加了一層0 layer = nn.Conv2d(1, 3, kernel_size=3, stride=1, padding=1) print(layer.forward(x).shape) # torch.Size([1, 3, 28, 28])"""步長設置為2看看""" # stride設置為2,也就是每次移動2格子(向上或者向右) layer = nn.Conv2d(1, 3, kernel_size=3, stride=2, padding=1) # 相當于每次跳1個像素地掃描,輸出的Feature Map直接小了一半 print(layer.forward(x).shape) # torch.Size([1, 3, 14, 14])"""實際使用時,應該這樣用!""" out = layer(x) print(out.shape) # torch.Size([1, 3, 14, 14])

“”"28. torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
如果padding不是0，會在輸入的每一邊添加相應數目0 比如padding=1，則在每一邊分別補0 ，其實最后的結果補出來是bias

參數：

kernel_size(int or tuple) - max pooling的窗口大小，可以為tuple，在nlp中tuple用更多，（n,1）
stride(int or tuple, optional) - max pooling的窗口移動的步長。默認值是kernel_size
padding(int or tuple, optional) - 輸入的每一條邊補充0的層數
dilation(int or tuple, optional) – 一個控制窗口中元素步幅的參數
return_indices - 如果等于True，會返回輸出最大值的序號，對于上采樣操作會有幫助
ceil_mode - 如果等于True，計算輸出信號大小的時候，會使用向上取整，代替默認的向下取整的操作
“”"

aa = torch.randn(4, 4, 2) print("aa: ", aa) bb = nn.MaxPool2d(kernel_size=2, stride=2) c = bb(aa) print("c: ", c) print("c.shape", c.shape)

“”"29. nn.LSTM(in_dim, hidden_dim, n_layer, batch_first=True):LSTM循環神經網絡
參數：
input_size： 表示的是輸入的矩陣特征數
hidden_size： 表示的是輸出矩陣特征數
num_layers 表示堆疊幾層的LSTM，默認是1
bias： True 或者 False，決定是否使用bias
batch_first： True 或者 False，因為nn.lstm()接受的數據輸入是(序列長度，batch，輸入維數)，這和我們cnn輸入的方式不太一致，所以使用batch_first，我們可以將輸入變成(batch，序列長度，輸入維數)
dropout： 表示除了最后一層之外都引入一個dropout
bidirectional： 表示雙向LSTM，也就是序列從左往右算一次，從右往左又算一次，這樣就可以兩倍的輸出

batch_first: 輸入輸出的第一維是否為 batch_size，默認值 False。因為 Torch 中，人們習慣使用Torch中帶有的dataset，
dataloader向神經網絡模型連續輸入數據，這里面就有一個 batch_size 的參數，表示一次輸入多少個數據。 在 LSTM 模型中，
輸入數據必須是一批數據，為了區分LSTM中的批量數據和dataloader中的批量數據是否相同意義，LSTM 模型就通過這個參數的設定來區分。
如果是相同意義的，就設置為True，如果不同意義的，設置為False。 torch.LSTM 中 batch_size 維度默認是放在第二維度，故此參數設置
可以將 batch_size 放在第一維度。如：input 默認是(4,1,5)，中間的 1 是 batch_size，指定batch_first=True后就是(1,4,5)。所以，
如果你的輸入數據是二維數據的話，就應該將 batch_first 設置為True;

“”"

import torch import torch.nn as nn from torch.autograd import Variable#構建網絡模型---輸入矩陣特征數input_size、輸出矩陣特征數hidden_size、層數num_layers inputs = torch.randn(5,3,10)# ->(seq_len,batch_size,input_size) """inputs = torch.randn(5,3,10) ：bitch_size=5, seq_len=3,input_size=10 我的理解：有5個句子，每個句子3個單詞，每個單詞用10個實數向量表示；而句子的長度是不一樣的，所以seq_len可長可短，這也是LSTM可以解決長短序列 的特殊之處。只有seq_len這一參數是可變的。 """ rnn = nn.LSTM(10,20,2)# -> (input_size,hidden_size,num_layers) h0 = torch.randn(2,3,20)# ->(num_layers* 1,batch_size,hidden_size) c0 = torch.randn(2,3,20)# ->(num_layers*1,batch_size,hidden_size) num_directions=1# 因為是單向LSTM ''' Outputs: output, (h_n, c_n) ''' output,(hn,cn) = rnn(inputs,(h0,c0)) #print("out:", out)

“”“30. x.size(num)：獲取維數”""

dede = torch.Tensor(3, 4, 5) print("dedede: ", torch.Tensor(3, 4, 5).size(0)) #值是3 print("dedede2: ", torch.Tensor(3, 4, 5).size(1))#值是4 print("dedede3: ", torch.Tensor(3, 4, 5).size(2))#值是5 #print("dedede4: ", torch.Tensor(3, 4, 5).size(3))#報錯frfr = torch.cuda.get_device_name(0) print("dedede: ", frfr)

31.torch.nn.ReLU(inplace=False)：tensor所有的元素中如果小于零的就改為零
1.如果inplace為false，不改變輸入，只改變輸出
2.如果inplace為true，改變輸入
如下例子：

import torchinput = torch.randn(8) print('input: ', input)input1 = torch.nn.ReLU(inplace=False)(input) print('input: ', input) print('input1: ', input1)input2 = torch.nn.ReLU(inplace=True)(input) print('input: ', input) print('input2: ', input2) 輸出結果： input: tensor([-0.1985, -1.4657, 0.1393, -1.6685, 0.1855, -0.5001, -1.0144, 0.1143]) input: tensor([-0.1985, -1.4657, 0.1393, -1.6685, 0.1855, -0.5001, -1.0144, 0.1143]) input1: tensor([0.0000, 0.0000, 0.1393, 0.0000, 0.1855, 0.0000, 0.0000, 0.1143]) input: tensor([0.0000, 0.0000, 0.1393, 0.0000, 0.1855, 0.0000, 0.0000, 0.1143]) input2: tensor([0.0000, 0.0000, 0.1393, 0.0000, 0.1855, 0.0000, 0.0000, 0.1143])

總結

以上是生活随笔為你收集整理的pytorch函数详解 附带测试demo的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。