Ein PyTorch-Leitfaden für Anfänger

Bild vom Herausgeber | Midjourney & Canva

Deep Studying wird in vielen Bereichen der künstlichen Intelligenzforschung eingesetzt und hat zu technologischen Fortschritten beigetragen. So basieren beispielsweise Anwendungen zur Textgenerierung, Gesichtserkennung und Sprachsynthese auf Deep-Studying-Forschung.

Eines der am häufigsten verwendeten Deep Studying-Pakete ist PyTorch. Es ist ein Open-Supply-Paket, das 2016 von Meta AI erstellt wurde und seitdem von vielen verwendet wird.
PyTorch bietet zahlreiche Vorteile, darunter:

• Versatile Modellarchitektur
• Native Unterstützung für CUDA (kann GPU verwenden)
• Python-basiert
• Bereitstellung von Steuerelementen auf niedrigerer Ebene, die für die Forschung und viele Anwendungsfälle nützlich sind
• Aktive Weiterentwicklung durch Entwickler und Neighborhood

Lassen Sie uns mit diesem Artikel PyTorch erkunden, um Ihnen den Einstieg zu erleichtern.

Vorbereitung

Besuchen Sie die Installationswebseite und wählen Sie diejenige aus, die den Anforderungen Ihrer Umgebung entspricht. Der folgende Code ist das Installationsbeispiel.

pip3 set up torch torchvision torchaudio --index-url https://obtain.pytorch.org/whl/cpu

Nachdem PyTorch bereit ist, kommen wir zum zentralen Teil.

PyTorch-Tensor

Tensor ist der Baustein in PyTorch. Er ähnelt dem NumPy-Array, hat aber Zugriff auf eine GPU. Wir können versuchen, mit dem folgenden Code einen PyTorch-Tensor zu erstellen:

a = torch.tensor((2, 4, 5))
print(a)

Output>> 
tensor((2, 4, 5))

Wie der NumPy-Array-Tensor ermöglicht es Matrixoperationen.

e = torch.tensor(((1, 2, 3),
                (4, 5, 6)))
f = torch.tensor((7, 8, 9))

print(e * f)

Output>>
tensor((( 7, 16, 27),
        (28, 40, 54)))

Es ist auch möglich, eine Matrizenmultiplikation durchzuführen.

g = torch.randn(2, 3)
h = torch.randn(3, 2)
print( g @ h)

Output>> 
tensor(((-0.8357,  0.0583),
        (-2.7121,  2.1980)))

Mit dem folgenden Code können wir auf die Tensor-Informationen zugreifen.

x = torch.rand(3,4)

print("Form:", x.form)
print("Information sort:", x.dtype)
print("System:", x.system)

Output>>
Form: torch.Measurement((3, 4))
Information sort: torch.float32
System: cpu

Coaching neuronaler Netze mit PyTorch

Indem wir das NN mithilfe der Klasse nn.Module definieren, können wir ein einfaches Modell entwickeln. Probieren wir es mit dem folgenden Code aus.

import torch

class SimpleNet(nn.Module):
    def __init__(self, enter, hidden, output):
        tremendous(SimpleNet, self).__init__()
        self.fc1 = torch.nn.Linear(enter, hidden)
        self.fc2 = torch.nn.Linear(hidden, output)
    
    def ahead(self, x):
        x = torch.nn.purposeful.relu(self.fc1(x))
        x = self.fc2(x)
        return x

inp = 10
hid = 10
outp = 2
mannequin = SimpleNet(inp, hid, out)

print(mannequin)

Output>>
SimpleNet(
  (fc1): Linear(in_features=10, out_features=10, bias=True)
  (fc2): Linear(in_features=10, out_features=2, bias=True)
)

Der obige Code definiert eine SimpleNet Klasse, die erbt von nn.Moduledas die Schichten einrichtet. Wir verwenden nn.Linear ist für die Schichten, und relu als Aktivierungsfunktion.

Wir können weitere Schichten hinzufügen oder andere Schichten wie Conv2D oder CNN verwenden. Aber das würden wir nicht verwenden.

Als nächstes trainieren wir die SimpleNet wir haben es mit Beispiel-Tensordaten entwickelt.

import torch

inp = torch.randn(100, 10) 
tar = torch.randint(0, 2, (100,)) 
criterion = torch.nn.CrossEntropyLoss()
optimizr = torch.optim.SGD(mannequin.parameters(), lr=0.01)

epochs = 100
batchsize = 10

for epoch in vary(numepochs):
    mannequin.prepare()
    
    for i in vary(0, inp.dimension(0), batchsize):
        batch_inp = inputs(i:i+batch_size)
        batch_tar = targets(i:i+batch_size)
        
        out = mannequin(batch_inp)
        loss = criterion(out, batch_tar)
     
        optimizer.zero_grad()
        loss.backward()
        optimizr.step()
    
    if (epoch + 1) % 10 == 0:
        print(f'Epoch ({epoch+1}/{num_epochs}), Loss: {spherical(loss.merchandise(),4})')

Während des obigen Trainings verwenden wir zufällige Tensordaten und initiieren die Verlustfunktion namens CrossEntropyLoss. Außerdem starten wir den SGD-Optimierer, um die Modellparameter zu verwalten und den Verlust zu minimieren.

Der Trainingsprozess wird entsprechend der Epochennummern mehrmals ausgeführt und führt dann den Optimierungsprozess durch. Dies ist der übliche Deep-Studying-Prozess.

Wir können einem komplexeren Coaching mehrere Schritte hinzufügen, um es zu verbessern, beispielsweise durch frühzeitiges Stoppen, Lernrate und andere Techniken.

Zuletzt können wir das Modell auswerten, das wir mit den unbekannten Daten trainiert haben. Der folgende Code ermöglicht uns dies.

from sklearn.metrics import classification_report

mannequin.eval()
test_inputs = torch.randn(20, 10)
test_targets = torch.randint(0, 2, (20,))

with torch.no_grad():
    test_outputs = mannequin(test_inputs)
    _, predicted = torch.max(test_outputs, 1)

print(classification_report(test_targets, predicted))

Was oben passiert ist, ist, dass wir das Modell in den Auswertungsmodus geschaltet haben, wodurch Dropout- und Batch-Normalisierungsaktualisierungen deaktiviert wurden. Zusätzlich deaktivieren wir den Gradientenberechnungsprozess, um den Prozess zu beschleunigen.

Besuchen Sie die PyTorch-Dokumentation um mehr über Ihre Möglichkeiten zu erfahren.

Abschluss

In diesem Artikel werden wir die Grundlagen von PyTorch durchgehen. Von der Tensorerstellung über Tensoroperationen bis hin zur Entwicklung eines einfachen NN-Modells. Der Artikel ist ein Einführungsartikel, den jeder Anfänger schnell verstehen sollte.

Cornellius Yudha Wijaya ist Information Science Assistant Supervisor und Datenautor. Während seiner Vollzeitbeschäftigung bei Allianz Indonesien teilt er gerne Python- und Datentipps über soziale Medien und in den Medien. Cornellius schreibt über eine Vielzahl von KI- und maschinellen Lernthemen.