1.PyTorchの基本

1. PyTorchの基本操作

1. ガイドパッケージ

import torch

2. バージョン番号を確認する

torch.__version__
"""
'2.0.1+cpu'
"""

3.行列を初期化（すべてゼロ）

x = torch.empty(3,2)
x
"""
tensor([[7.2868e-44, 8.1275e-44],
        [6.7262e-44, 7.5670e-44],
        [8.1275e-44, 6.7262e-44]])
"""

4. 初期化行列をランダムに作成する

4.1 正規分布に従う

x_1 = torch.randn(3,4)
x_1
"""
tensor([[ 0.1605, -0.9290, -0.0501, -0.0723],
        [ 0.6792,  0.1977, -0.7773,  0.6927],
        [ 0.7576, -1.4204,  0.1976, -2.2545]])

"""

4.2 一様分布に従う

x_2 = torch.rand(3,4)
x_2
"""
tensor([[0.5876, 0.5991, 0.9678, 0.8188],
        [0.2934, 0.4345, 0.1316, 0.8469],
        [0.0042, 0.3754, 0.3141, 0.8362]])
"""

5. すべてゼロの行列を初期化する

x1 = torch.zeros(5,2,dtype=torch.long)
x1
"""
tensor([[0, 0],
        [0, 0],
        [0, 0],
        [0, 0],
        [0, 0]])
"""

6. オールワン行列の初期化

x2 = torch.ones(3,4)
x2
"""
tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]])
"""

7. マトリックスサイズの仕様を確認します

x2.size()
"""
torch.Size([3, 4])
"""

8. マトリックスの次元を変更する

y = torch.randn(3,4)
y
"""
tensor([[-1.3152,  0.2621, -0.7739,  0.1728],
        [-1.3887,  1.0964,  0.7797,  2.0587],
        [ 0.4726, -0.2367,  0.8845,  0.9405]])
"""

y1 = y.view(12)
y1
"""
tensor([-1.3152,  0.2621, -0.7739,  0.1728, -1.3887,  1.0964,  0.7797,  2.0587,  0.4726, -0.2367,  0.8845,  0.9405])
"""


y2 = y.view(2,6)
y2
"""
tensor([[-1.3152,  0.2621, -0.7739,  0.1728, -1.3887,  1.0964],
        [ 0.7797,  2.0587,  0.4726, -0.2367,  0.8845,  0.9405]])
"""


y3 = y.view(6,-1)
y3
"""
tensor([[-1.3152,  0.2621],
        [-0.7739,  0.1728],
        [-1.3887,  1.0964],
        [ 0.7797,  2.0587],
        [ 0.4726, -0.2367],
        [ 0.8845,  0.9405]])
"""

9、NumpyとTensor形式の変換

9.1 Numpy から Tensor へ

z1 = torch.ones(2,5)
z1
"""
tensor([[1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.]])
"""

z2 = z1.numpy()
z2
"""
array([[1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.]], dtype=float32)
"""

9.2 テンソルからNumpyへ

import numpy as np
a1 = np.ones([2,4])
a1
"""
array([[1., 1., 1., 1.],
       [1., 1., 1., 1.]])
"""

a2 = torch.from_numpy(a1)
a2
"""
tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.]], dtype=torch.float64)
"""

10. テンソルの一般的な形式

import torch
from torch import tensor

10.1スカラー

数or である限り单一的值、次のようになります。scalar

x = tensor(22)
x
"""
tensor(22)
"""

x.dim() # 0
2*x # tensor(44)
x.item() # 22

10.2 ベクトル

特定の機能を表すベクトル ベクトル。例:ベクトルは値ではなく、[年龄，身高，体重]，[25,178,60]
実数値のコレクションです。

私の理解は次のとおりです:複数のスカラーがベクトルを形成します

y = tensor([25,178,60])
y
"""
tensor([ 25, 178,  60])
"""

y.dim() # 1
y.size() # torch.Size([3])

10.3 マトリックス

マトリックス マトリックス、通常は多次元。
たとえば、Zhang San、Li Si、Wang Ermazi という3 人の生徒がいます。彼らはそれぞれ独自の特性 ( [年齢、身長、体重] )を持っており[[25,178,60], [22,180,62], [21,177,61]]、それらを組み合わせると行列になります。

私の理解は次のとおりです:複数のベクトルが行列を形成する

m = tensor([[1,2,3], [2,1,3], [3,1,2]])
m
"""
tensor([[1, 2, 3],
        [2, 1, 3],
        [3, 1, 2]])
"""

m.matmul(m)
"""
tensor([[14,  7, 15],
        [13,  8, 15],
        [11,  9, 16]])
"""

tensor([1,0,1]).matmul(m)
"""
tensor([4, 3, 5])
"""

tensor([1,2,1]).matmul(m)
"""
tensor([ 8,  5, 11])
"""

