Maison > Article > Périphériques technologiques > Apprentissage automatique | Tutoriel concis PyTorch, partie 1
Les articles précédents ont présenté la normalisation des fonctionnalités et les tenseurs. Ensuite, j'écrirai deux tutoriels concis sur PyTorch, présentant principalement des pratiques simples de PyTorch.
1 Figure 1import 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) Commencez par la fonction principale torch.manual_seed(42) est utilisé pour définir la graine du générateur de nombres aléatoires afin de garantir que la séquence de nombres aléatoires générée est la même à chaque fois. run. Cette fonction accepte un nombre entier. Les paramètres servent de graines et peuvent être utilisés dans des scénarios qui nécessitent des nombres aléatoires tels que la formation de réseaux de neurones pour garantir la répétabilité des résultats
torch.nn.Sequential(torch.nn.Linear(1, 1, biais=False)) utilise le constructeur de la classe nn.Sequential, lui passe la couche linéaire comme un paramètre et renvoie Un modèle de réseau neuronal contenant la couche linéaire ; build_model2 a la même fonction que build_model1, en utilisant la méthode add_module() pour y ajouter un sous-module nommé Linear ; (reductinotallow='mean') définit la fonction de perte ;
Utilisez optim.SGD(model.parameters(), lr=0.01, momentum=0.9) pour implémenter l'algorithme d'optimisation de descente de gradient stochastique (SGD)Mettez l'ensemble d'entraînement à travers la taille du lot Split, bouclez 100 fois (7) Vient ensuite la fonction de formation train, qui est utilisée pour former un modèle de réseau neuronal. Plus précisément, cette fonction accepte les paramètres suivants :x : données d'entrée, est un tenseur de type torch.Tensor ;
y : données cibles, est un tenseur de type torch.Tensor
(8) train est une méthode couramment utilisée dans le processus de formation PyTorch, et ses étapes sont les suivantes :a + b:[5 7 9]a - b:[-1 -1 -1]a * b:[ 6 12 20]a / b:[0.6666667 0.750.8]
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()
(3) implémentation interne de build_model : torch.nn.Sequential(torch.nn.Linear(input_dim, output_dim, biais=False)) est utilisé pour construire un modèle de réseau neuronal contenant une couche linéaire, le nombre d'entités d'entrée du modèle est input_dim, le nombre d'entités de sortie est output_dim et la couche linéaire n'a pas de terme de biais, où n_classes=10 signifie produire 10 catégories ; Après réécriture : (3) Implémentation interne de build_model : utilisez torch.nn.Sequential(torch.nn.Linear(input_dim, output_dim,bias=False)) pour créer un modèle de réseau neuronal contenant une couche linéaire. Le nombre de fonctionnalités d'entrée du modèle est. input_dim. Le nombre d'entités en sortie est output_dim et la couche linéaire n'a pas de terme de biais. Parmi eux, n_classes=10 signifie générer 10 catégories ;
Utilisez optim.SGD ; (model .parameters(), lr=0.01, momentum=0.9) peut implémenter l'algorithme d'optimisation de descente de gradient stochastique (SGD)
(6) Après chaque cycle d'entraînement, la fonction de prévision doit être exécutée pour faire des prédictions. Cette fonction accepte deux paramètres modèle (le modèle entraîné) et teX (les données qui doivent être prédites). Les étapes spécifiques sont les suivantes :
(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%
一个经典的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%
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!