Pembelajaran Mesin |. Tutorial Ringkas PyTorch Bahagian 1

Artikel sebelumnya memperkenalkan penormalan ciri dan tensor Seterusnya, saya akan menulis dua tutorial ringkas tentang PyTorch, terutamanya memperkenalkan amalan mudah PyTorch.

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

(1) Mulakan dengan fungsi utama obor.manual_seed(42) digunakan untuk menetapkan benih penjana nombor rawak untuk memastikan urutan nombor rawak yang dihasilkan adalah sama setiap kali. run. Fungsi ini menerima Parameter integer berfungsi sebagai benih dan boleh digunakan dalam senario yang memerlukan nombor rawak seperti melatih rangkaian saraf untuk memastikan kebolehulangan hasil

(2) torch.linspace(-1, 1, 101, require_grad; =False) digunakan untuk menentukan Hasilkan satu set nilai jarak yang sama dalam selang tersebut Fungsi ini menerima tiga parameter: nilai permulaan, nilai akhir dan bilangan elemen, dan mengembalikan tensor yang mengandungi bilangan nilai yang sama jaraknya

(3) Pelaksanaan dalaman build_model1:

torch.nn.Sequential(torch.nn.Linear(1, 1, bias=False)) menggunakan pembina kelas nn.Sequential, melepasi lapisan linear kepadanya sebagai parameter, dan mengembalikan Model rangkaian saraf yang mengandungi lapisan linear build_model2 mempunyai fungsi yang sama seperti build_model1, menggunakan kaedah add_module() untuk menambah submodul bernama linear padanya; (reductinotallow=' mean') mentakrifkan fungsi kehilangan;

Gunakan optim.SGD(model.parameters(), lr=0.01, momentum=0.9) untuk melaksanakan algoritma pengoptimuman Stochastic Gradient Descent (SGD)

Letakkan set latihan melalui saiz batch Split, loop 100 kali

(7) Seterusnya ialah train function training, yang digunakan untuk melatih model rangkaian saraf Secara khusus, fungsi ini menerima parameter berikut:

model: model rangkaian saraf, biasanya. satu yang diwarisi daripada Contoh kelas nn.Modul;
• x: data input , ialah tensor jenis obor.Tensor
• y: data sasaran, ialah tensor jenis obor.Tensor

(8) kereta api ialah kaedah yang biasa digunakan dalam proses latihan PyTorch, dan langkah-langkahnya adalah seperti berikut:

Tetapkan model kepada mod latihan, iaitu, dayakan operasi khas yang digunakan semasa latihan seperti keciciran dan penormalan kelompok

Kosongkan cache kecerunan pengoptimum untuk pusingan baharu pengiraan kecerunan;

Haruskan data input kepada model , kira nilai ramalan model dan hantar nilai ramalan dan data sasaran kepada fungsi kehilangan untuk mengira nilai kerugian
• Rambat balik nilai kerugian dan kira kecerunan parameter model ;
• Gunakan pengoptimum untuk mengemas kini parameter model untuk meminimumkan Transform nilai kerugian
• Kembalikan nilai skalar bagi nilai kerugian
• (9) print("Round = %d, loss value = %s" %; (i + 1, kos / num_batches)) Akhir sekali, cetak nilai pusingan latihan dan kerugian semasa Output kod di atas adalah seperti berikut:

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

3 Regresi logistik

Regresi logistik menggunakan lengkung untuk mewakili trajektori sekumpulan titik diskret, seperti yang ditunjukkan dalam rajah. :

• Rajah 2

• 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) Mulakan dengan fungsi utama, torch.manual_seed(42) diperkenalkan di atas, langkau di sini
• (2) load_mnist adalah untuk memuat turun set data mnist sendiri dan kembalikan trX dan teX sebagai data input , try dan teY ialah data label
• (3) pelaksanaan dalaman build_model: torch.nn.Sequential(torch.nn.Linear(input_dim, output_dim, bias=False)) digunakan untuk bina model rangkaian saraf yang mengandungi lapisan linear , bilangan ciri input model ialah input_dim, bilangan ciri output ialah output_dim, dan lapisan linear tidak mempunyai istilah bias, di mana n_classes=10 bermakna mengeluarkan 10 kategori; Selepas menulis semula: (3) Pelaksanaan dalaman build_model: Gunakan torch.nn.Sequential(torch.nn.Linear(input_dim, output_dim, bias=False)) untuk membina model rangkaian neural yang mengandungi lapisan linear Bilangan ciri input model ialah input_dim Bilangan ciri output ialah output_dim, dan lapisan linear tidak mempunyai istilah bias. Antaranya, n_classes=10 bermaksud mengeluarkan 10 kategori;
• (4) Langkah-langkah lain adalah untuk menentukan fungsi kehilangan, pengoptimum keturunan kecerunan, membahagikan set latihan melalui saiz_kelompok, dan gelung 100 kali untuk kereta api

Gunakan optim.SGD (model .parameters(), lr=0.01, momentum=0.9) boleh melaksanakan algoritma pengoptimuman Stochastic Gradient Descent (SGD)

(6) Selepas setiap pusingan latihan, fungsi ramalan perlu dilaksanakan untuk membuat ramalan. Fungsi ini menerima dua model parameter (model terlatih) dan teX (data yang perlu diramalkan). Langkah-langkah khusus adalah seperti berikut:

• 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％

Atas ialah kandungan terperinci Pembelajaran Mesin |. Tutorial Ringkas PyTorch Bahagian 1. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!