m*m
"""
tensor([[1, 4, 9],
        [4, 1, 9],
        [9, 1, 4]])
"""

10.4 n 次元テンソル

pytorch は画像の処理[N,C,H,W]に 4 次元テンソルを使用することがよくあります
。 N: 各バッチ内の画像の数
C: 各画像のチャネル数
H: 各画像の垂直方向の次元 (高さ) のピクセル数
W: 各画像の数画像の水平方向のピクセル (幅)

11，模型動物園

他の人がトレーニングしたネットワーク アーキテクチャと重みパラメータを呼び出し、最終的には 1 行のコードで実行できます。
怠け者にとっては呼び出しに便利で、 Pytorch のハブモジュールになります
Github 上の関連リンクは
pytorch 公式 Web サイトの API リンクです。

たとえば、pytorch 公式 Web サイトで任意のプロジェクトを開き、コピーして貼り付けて実行し、関連する重みパラメータ ファイルをダウンロードするには、科学的にインターネットをサーフィンする必要があります。

2、autograd自動導出メカニズム

ケース 1: 逆伝播による導出、関数式は ですy = w*x*x + b*x + c。ここで、w=2、x=3、b=5、c=4

import torch
w = torch.tensor(2, dtype = torch.float32, requires_grad = True)
x = torch.tensor(3, dtype = torch.float32, requires_grad = True)
b = torch.tensor(5, dtype = torch.float32, requires_grad = True)
c = torch.tensor(4, dtype = torch.float32, requires_grad = True)
w,x,b,c
"""
(tensor(2., requires_grad=True),
 tensor(3., requires_grad=True),
 tensor(5., requires_grad=True),
 tensor(4., requires_grad=True))
"""

y = w * x**2 + b * x + c
y
"""
tensor(37., grad_fn=<AddBackward0>)
"""

y.backward() #反向传播

w.grad
"""
tensor(9.)
"""
x.grad
"""
tensor(17.)
"""
b.grad
"""
tensor(3.)
"""
c.grad
"""
tensor(1.)
"""

3. 最も基本的なモデルトレーニングの完全な手順のデモンストレーション

要件: 教師あり学習、トレーニング モデルに準拠y = 2*x + 5

import torch
import numpy as np

1. ラベルデータの準備

①×サンプル

Ⅰ、0～9、10の数字

ここでは簡単にするために、x サンプルは 0 ～ 9、10 の数値であり、リストに格納されています。

x = [i for i in range(10)]
x # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Ⅱ.配列形式に変換して操作を容易にする

x_arr = np.array(x,dtype=np.float32)
x_arr # array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.], dtype=float32)

Ⅲ. 後続の操作を容易にするためにデータの列に変換します

x_train = x_arr.reshape(-1,1)
x_train
"""
array([[0.],
       [1.],
       [2.],
       [3.],
       [4.],
       [5.],
       [6.],
       [7.],
       [8.],
       [9.]], dtype=float32)
"""

x_train.shape # (10, 1)

②yサンプル

Ⅰ.関数を通じてy=2*x+5対応する結果 y を生成する

y = [2*x+5 for x in range(10)]
y # [5, 7, 9, 11, 13, 15, 17, 19, 21, 23]

Ⅱ.配列形式に変換して操作を容易にする

y_arr = np.array(y,dtype=np.float32)
y_arr # array([ 5.,  7.,  9., 11., 13., 15., 17., 19., 21., 23.], dtype=float32)

Ⅲ. 後続の操作を容易にするためにデータの列に変換します

y_train = y_arr.reshape(-1,1)
y_train
"""
array([[ 5.],
       [ 7.],
       [ 9.],
       [11.],
       [13.],
       [15.],
       [17.],
       [19.],
       [21.],
       [23.]], dtype=float32)
"""

y_train.shape # (10, 1)

2. 設計モデル

ここでは、最も単純な 2 層の線形層を使用してモデルを構築し、トレーニング データは 1 つのデータ
です

class Linear_yy(torch.nn.Module):
    def __init__(self,in_dim,media_dim,out_dim):
        super(Linear_yy,self).__init__()
        self.linear_1 = torch.nn.Linear(in_dim,media_dim)
        self.linear_2 = torch.nn.Linear(media_dim,out_dim)
        
    def forward(self,x):
        x = self.linear_1(x)
        x = self.linear_2(x)
        return x

in_dim = 1
media_dim = 2
out_dim = 1

model = Linear_yy(in_dim=in_dim,media_dim=media_dim,out_dim=out_dim)
model
"""
Linear_yy(
  (linear_1): Linear(in_features=1, out_features=2, bias=True)
  (linear_2): Linear(in_features=2, out_features=1, bias=True)
)
"""

3. エポック、学習率、オプティマイザ、損失関数などのパラメータを指定します。

epochs = 1000 #epoch
learning_rate = 0.0001 # 学习率
optimizer = torch.optim.Adam(model.parameters(),lr=learning_rate) # 优化器选择Adam
loss_faction = torch.nn.MSELoss() # 损失函数选择MSE

