[PYTHON] Einführung in Lightning Pytorch

pytorch Ich habe versucht, selbst zu lernen, aber ich bin über verschiedene Dinge gestolpert, also habe ich es zusammengefasst. Insbesondere pytorch Tutorialの一部をGW中に翻訳・若干改良しました。この通りになめて行けば短時間で基本的なことはできるようになると思います。躓いた人、自分で書きながら勉強したい人向けに各章末にまとめのコードのリンクがあるのでよしなにご活用ください。

Eigenschaften von Pytorch

Module importieren

import torch #Grundmodul
from torch.autograd import Variable #Zur automatischen Differenzierung
import torch.nn as nn #Für den Netzwerkaufbau
import torch.optim as optim #Optimierungsfunktion
import torch.nn.functional as F #Verschiedene Funktionen für das Netzwerk
import torch.utils.data #Datensatz lesen bezogen
import torchvision #Bildbezogen
from torchvision import datasets, models, transforms #Verschiedene Datensätze für Bilder

Grob pytorch

Grundlagen der Pytorch

--pytorch führt Operationen mit einem Typ namens Tensor aus

x = torch.Tensor(5, 3) #Definition von 5x3 Tensor
y = torch.rand(5, 3) #Definition des Tensors mit 5x3 Zufallszahlen initialisiert
z = x + y #Eine normale Berechnung ist ebenfalls möglich
x = np.random.rand(5, 3)
y = torch.from_numpy(x)
z = y.numpy()
x = torch.rand(5, 3)
y = Variable(x)
z = torch.pow(y,2) + 2 #y_i**2 + 2

Daten bekommen

Die von pytorch angegebenen Daten müssen Tensor (Zug), Tensor (Ziel) sein. TensorDataset ist eine Funktion, die Datenbeschriftungen gleichzeitig konvertiert. Der DataLoader von pytorch unterstützt nur die Stapelverarbeitung.

train = torch.utils.data.TensorDataset(torch.from_numpy(X_train), torch.from_numpy(y_train))
train_loader = torch.utils.data.DataLoader(train, batch_size=100, shuffle=True)
test = torch.utils.data.TensorDataset(torch.from_numpy(X_test), torch.from_numpy(y_test))
test_loader = torch.utils.data.DataLoader(test, batch_size=100, shuffle=True)

Es ist auch möglich, im Voraus zu mischen, indem shuffle = True usw. gesetzt wird.

Darüber hinaus können Sie Torchvision für die bildverarbeitungsbezogene Verarbeitung verwenden (die Transformation kann die Verarbeitung wie Tensorisierung, Standardisierung und Zuschneiden einheitlich ausführen), und Datensätze wie CIFAR-10 können gelesen werden.

#Bildtransformationsverarbeitung
transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

#CIFAR-Laden des Zugsatzes vor der Umwandlung in 10 Tensoren
rawtrainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True)

#CIFAR-10 Züge,Testset laden
#Transformation wendet Transformation an
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)

#Data Loader anwenden->Dies ermöglicht das gleichzeitige Zuweisen und Mischen von Chargen.
#batch_Geben Sie die Stapelgröße mit der Größe an
#num_Geben Sie an, auf wie viele Kerne Worker Daten laden sollen(Der Standardwert ist nur main)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False, num_workers=2)

Modelldefinition

