機械学習 | PyTorch の簡潔なチュートリアル パート 1

前回の記事では、特徴正規化とテンソルについて紹介しましたが、次回は、主に PyTorch の簡単な実践方法を紹介する、PyTorch に関する 2 つの簡潔なチュートリアルを書きます。

1. 四則演算

import torcha = torch.tensor([2, 3, 4])b = torch.tensor([3, 4, 5])print("a + b: ", (a + b).numpy())print("a - b: ", (a - b).numpy())print("a * b: ", (a * b).numpy())print("a / b: ", (a / b).numpy())

加算、減算、乗算、除算については説明する必要はありません。出力は次のとおりです:

a + b:[5 7 9]a - b:[-1 -1 -1]a * b:[ 6 12 20]a / b:[0.6666667 0.750.8]

2. 線形回帰

線形回帰が見つかりました。図に示すように、直線は既知の点にできるだけ近いです。

図 1

import torchfrom torch import optimdef build_model1():return torch.nn.Sequential(torch.nn.Linear(1, 1, bias=False))def build_model2():model = torch.nn.Sequential()model.add_module("linear", torch.nn.Linear(1, 1, bias=False))return modeldef train(model, loss, optimizer, x, y):model.train()optimizer.zero_grad()fx = model.forward(x.view(len(x), 1)).squeeze()output = loss.forward(fx, y)output.backward()optimizer.step()return output.item()def main():torch.manual_seed(42)X = torch.linspace(-1, 1, 101, requires_grad=False)Y = 2 * X + torch.randn(X.size()) * 0.33print("X: ", X.numpy(), ", Y: ", Y.numpy())model = build_model1()loss = torch.nn.MSELoss(reductinotallow='mean')optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)batch_size = 10for i in range(100):cost = 0.num_batches = len(X) // batch_sizefor k in range(num_batches):start, end = k * batch_size, (k + 1) * batch_sizecost += train(model, loss, optimizer, X[start:end], Y[start:end])print("Epoch = %d, cost = %s" % (i + 1, cost / num_batches))w = next(model.parameters()).dataprint("w = %.2f" % w.numpy())if __name__ == "__main__":main()

(1) メイン関数から始めて、torch.manual_seed(42) を使用して乱数生成器のシードを設定し、生成される乱数シーケンスが実行されるたびに同じになるようにします。この関数は整数パラメータを受け入れます。シードであり、結果の再現性を確保するためのニューラル ネットワークのトレーニングなど、乱数を必要とするシナリオで使用できます。

(2) torch.linspace(-1, 1, 101, require_grad=False) は、次の目的で使用されます。指定された間隔内で等間隔の値のセットを生成します。この関数は 3 つのパラメータを受け入れます: 開始値、終了値、要素数、指定された数の等間隔の値を含むテンソルを返します;

(3 ) build_model1 の内部実装:

• torch.nn.Sequential(torch.nn.Linear(1, 1,bias=False)) nn.Sequential クラスのコンストラクターを使用し、線形層を渡しますこれをパラメータとして追加し、ニューラル ネットワーク モデルを返します。
• build_model2 には build_model1 と同じ機能があり、add_module() メソッドを使用して、linear という名前のサブモジュールを追加します。

(4) torch.nn.MSELoss (reductinotallow='mean') は損失関数を定義します;

optim.SGD(model.parameters(), lr=0.01, moment=0.9) を使用して、確率的勾配降下法 (SGD) 最適化アルゴリズム

トレーニング セットをバッチ サイズで分割し、100 回ループします

(7) 次は、ニューラル ネットワーク モデルをトレーニングするために使用されるトレーニング関数 train です。具体的には、この関数は次のパラメータを受け入れます:

• model: ニューラル ネットワーク モデル、通常は nn.Module から継承されたクラスのインスタンス;
• loss: 損失関数、使用されるモデルの予測値と真の値を計算する 値の差分;
• optimizer: モデルのパラメーターを更新するために使用されるオプティマイザー;
• x: テンソルである入力データtorch.Tensor タイプのテンソル;
• y: ターゲット データは torch.Tensor タイプのテンソルです;

(8) train は、PyTorch トレーニング プロセスで一般的に使用されるメソッドです。