4. トレーニングモデル

for epoch in range(epochs):
    epoch += 1
    # 注意转行成tensor
    inputs = torch.from_numpy(x_train)
    labels = torch.from_numpy(y_train)

    # 梯度要清零每一次迭代
    optimizer.zero_grad() 

    # 前向传播
    outputs = model(inputs)

    # 计算损失
    loss = loss_faction(outputs, labels)

    # 返向传播
    loss.backward()

    # 更新权重参数
    optimizer.step()
    if epoch % 50 == 0: # 每50次输出一次损失值
        print('epoch {}, loss {}'.format(epoch, loss.item()))

5. モデル予測

predicted = model(torch.from_numpy(x_train).requires_grad_()).data.numpy()
predicted
"""
array([[0.6956282 ],
       [0.75930536],
       [0.82298255],
       [0.88665974],
       [0.9503369 ],
       [1.014014  ],
       [1.0776913 ],
       [1.1413685 ],
       [1.2050457 ],
       [1.2687228 ]], dtype=float32)
"""

6. モデルの重量を保存する

torch.save(model.state_dict(), 'model.pth')

7. モデルの重量負荷

モデルの重みのロードは通常、モデルのトレーニングを中断するために使用されます。トレーニングを続行するには、最後の重みパラメータを使用する必要があります。このとき、最初にモデルを保存してから、重みパラメータをロードする必要があります。

model.load_state_dict(torch.load('model.pth'))

8. 完全なコード (CPU)

もちろん、これはモデルをトレーニングするための完全なコードにすぎません。最終テストとモデルの重みの保存については、5、6、7 を参照してください。

import torch
import torch.nn as nn
import numpy as np

class Linear_yy(torch.nn.Module):
    def __init__(self,in_dim,media_dim,out_dim):
        super(Linear_yy,self).__init__()
        self.linear_1 = torch.nn.Linear(in_dim,media_dim)
        self.linear_2 = torch.nn.Linear(media_dim,out_dim)
        
    def forward(self,x):
        x = self.linear_1(x)
        x = self.linear_2(x)
        return x
    
in_dim = 1
media_dim = 2
out_dim = 1

model = Linear_yy(in_dim=in_dim,media_dim=media_dim,out_dim=out_dim)

epochs = 1000
learning_rate = 0.0001
optimizer = torch.optim.Adam(model.parameters(),lr=learning_rate)
loss_faction = torch.nn.MSELoss()

for epoch in range(epochs):
    epoch += 1
    # 注意转行成tensor
    inputs = torch.from_numpy(x_train)
    labels = torch.from_numpy(y_train)

    # 梯度要清零每一次迭代
    optimizer.zero_grad() 

    # 前向传播
    outputs = model(inputs)

    # 计算损失
    loss = loss_faction(outputs, labels)

    # 返向传播
    loss.backward()

    # 更新权重参数
    optimizer.step()
    if epoch % 50 == 0:
        print('epoch {}, loss {}'.format(epoch, loss.item()))

9. 完全なコード (GPU)

GPU トレーニングを使用するには、 GPU に训练数据,を入れるだけです。模型

モデルのトレーニングに GPU を使用するかどうかを指定します
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

モデルはGPUに入れられます
model.to(device)

データをGPUに取り込む
inputs = torch.from_numpy(x_train).to(device)
labels = torch.from_numpy(y_train).to(device)

import torch
import torch.nn as nn
import numpy as np

class Linear_yy(torch.nn.Module):
    def __init__(self,in_dim,media_dim,out_dim):
        super(Linear_yy,self).__init__()
        self.linear_1 = torch.nn.Linear(in_dim,media_dim)
        self.linear_2 = torch.nn.Linear(media_dim,out_dim)
        
    def forward(self,x):
        x = self.linear_1(x)
        x = self.linear_2(x)
        return x
    
in_dim = 1
media_dim = 2
out_dim = 1

model = Linear_yy(in_dim=in_dim,media_dim=media_dim,out_dim=out_dim)

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model.to(device)

epochs = 1000
learning_rate = 0.0001
optimizer = torch.optim.Adam(model.parameters(),lr=learning_rate)
loss_faction = torch.nn.MSELoss()

for epoch in range(epochs):
    epoch += 1
    # 注意转行成tensor
    inputs = torch.from_numpy(x_train).to(device)
    labels = torch.from_numpy(y_train).to(device)
    
    # 梯度要清零每一次迭代
    optimizer.zero_grad() 

    # 前向传播
    outputs = model(inputs)

    # 计算损失
    loss = loss_faction(outputs, labels)

    # 返向传播
    loss.backward()

    # 更新权重参数
    optimizer.step()
    if epoch % 50 == 0:
        print('epoch {}, loss {}'.format(epoch, loss.item()))