Maschinelles Lernen |. PyTorch Kurzanleitung Teil 1

In den vorherigen Artikeln wurden Funktionsnormalisierung und Tensoren vorgestellt. Als Nächstes werde ich zwei kurze Tutorials zu PyTorch schreiben, in denen hauptsächlich einfache Praktiken von PyTorch vorgestellt werden.

1 Abbildung 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) Beginnen Sie mit der Hauptfunktion Torch.manual_seed(42) wird verwendet, um den Startwert des Zufallszahlengenerators festzulegen, um sicherzustellen, dass die Folge der generierten Zufallszahlen jedes Mal dieselbe ist run. Diese Funktion akzeptiert eine Ganzzahl. Parameter dienen als Startwerte und können in Szenarien verwendet werden, die Zufallszahlen erfordern, wie z. B. das Training neuronaler Netze, um die Wiederholbarkeit der Ergebnisse sicherzustellen =False) wird verwendet, um eine Menge von Werten mit gleichem Abstand innerhalb des Intervalls zu generieren. Diese Funktion akzeptiert drei Parameter: Startwert, Endwert und Anzahl der Elemente und gibt einen Tensor zurück, der die angegebene Anzahl von Werten mit gleichem Abstand enthält

(3) Interne Implementierung von build_model1:

torch.nn.Sequential(torch.nn.Linear(1, 1, Bias=False)) verwendet den Konstruktor der Klasse nn.Sequential und übergibt die lineare Ebene als ein Parameter und gibt ein neuronales Netzwerkmodell zurück, das die lineare Schicht enthält.

build_model2 hat die gleiche Funktion wie build_model1 und verwendet die Methode add_module(), um ein Submodul mit dem Namen linear hinzuzufügen (reductinotallow='mean') definiert die Verlustfunktion; Verwenden Sie optim.SGD(model.parameters(), lr=0,01, momentum=0,9), um den Stochastic Gradient Descent (SGD)-Optimierungsalgorithmus zu implementieren

Setzen Sie den Trainingssatz ein durch die Batch-Größe Aufteilen, Schleife 100 Mal

(7) Als nächstes kommt die Trainingsfunktion train, die zum Trainieren eines neuronalen Netzwerkmodells verwendet wird. Diese Funktion akzeptiert insbesondere die folgenden Parameter:

model: normalerweise neuronales Netzwerkmodell eine von der Instanz der Klasse nn.Module geerbte;

Verlustfunktion, die zur Berechnung der Differenz zwischen dem vorhergesagten Wert und dem wahren Wert des Modells verwendet wird;
• Optimierer: zur Aktualisierung der Parameter des Modells;
• x: Eingabedaten, ist ein Tensor vom Typ Torch.Tensor;

y: Zieldaten, ist ein Tensor vom Typ Torch.Tensor;

(8) Zug ist eine häufig verwendete Methode im PyTorch-Trainingsprozess. und seine Schritte sind wie folgt:

Setzen Sie das Modell in den Trainingsmodus, das heißt, aktivieren Sie spezielle Vorgänge, die während des Trainings verwendet werden, wie z.

Übergeben Sie die Eingabedaten an das Modell, berechnen Sie den vorhergesagten Wert des Modells und übergeben Sie den vorhergesagten Wert und die Zieldaten an die Verlustfunktion, um den Verlustwert zu berechnen.
• Backpropagieren Sie den Verlustwert und berechnen Sie den Gradienten der Modellparameter ;
• Verwenden Sie den Optimierer, um die Modellparameter zu aktualisieren. Transformieren Sie den Verlustwert.
• (9) print("Round = %d, loss value = %s" % (i + 1, Kosten / num_batches)) Drucken Sie abschließend die aktuelle Trainingsrunde und den Verlustwert aus:

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

3. Die logistische Regression verwendet eine Kurve, um die Flugbahn einer Reihe diskreter Punkte ungefähr darzustellen, wie in der Abbildung gezeigt :

Abbildung 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) Beginnen Sie mit der Hauptfunktion, Torch.manual_seed(42) wird oben vorgestellt, überspringen Sie sie hier;
• (2) Load_mnist dient dazu, den Mnist-Datensatz selbst herunterzuladen, und trX und teX als Eingabedaten zurückgeben, trY und teY sind Etikettendaten;
• (3) interne Implementierung von build_model: Torch.nn.Sequential(torch.nn.Linear(input_dim, Output_dim, Bias=False)) wird verwendet Erstellen Sie ein neuronales Netzwerkmodell, das eine lineare Schicht enthält. Die Anzahl der Eingabemerkmale des Modells ist input_dim, die Anzahl der Ausgabemerkmale ist output_dim und die lineare Schicht hat keinen Bias-Term, wobei n_classes = 10 bedeutet, dass 10 Kategorien ausgegeben werden. Nach dem Umschreiben: (3) Interne Implementierung von build_model: Verwenden Sie Torch.nn.Sequential (Torch.nn.Linear (Input_dim, Output_dim, Bias = False)), um ein neuronales Netzwerkmodell zu erstellen, das eine lineare Ebene enthält input_dim. Die Anzahl der Ausgabe-Features ist Output_dim, und die lineare Ebene hat keinen Bias-Term. Unter anderem bedeutet n_classes=10 die Ausgabe von 10 Kategorien (Modell .parameters(), lr=0,01, Impuls=0,9) kann den Optimierungsalgorithmus Stochastic Gradient Descent (SGD) implementieren
• (6) Nach jeder Trainingsrunde muss die Vorhersagefunktion ausgeführt werden, um Vorhersagen zu treffen. Diese Funktion akzeptiert zwei Parameter: model (das trainierte Modell) und teX (die Daten, die vorhergesagt werden müssen). Die spezifischen Schritte sind wie folgt:
• • 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％

  
  

Das obige ist der detaillierte Inhalt vonMaschinelles Lernen |. PyTorch Kurzanleitung Teil 1. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!