I’m trying to train an NN on a dataset containg 1d vectors of features.
class data_loader(Dataset):
def __init__(self, data):
data = np.array(data.values, dtype=float)
self.len = data.shape[0]
self.X = torch.from_numpy(data[:, 0:-1])
self.y = torch.from_numpy(data[:, [-1]])
def __getitem__(self, index):
return self.X[index], self.y[index]
def __len__(self):
return self.len
train_set = data_loader(real_train)
train_loader = DataLoader(dataset=train_set,
batch_size=64,
shuffle=True,
num_workers=0)
val_set = data_loader(real_val)
val_loader = DataLoader(dataset=val_set,
batch_size=64,
shuffle=False,
num_workers=0)
class genreNN(nn.Module):
def __init__(self, n_in=26, n_hidden=128, n_out=8, dropout=0.4):
super(genreNN, self).__init__()
self.n_in = n_in
self.n_hidden = n_hidden
self.n_out = n_out
self.dropout = dropout
self.fc = nn.Linear(n_in, n_hidden)
self.drop = nn.Dropout(dropout)
self.out = nn.Linear(n_hidden, n_out)
def forward(self, x):
x = x.view(-1, self.n_in)
sigmoid = nn.Sigmoid()
x = sigmoid(self.fc(x))
x = self.drop(x)
x = F.log_softmax(self.out(x))
return x
model = genreNN()
criterion = nn.NLLLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4)
def train(epoch, model, train_loader, optimizer, print_every=50, cuda=None):
model.train()
correct = 0
for k, (data, target) in enumerate(train_loader):
# if cuda:
# data, target= data.cuda(), target.cuda()
data, target = Variable(data), Variable(target)
optimizer.zero_grad()
output = model(data.float())
pred = output.data.max(1)[1]
correct += pred.eq(target.long().data).cpu().sum()
acc = 100. * correct / len(train_loader.dataset)
loss = F.nll_loss(output, target.long())
loss.backward()
optimizer.step()
if k % print_every == 0:
print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f} Accuracy: {}'.format(
epoch, k * len(data), len(train_loader.dataset),
100. * k / len(train_loader), loss.data[0], acc))
def validate(loss_vec, acc_vec, model, val_loader, cuda=None):
model.eval()
val_loss, correct = 0, 0
for data, target in val_loader:
# if cuda:
# data, target = data.cuda(), target.cuda()
data, target = Variable(data, volatile=True), Variable(target)
output = model(data.float())
val_loss += F.nll_loss(output, target.long()).data[0]
pred = output.data.max(1)[1] # get the index of the max log-probability
correct += pred.eq(target.long().data).cpu().sum()
val_loss /= len(val_loader)
loss_vec.append(val_loss)
acc = 100. * correct / len(val_loader.dataset)
acc_vec.append(acc)
print('\nValidation set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
val_loss, correct, len(val_loader.dataset), acc))
epochs = 100
loss_vec=[]
acc_vec=[]
gpu_available = torch.cuda.is_available()
for e in range(epochs):
train(e, model, train_loader, optimizer, cuda=gpu_available)
validate(loss_vec, acc_vec, model, val_loader, cuda=gpu_available)
I believe the loss function in train()
is causing this error but I don’t know how to fix this