Sie müssen das Modell wie im folgenden Beispiel definieren --OK wenn Sie init und forward definieren

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(784,500)
        self.fc2 = nn.Linear(500, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = F.log_softmax(self.fc3(x))
        return x

#Modelldefinition
model = Net()

Lernen

Stellen Sie die Verlustfunktion und den Optimierer wie folgt ein

#Festlegen der Verlustfunktion
criterion = nn.CrossEntropyLoss()

#Optimierer angeben
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

Darunter erfolgt das Training. Ich denke, dass der Ablauf ziemlich ähnlich sein wird, also werde ich ihn als Referenz veröffentlichen

#Ausbildung
#Angabe der Anzahl der Epochen
for epoch in range(2):  # loop over the dataset multiple times
    
    #Totalverlust aller Daten
    running_loss = 0.0 
    
    
    for i, data in enumerate(trainloader):
        
        #In Eingabedatenbeschriftungen aufteilen
        # get the inputs
        inputs, labels = data
        
        #In Variable umgewandelt
        # wrap them in Variable
        inputs, labels = Variable(inputs), Variable(labels)

        #Optimierer initialisieren
        # zero the parameter gradients
        optimizer.zero_grad()

        #Eine Reihe von Flüssen
        # forward + backward + optimize
        outputs = net(inputs)
        
        #Hier Kreuz für Etikettendaten-Entropie wird genommen
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        #Anzeige des Verlustes
        # print statistics
        running_loss += loss.data[0]
        if i % 2000 == 1999:    # print every 2000 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print('Finished Training')

Bis zu diesem Punkt befindet sich der Code auch unten. Bitte beziehen Sie sich darauf. Pytorch Tutorial

Modellübertragung und -erhaltung

Modell laden

Da Resnet usw. standardmäßig enthalten sind, kann es gelesen werden

#Laden eines Modells aus dem Resnet
model_ft = models.resnet18(pretrained=True)

Fine Tuning Sie können das Modell auch einfrieren und die letzte Ebene neu schreiben

#Einfrieren des vorgefertigten Modells
for param in model_conv.parameters():
    param.requires_grad = False

#Schreiben Sie die Parameter nur in der letzten Ebene des Modells neu
num_ftrs = model_conv.fc.in_features
model_conv.fc = nn.Linear(num_ftrs, 2)

Modell speichern und laden

Modell speichern

torch.save(model.state_dict(), 'model.pth')

Modell laden

param = torch.load('model.pth')
model = Net() #Erfordert vor dem Laden eine Klassendeklaration
model.load_state_dict(param)

Der Beispielcode für das Transferlernen lautet wie folgt Pytorch Transfer Learning

Anpassen

Selbstgemachte Aktivierungsfunktion

Sie können die Klasse wie folgt definieren und vorwärts und rückwärts schreiben.

class MyReLU(torch.autograd.Function):
    
    #Es müssen nur die Vorwärtsaktivierungsfunktion und die Rückwärtsberechnung beschrieben werden.
    def forward(self, input):
        
        #Wertspeicher
        self.save_for_backward(input)
        
        #Definitionsteil von ReLU
        #x.clamp(min=0) <=> max(x, 0)
        return input.clamp(min=0)

    #Beschreibung der Backpropagation
    #Geben Sie einfach die Verlaufsinformationen zurück
    def backward(self, grad_output):

        #Erinnerte Tensor Anruf
        input, = self.saved_tensors
        
        #Kopieren Sie es so, dass es nicht als Referenz übergeben wird
        grad_input = grad_output.clone()
        
        #input<0 => 0  else input
        grad_input[input < 0] = 0
        return grad_input

Selbstgemachte Verlustfunktion

Wenn Sie eine Klasse für die Verlustfunktion definieren und init und forward schreiben, funktioniert dies.

class TripletMarginLoss(nn.Module):

def __init__(self, margin):
    super(TripletMarginLoss, self).__init__()
    self.margin = margin

def forward(self, anchor, positive, negative):
    dist = torch.sum(
        torch.pow((anchor - positive),2) - torch.pow((anchor - negative),2),
        dim=1) + self.margin
    dist_hinge = torch.clamp(dist, min=0.0)  #max(dist, 0.0)Gleichwertig
    loss = torch.mean(dist_hinge)
    return loss

Dynamisches Netzwerk

Da es sich um ein durch Ausführen definiertes Format handelt, können Sie die Ebenen durch bedingte Verzweigung im vorderen Teil neu anordnen.

class DynamicNet(torch.nn.Module):
    
    #Ebenendefinition
    def __init__(self, D_in, H, D_out):
        super(DynamicNet, self).__init__()
        self.input_linear = torch.nn.Linear(D_in, H)
        self.middle_linear = torch.nn.Linear(H, H)
        self.output_linear = torch.nn.Linear(H, D_out)

    #Zufällig 0 mittlere Schicht~Wechseln Sie zu 3
    def forward(self, x):
        h_relu = self.input_linear(x).clamp(min=0)
        for _ in range(random.randint(0, 3)):
            h_relu = self.middle_linear(h_relu).clamp(min=0)
        y_pred = self.output_linear(h_relu)
        return y_pred

Der richtige Code ist unten Pytorch anpassen


pytorch Es ist wirklich einfach zu bedienen. In Japan scheint es nur Ketten zu geben, aber ich denke, es ist sehr einfach zu schreiben, schnell und bequem. Jeder sollte es versuchen.

Referenzierte Websites

--Pytorch super Einführung http://qiita.com/miyamotok0105/items/1fd1d5c3532b174720cd Verschiedene Dinge werden vom Hintergrund der Pytorch bis zur Basis geschrieben

--PyTorch: Tutorial Japanische Übersetzung http://caffe.classcat.com/2017/04/14/pytorch-tutorial-tensor/ Japanische Übersetzung des Pytorch-Tutorials. Ist es maschinelle Übersetzung? Das ist schwer zu lesen

--tripletLoss Funktion http://docs.chainer.org/en/stable/_modules/chainer/functions/loss/triplet.html Chainers Tripet-Verlust. Kann mit Pytorch in fast derselben Notation geschrieben werden

Recommended Posts

Einführung in Lightning Pytorch
Einführung in PyTorch (1) Automatische Differenzierung
[Details (?)] Einführung in Pytorch ~ CNN von CIFAR10 ~
Einführung in MQTT (Einführung)
Einführung in Scrapy (1)
Einführung in Scrapy (3)
Erste Schritte mit Supervisor
Einführung in Tkinter 1: Einführung
Pytorch super Einführung
Einführung in PyQt
Einführung in Scrapy (2)
[Linux] Einführung in Linux
Einführung in Scrapy (4)
Einführung in discord.py (2)
[PyTorch] Einführung in die Dokumentklassifizierung mit BERT
[Einführung in Pytorch] Ich habe mit sinGAN ♬ gespielt
[Super Einführung in das maschinelle Lernen] Lernen Sie Pytorch-Tutorials
Erste Schritte mit Web Scraping
[PyTorch] Einführung in die Klassifizierung japanischer Dokumente mit BERT
Einführung in nichtparametrische Felder
Einführung in EV3 / MicroPython
Einführung in die Python-Sprache
Einführung in die TensorFlow-Bilderkennung
Einführung in OpenCV (Python) - (2)
[Pytorch] numpy bis Tensor
Einführung in PyQt4 Teil 1
[Super Einführung in das maschinelle Lernen] Lernen Sie Pytorch-Tutorials
Einführung in die Abhängigkeitsinjektion
Einführung in Private Chainer
PyTorch-Einführung (virtuelle Umgebung)
PyTorch Super Einführung PyTorch-Grundlagen
Einführung in das maschinelle Lernen
[Einführung in Pytorch] Ich habe versucht, Cifar10 mit VGG16 ♬ zu kategorisieren
AOJ Einführung in die Programmierung Thema Nr. 1, Thema Nr. 2, Thema Nr. 3, Thema Nr. 4
Einführung in das elektronische Papiermodul
Einführung in den Wörterbuch-Suchalgorithmus
[Lernmemorandum] Einführung in vim
opencv-python Einführung in die Bildverarbeitung
Einführung in Python Django (2) Win
Eine Einführung in das maschinelle Lernen
[Einführung in cx_Oracle] Übersicht über cx_Oracle
Einführung in die Anomalieerkennung 1 Grundlagen
Einführung in RDB mit sqlalchemy Ⅰ
[Einführung in Systre] Fibonacci Retracement ♬
Einführung in die nichtlineare Optimierung (I)
Einführung in die serielle Kommunikation [Python]
AOJ Einführung in die Programmierung Thema Nr. 5, Thema Nr. 6
Einführung in Deep Learning ~ Lernregeln ~
[Einführung in Python] <Liste> [Bearbeiten: 22.02.2020]
Einführung in Python (Python-Version APG4b)
Eine Einführung in die Python-Programmierung
PyTorch Sangokushi (Zünden / Katalysator / Blitz)
[Einführung in cx_Oracle] (8.) Version cx_Oracle 8.0
Einführung in discord.py (3) Verwenden von Stimme
Einführung in die Bayes'sche Optimierung
Tiefe Stärkung des Lernens 1 Einführung in die Stärkung des Lernens