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