Pytorch deeplearning
Question:
I am trying to train a model with the data of the size: torch.Size([280652, 87]) and the target: torch.Size([280652, 64]) with 80% in the training data and 20 in the test data.
My code:
#split the data in train and test
X_train, X_test, y_train, y_test = train_test_split(data, target, test_size=0.2)
# convert to torch tensors
train = torch.tensor(X_train.values, dtype=torch.float32)
test = torch.tensor(X_test.values, dtype=torch.float32)
train_target = torch.tensor(y_train.values, dtype=torch.float32)
test_target = torch.tensor(y_test.values, dtype=torch.float32)
# inizializing and forward propagation
class MyModel(nn.Module):
def __init__(self):
super(MyModel, self).__init__()
self.fc1 = nn.Linear(87, 50)# layer 1
self.fc2 = nn.Linear(50, 64)# layer 2
self.relu = nn.ReLU()# aktivation method
def forward(self, x):
x = self.relu(self.fc1(x))
x = self.fc2(x)
return x
#print(shapes)
print(train.shape)
print(train_target.shape)
print(test.shape)
print(test_target.shape)
#trainings datasets
train_dataset = TensorDataset(train, train_target)
train_dataloader = DataLoader(train_dataset, batch_size=64, shuffle=True)
#train_dataloader = DataLoader(train_dataset, batch_size=len(train_dataset), shuffle=False)
test_dataset = TensorDataset(test, test_target)
test_dataloader = DataLoader(test_dataset, batch_size=64, shuffle=False)
#test_dataloader = DataLoader(test_dataset, batch_size=len(test_dataset), shuffle=False)
model = MyModel()
#opimizer (ajust weights) for large amounts
optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()
print(train.shape)
print(train_target.shape)
print(test.shape)
print(test_target.shape)
#train = F.one_hot(train_target.to(torch.int64))
# Train the model
for epoch in range(10):
for i, (inputs, labels) in enumerate(train_dataloader):
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels.float())
loss.backward()
optimizer.step()
# Print the loss every 1000 iterations
if i % 1000 == 0:
print(train.shape)
print(train_target.shape)
print(test.shape)
print(test_target.shape)
print(f"Epoch {epoch+1}, Iteration {i+1}, Loss {loss.item():.4f}")
correct = 0
total = 0
with torch.no_grad():
for inputs, labels in test_dataloader:
outputs = model(inputs)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
predicted = torch.argmax(outputs, dim=1)
#correct += (torch.argmax(predicted, dim=1) == labels).sum().item()
#print(len(labels))
#print(len(predicted))
#print(predicted)
#print(labels)
correct += (predicted == labels).sum().item()
accuracy = 100 * correct / total
print(f"Test Accuracy: {accuracy:.2f}%")
the error accures in the line correct += (predicted == labels).sum().item() with the error: The size of tensor a (19) must match the size of tensor b (64) at non-singleton dimension 1
I have no idea where the 19 comes from and i thought that the batch size shouldnt matter.
Did i forget something or is there a mager error in my code?
I tryed adapting the batch size and the layer sizes and tried some diffrent methods but nothing seems to work right.
Answers:
You have applied the argmax function twice.
Keep in mind, you also have to do apply an argmax for labels because I believe they are one-hot encoded.
I tried this and worked. I don’t have your data so I created some dummy data:
import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.model_selection import train_test_split
import numpy as np
from torch.utils.data import TensorDataset, DataLoader
from sklearn.preprocessing import OneHotEncoder
#dummy data
data = np.random.randn(10000,87)
target = np.random.randint(0, 64, (10000,1))
encoder = OneHotEncoder(sparse=False)
target = encoder.fit_transform(target)
#this part is basically identical to yours
#split the data in train and test
X_train, X_test, y_train, y_test = train_test_split(data, target, test_size=0.2)
# convert to torch tensors
train = torch.tensor(X_train, dtype=torch.float32)
test = torch.tensor(X_test, dtype=torch.float32)
train_target = torch.tensor(y_train, dtype=torch.float32)
test_target = torch.tensor(y_test, dtype=torch.float32)
# inizializing and forward propagation
class MyModel(nn.Module):
def __init__(self):
super(MyModel, self).__init__()
self.fc1 = nn.Linear(87, 50)# layer 1
self.fc2 = nn.Linear(50, 64)# layer 2
self.relu = nn.ReLU()# aktivation method
def forward(self, x):
x = self.relu(self.fc1(x))
x = self.fc2(x)
return x
#print(shapes)
print(train.shape)
print(train_target.shape)
print(test.shape)
print(test_target.shape)
#trainings datasets
train_dataset = TensorDataset(train, train_target)
train_dataloader = DataLoader(train_dataset, batch_size=64, shuffle=True)
#train_dataloader = DataLoader(train_dataset, batch_size=len(train_dataset), shuffle=False)
test_dataset = TensorDataset(test, test_target)
test_dataloader = DataLoader(test_dataset, batch_size=64, shuffle=False)
#test_dataloader = DataLoader(test_dataset, batch_size=len(test_dataset), shuffle=False)
model = MyModel()
#opimizer (ajust weights) for large amounts
optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()
print(train.shape)
print(train_target.shape)
print(test.shape)
print(test_target.shape)
# Train the model
for epoch in range(10):
for i, (inputs, labels) in enumerate(train_dataloader):
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels.float())
loss.backward()
optimizer.step()
# Print the loss every 1000 iterations
if i % 1000 == 0:
print(train.shape)
print(train_target.shape)
print(test.shape)
print(test_target.shape)
print(f"Epoch {epoch+1}, Iteration {i+1}, Loss {loss.item():.4f}")
#now here is the change
correct = 0
total = 0
with torch.no_grad():
for inputs, labels in test_dataloader:
outputs = model(inputs)
#print(outputs.shape)
_, predicted = torch.max(outputs.data, 1)
print(predicted.shape)
total += labels.size(0)
#predicted = torch.argmax(outputs, dim=1)
#correct += (torch.argmax(predicted, dim=1) == labels).sum().item()
#print(len(labels))
#print(len(predicted))
#print(predicted)
#print(labels)
labels = torch.argmax(labels, dim=1)
correct += (predicted == labels).sum().item()
accuracy = 100 * correct / total
print(f"Test Accuracy: {accuracy:.2f}%")
I am trying to train a model with the data of the size: torch.Size([280652, 87]) and the target: torch.Size([280652, 64]) with 80% in the training data and 20 in the test data.
My code:
#split the data in train and test
X_train, X_test, y_train, y_test = train_test_split(data, target, test_size=0.2)
# convert to torch tensors
train = torch.tensor(X_train.values, dtype=torch.float32)
test = torch.tensor(X_test.values, dtype=torch.float32)
train_target = torch.tensor(y_train.values, dtype=torch.float32)
test_target = torch.tensor(y_test.values, dtype=torch.float32)
# inizializing and forward propagation
class MyModel(nn.Module):
def __init__(self):
super(MyModel, self).__init__()
self.fc1 = nn.Linear(87, 50)# layer 1
self.fc2 = nn.Linear(50, 64)# layer 2
self.relu = nn.ReLU()# aktivation method
def forward(self, x):
x = self.relu(self.fc1(x))
x = self.fc2(x)
return x
#print(shapes)
print(train.shape)
print(train_target.shape)
print(test.shape)
print(test_target.shape)
#trainings datasets
train_dataset = TensorDataset(train, train_target)
train_dataloader = DataLoader(train_dataset, batch_size=64, shuffle=True)
#train_dataloader = DataLoader(train_dataset, batch_size=len(train_dataset), shuffle=False)
test_dataset = TensorDataset(test, test_target)
test_dataloader = DataLoader(test_dataset, batch_size=64, shuffle=False)
#test_dataloader = DataLoader(test_dataset, batch_size=len(test_dataset), shuffle=False)
model = MyModel()
#opimizer (ajust weights) for large amounts
optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()
print(train.shape)
print(train_target.shape)
print(test.shape)
print(test_target.shape)
#train = F.one_hot(train_target.to(torch.int64))
# Train the model
for epoch in range(10):
for i, (inputs, labels) in enumerate(train_dataloader):
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels.float())
loss.backward()
optimizer.step()
# Print the loss every 1000 iterations
if i % 1000 == 0:
print(train.shape)
print(train_target.shape)
print(test.shape)
print(test_target.shape)
print(f"Epoch {epoch+1}, Iteration {i+1}, Loss {loss.item():.4f}")
correct = 0
total = 0
with torch.no_grad():
for inputs, labels in test_dataloader:
outputs = model(inputs)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
predicted = torch.argmax(outputs, dim=1)
#correct += (torch.argmax(predicted, dim=1) == labels).sum().item()
#print(len(labels))
#print(len(predicted))
#print(predicted)
#print(labels)
correct += (predicted == labels).sum().item()
accuracy = 100 * correct / total
print(f"Test Accuracy: {accuracy:.2f}%")
the error accures in the line correct += (predicted == labels).sum().item() with the error: The size of tensor a (19) must match the size of tensor b (64) at non-singleton dimension 1
I have no idea where the 19 comes from and i thought that the batch size shouldnt matter.
Did i forget something or is there a mager error in my code?
I tryed adapting the batch size and the layer sizes and tried some diffrent methods but nothing seems to work right.
You have applied the argmax function twice.
Keep in mind, you also have to do apply an argmax for labels because I believe they are one-hot encoded.
I tried this and worked. I don’t have your data so I created some dummy data:
import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.model_selection import train_test_split
import numpy as np
from torch.utils.data import TensorDataset, DataLoader
from sklearn.preprocessing import OneHotEncoder
#dummy data
data = np.random.randn(10000,87)
target = np.random.randint(0, 64, (10000,1))
encoder = OneHotEncoder(sparse=False)
target = encoder.fit_transform(target)
#this part is basically identical to yours
#split the data in train and test
X_train, X_test, y_train, y_test = train_test_split(data, target, test_size=0.2)
# convert to torch tensors
train = torch.tensor(X_train, dtype=torch.float32)
test = torch.tensor(X_test, dtype=torch.float32)
train_target = torch.tensor(y_train, dtype=torch.float32)
test_target = torch.tensor(y_test, dtype=torch.float32)
# inizializing and forward propagation
class MyModel(nn.Module):
def __init__(self):
super(MyModel, self).__init__()
self.fc1 = nn.Linear(87, 50)# layer 1
self.fc2 = nn.Linear(50, 64)# layer 2
self.relu = nn.ReLU()# aktivation method
def forward(self, x):
x = self.relu(self.fc1(x))
x = self.fc2(x)
return x
#print(shapes)
print(train.shape)
print(train_target.shape)
print(test.shape)
print(test_target.shape)
#trainings datasets
train_dataset = TensorDataset(train, train_target)
train_dataloader = DataLoader(train_dataset, batch_size=64, shuffle=True)
#train_dataloader = DataLoader(train_dataset, batch_size=len(train_dataset), shuffle=False)
test_dataset = TensorDataset(test, test_target)
test_dataloader = DataLoader(test_dataset, batch_size=64, shuffle=False)
#test_dataloader = DataLoader(test_dataset, batch_size=len(test_dataset), shuffle=False)
model = MyModel()
#opimizer (ajust weights) for large amounts
optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()
print(train.shape)
print(train_target.shape)
print(test.shape)
print(test_target.shape)
# Train the model
for epoch in range(10):
for i, (inputs, labels) in enumerate(train_dataloader):
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels.float())
loss.backward()
optimizer.step()
# Print the loss every 1000 iterations
if i % 1000 == 0:
print(train.shape)
print(train_target.shape)
print(test.shape)
print(test_target.shape)
print(f"Epoch {epoch+1}, Iteration {i+1}, Loss {loss.item():.4f}")
#now here is the change
correct = 0
total = 0
with torch.no_grad():
for inputs, labels in test_dataloader:
outputs = model(inputs)
#print(outputs.shape)
_, predicted = torch.max(outputs.data, 1)
print(predicted.shape)
total += labels.size(0)
#predicted = torch.argmax(outputs, dim=1)
#correct += (torch.argmax(predicted, dim=1) == labels).sum().item()
#print(len(labels))
#print(len(predicted))
#print(predicted)
#print(labels)
labels = torch.argmax(labels, dim=1)
correct += (predicted == labels).sum().item()
accuracy = 100 * correct / total
print(f"Test Accuracy: {accuracy:.2f}%")