Ich mache ein CNN mit Pytorch für eine Aufgabe, aber es wird nicht lernen und die Genauigkeit verbessern. Ich habe eine Version erstellt, die mit dem MNIST-Datensatz arbeitet, damit ich sie hier veröffentlichen kann. Ich suche nur nach einer Antwort, warum es nicht funktioniert. Die Architektur ist in Ordnung, ich habe sie in Keras implementiert und hatte nach 3 Epochen eine Genauigkeit von über 92%. Hinweis: Ich habe den MNIST in 60x60-Bilder umgeformt, da die Bilder in meinem "echten" Problem so sind.
import numpy as np
from PIL import Image
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import DataLoader
from torch.autograd import Variable
from keras.datasets import mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
def resize(pics):
pictures = []
for image in pics:
image = Image.fromarray(image).resize((dim, dim))
image = np.array(image)
pictures.append(image)
return np.array(pictures)
dim = 60
x_train, x_test = resize(x_train), resize(x_test) # because my real problem is in 60x60
x_train = x_train.reshape(-1, 1, dim, dim).astype('float32') / 255
x_test = x_test.reshape(-1, 1, dim, dim).astype('float32') / 255
y_train, y_test = y_train.astype('float32'), y_test.astype('float32')
if torch.cuda.is_available():
x_train = torch.from_numpy(x_train)[:10_000]
x_test = torch.from_numpy(x_test)[:4_000]
y_train = torch.from_numpy(y_train)[:10_000]
y_test = torch.from_numpy(y_test)[:4_000]
class ConvNet(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(1, 32, 3)
self.conv2 = nn.Conv2d(32, 64, 3)
self.conv3 = nn.Conv2d(64, 128, 3)
self.fc1 = nn.Linear(5*5*128, 1024)
self.fc2 = nn.Linear(1024, 2048)
self.fc3 = nn.Linear(2048, 1)
def forward(self, x):
x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
x = F.max_pool2d(F.relu(self.conv2(x)), (2, 2))
x = F.max_pool2d(F.relu(self.conv3(x)), (2, 2))
x = x.view(x.size(0), -1)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = F.dropout(x, 0.5)
x = torch.sigmoid(self.fc3(x))
return x
net = ConvNet()
optimizer = optim.Adam(net.parameters(), lr=0.03)
loss_function = nn.BCELoss()
class FaceTrain:
def __init__(self):
self.len = x_train.shape[0]
self.x_train = x_train
self.y_train = y_train
def __getitem__(self, index):
return x_train[index], y_train[index].unsqueeze(0)
def __len__(self):
return self.len
class FaceTest:
def __init__(self):
self.len = x_test.shape[0]
self.x_test = x_test
self.y_test = y_test
def __getitem__(self, index):
return x_test[index], y_test[index].unsqueeze(0)
def __len__(self):
return self.len
train = FaceTrain()
test = FaceTest()
train_loader = DataLoader(dataset=train, batch_size=64, shuffle=True)
test_loader = DataLoader(dataset=test, batch_size=64, shuffle=True)
epochs = 10
steps = 0
train_losses, test_losses = [], []
for e in range(epochs):
running_loss = 0
for images, labels in train_loader:
optimizer.zero_grad()
log_ps = net(images)
loss = loss_function(log_ps, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
else:
test_loss = 0
accuracy = 0
with torch.no_grad():
for images, labels in test_loader:
log_ps = net(images)
test_loss += loss_function(log_ps, labels)
ps = torch.exp(log_ps)
top_p, top_class = ps.topk(1, dim=1)
equals = top_class.type('torch.LongTensor') == labels.type(torch.LongTensor).view(*top_class.shape)
accuracy += torch.mean(equals.type('torch.FloatTensor'))
train_losses.append(running_loss/len(train_loader))
test_losses.append(test_loss/len(test_loader))
print("[Epoch: {}/{}] ".format(e+1, epochs),
"[Training Loss: {:.3f}] ".format(running_loss/len(train_loader)),
"[Test Loss: {:.3f}] ".format(test_loss/len(test_loader)),
"[Test Accuracy: {:.3f}]".format(accuracy/len(test_loader)))
Die Verlustfunktion, die Ausgabeform des Netzwerks und die Zielbezeichnungen sind hier nicht sinnvoll (diese Kombination ist zumindest falsch). MNIST hat 10 Klassen und die Beschriftungen sind ganze Zahlen zwischen 0 und 9. BCELoss erwartet für jedes Ziel einen einzelnen Wert zwischen 0 und 1. Sie sollten stattdessen 10 Logs ausgeben (nicht unbedingt sigmoided) und dann
—
Jodag
nn.CrossEntropyLossfür das Klassifizierungsproblem einer einzelnen Klasse verwenden. nn.CrossEntropyLossWendet sowohl Softmax als auch NLLLoss als eine einzige Operation an, also nicht zuerst Softmax.
Wenn Sie alternativ ein Regressionsproblem durchführen möchten, dh eine tatsächliche Anzahl als Ausgabe schätzen (nicht empfohlen für Probleme mit Klassifizierungstypen), können Sie es versuchen,
—
Jodag
nn.MSELossaber dann müssen Sie entweder die Ziele so anpassen, dass sie in den Bereich der Sigmoid-Ausgabe fallen, oder nicht. t Sigmoid nach der letzten Schicht auftragen.
Hast du es so gemacht? Jetzt sagt es mir das
—
Nicolas Gervais
RuntimeError: multi-target not supported.
Sie müssen eine Dimension von Etiketten quetschen (es sollte ein 1D-Tensor von ganzen Zahlen sein, die die Größe der
—
Stapelgröße haben
comp.ai.neural-netsFAQs finden Sie einige gute Vorschläge, wo Sie suchen müssen, wenn Ihr neuronales Netz nicht lernt. Ich würde empfehlen, dort zu beginnen.