Tôi đang làm CNN với Pytorch cho một nhiệm vụ, nhưng nó sẽ không học và cải thiện độ chính xác. Tôi đã tạo một phiên bản làm việc với bộ dữ liệu MNIST để tôi có thể đăng nó ở đây. Tôi chỉ đang tìm kiếm một câu trả lời là tại sao nó không hoạt động. Kiến trúc rất ổn, tôi đã triển khai nó trong Keras và tôi đã có độ chính xác hơn 92% sau 3 kỷ nguyên. Lưu ý: Tôi đã định hình lại MNIST thành các hình ảnh 60x60 vì đó là cách các hình ảnh trong vấn đề "thực" của tôi.
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)))
Hàm mất, hình dạng đầu ra của mạng và nhãn đích không có ý nghĩa ở đây (ít nhất sự kết hợp này là sai). MNIST có 10 lớp và các nhãn là một số nguyên từ 0 đến 9. BCELoss mong đợi một giá trị duy nhất trong khoảng từ 0 đến 1 cho mỗi mục tiêu. Thay vào đó, bạn nên xuất ra 10 bản ghi (không nhất thiết phải sigmoided) và sau đó sử dụng
—
jodag
nn.CrossEntropyLosscho bài toán phân loại lớp đơn. nn.CrossEntropyLossáp dụng cả softmax và NLLLoss dưới dạng một opperation duy nhất, vì vậy trước tiên đừng dùng softmax.
Ngoài ra, nếu bạn muốn thực hiện một vấn đề hồi quy, tức là ước tính một số thực tế là đầu ra (không được khuyến nghị cho các vấn đề loại phân loại) thì bạn có thể thử
—
jodag
nn.MSELossnhưng sau đó bạn cần điều chỉnh các mục tiêu để chúng nằm trong phạm vi đầu ra sigmoid hoặc don ' t áp dụng sigmoid sau lớp cuối cùng.
Bạn đã có nó để làm việc theo cách này? Bây giờ nó nói với tôi điều đó
—
Nicolas Gervais
RuntimeError: multi-target not supported.
bạn cần phải bóp một kích thước của nhãn (nó phải là một thang đo 1D của số nguyên kích thước của kích thước lô)
—
jodag
comp.ai.neural-netsCâu Hỏi Thường Gặp có một số gợi ý tuyệt vời về nơi để xem xét nếu ròng thần kinh của bạn không được học tập; Tôi khuyên bạn nên bắt đầu từ đó.