• モデルをトレーニング モードに設定します。つまり、ドロップアウトやバッチ正規化などのトレーニング中に使用される特別な操作を有効にします。
• 新しいラウンドの勾配計算のオプティマイザー;
• 入力データをモデルに渡し、モデルの予測値を計算し、予測値とターゲット データを損失関数に渡して損失値を計算します。
## 損失値を逆伝播し、モデル パラメーターの勾配を計算します。;
• オプティマイザを使用してモデル パラメーターを更新し、損失値を最小限に抑えます。;
• 損失値;

（9）print("ラウンド回数 = %d、損失値 = %s" % (i 1, コスト / バッチ数)) 最後に、現在のトレーニング ラウンドと損失値を出力します。上記のコード出力は次のとおりです:

...Epoch = 95, cost = 0.10514946877956391Epoch = 96, cost = 0.10514946877956391Epoch = 97, cost = 0.10514946877956391Epoch = 98, cost = 0.10514946877956391Epoch = 99, cost = 0.10514946877956391Epoch = 100, cost = 0.10514946877956391w = 1.98

3. ロジスティック回帰

ロジスティック回帰では、曲線を使用して、一連のトレーニングの軌跡を近似的に表現します。図に示すように:

図 2

import numpy as npimport torchfrom torch import optimfrom data_util import load_mnistdef build_model(input_dim, output_dim):return torch.nn.Sequential(torch.nn.Linear(input_dim, output_dim, bias=False))def train(model, loss, optimizer, x_val, y_val):model.train()optimizer.zero_grad()fx = model.forward(x_val)output = loss.forward(fx, y_val)output.backward()optimizer.step()return output.item()def predict(model, x_val):model.eval()output = model.forward(x_val)return output.data.numpy().argmax(axis=1)def main():torch.manual_seed(42)trX, teX, trY, teY = load_mnist(notallow=False)trX = torch.from_numpy(trX).float()teX = torch.from_numpy(teX).float()trY = torch.tensor(trY)n_examples, n_features = trX.size()n_classes = 10model = build_model(n_features, n_classes)loss = torch.nn.CrossEntropyLoss(reductinotallow='mean')optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)batch_size = 100for i in range(100):cost = 0.num_batches = n_examples // batch_sizefor k in range(num_batches):start, end = k * batch_size, (k + 1) * batch_sizecost += train(model, loss, optimizer,trX[start:end], trY[start:end])predY = predict(model, teX)print("Epoch %d, cost = %f, acc = %.2f%%"% (i + 1, cost / num_batches, 100. * np.mean(predY == teY)))if __name__ == "__main__":main()

(1) 上で紹介した main 関数から始めます torch.manual_seed( 42)、ここでは省略します ;

(2)load_mnist は、mnist データセットをダウンロードする独自の実装であり、trX と teX を入力データとして、trY と teY をラベル データとして返します;

( 3) build_model の内部実装: torch.nn .Sequential(torch.nn.Linear(input_dim, Output_dim,bias=False)) は、線形層を含むニューラル ネットワーク モデルを構築するために使用されます。モデルの入力特徴の数は次のとおりです。 input_dim、出力特徴の数はoutput_dim、線形層にはバイアス項がありません。ここで、n_classes=10は10個のカテゴリを出力することを意味します。 書き換え後: (3) build_model の内部実装: torch.nn.Sequential(torch.nn.Linear(input_dim, Output_dim,bias=False)) を使用して、線形層を含むニューラル ネットワーク モデルを構築します。モデルの入力特徴の数はinput_dim.出力特徴の数はoutput_dimであり、線形層にはバイアス項がありません。このうち、n_classes=10 は 10 個のカテゴリを出力することを意味します;

(4) 他の手順は、損失関数、勾配降下オプティマイザを定義し、batch_size でトレーニング セットを分割し、train に対して 100 回ループすることです。

#optim.SGD(model.parameters(), lr=0.01, moment=0.9) を使用して確率的勾配降下法 (SGD) 最適化アルゴリズムを実装します

(6) 各ラウンドの終了時にトレーニング 最後に、予測を行うには、predict 関数を実行する必要があります。この関数は、model (トレーニング済みモデル) と teX (予測する必要があるデータ) の 2 つのパラメーターを受け入れます。具体的な手順は次のとおりです。

• model.eval()模型设置为评估模式，这意味着模型将不会进行训练，而是仅用于推理；
• 将output转换为NumPy数组，并使用argmax()方法获取每个样本的预测类别；

（7）print("Epoch %d, cost = %f, acc = %.2f%%" % (i + 1, cost / num_batches, 100. * np.mean(predY == teY)))最后打印当前训练的轮次，损失值和acc，上述的代码输出如下（执行很快，但是准确率偏低）：

...Epoch 91, cost = 0.252863, acc = 92.52%Epoch 92, cost = 0.252717, acc = 92.51%Epoch 93, cost = 0.252573, acc = 92.50%Epoch 94, cost = 0.252431, acc = 92.50%Epoch 95, cost = 0.252291, acc = 92.52%Epoch 96, cost = 0.252153, acc = 92.52%Epoch 97, cost = 0.252016, acc = 92.51%Epoch 98, cost = 0.251882, acc = 92.51%Epoch 99, cost = 0.251749, acc = 92.51%Epoch 100, cost = 0.251617, acc = 92.51%

4、神经网络

一个经典的LeNet网络，用于对字符进行分类，如图：

图3

• 定义一个多层的神经网络
• 对数据集的预处理并准备作为网络的输入
• 将数据输入到网络
• 计算网络的损失
• 反向传播，计算梯度

import numpy as npimport torchfrom torch import optimfrom data_util import load_mnistdef build_model(input_dim, output_dim):return torch.nn.Sequential(torch.nn.Linear(input_dim, 512, bias=False),torch.nn.Sigmoid(),torch.nn.Linear(512, output_dim, bias=False))def train(model, loss, optimizer, x_val, y_val):model.train()optimizer.zero_grad()fx = model.forward(x_val)output = loss.forward(fx, y_val)output.backward()optimizer.step()return output.item()def predict(model, x_val):model.eval()output = model.forward(x_val)return output.data.numpy().argmax(axis=1)def main():torch.manual_seed(42)trX, teX, trY, teY = load_mnist(notallow=False)trX = torch.from_numpy(trX).float()teX = torch.from_numpy(teX).float()trY = torch.tensor(trY)n_examples, n_features = trX.size()n_classes = 10model = build_model(n_features, n_classes)loss = torch.nn.CrossEntropyLoss(reductinotallow='mean')optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)batch_size = 100for i in range(100):cost = 0.num_batches = n_examples // batch_sizefor k in range(num_batches):start, end = k * batch_size, (k + 1) * batch_sizecost += train(model, loss, optimizer,trX[start:end], trY[start:end])predY = predict(model, teX)print("Epoch %d, cost = %f, acc = %.2f%%"% (i + 1, cost / num_batches, 100. * np.mean(predY == teY)))if __name__ == "__main__":main()

（1）以上这段神经网络的代码与逻辑回归没有太多的差异，区别的地方是build_model，这里是构建一个包含两个线性层和一个Sigmoid激活函数的神经网络模型，该模型包含一个输入特征数量为input_dim，输出特征数量为output_dim的线性层，一个Sigmoid激活函数，以及一个输入特征数量为512，输出特征数量为output_dim的线性层；

（2）print("Epoch %d, cost = %f, acc = %.2f%%" % (i + 1, cost / num_batches, 100. * np.mean(predY == teY)))最后打印当前训练的轮次，损失值和acc，上述的代码输入如下（执行时间比逻辑回归要长，但是准确率要高很多）：

第91个时期，费用= 0.054484，准确率= 97.58％第92个时期，费用= 0.053753，准确率= 97.56％第93个时期，费用= 0.053036，准确率= 97.60％第94个时期，费用= 0.052332，准确率= 97.61％第95个时期，费用= 0.051641，准确率= 97.63％第96个时期，费用= 0.050964，准确率= 97.66％第97个时期，费用= 0.050298，准确率= 97.66％第98个时期，费用= 0.049645，准确率= 97.67％第99个时期，费用= 0.049003，准确率= 97.67％第100个时期，费用= 0.048373，准确率= 97.68％

以上が機械学習 | PyTorch の簡潔なチュートリアル パート 1の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。