Hi everyone,
I am training an RNN and have come across the following error
247 input = cast(Tensor, input)
248 batch_sizes = None
--> 249 max_batch_size = input.size(0) if self.batch_first else input.size(1)
250 sorted_indices = None
251 unsorted_indices = None
AttributeError: 'function' object has no attribute 'size'
I understand what the error means, but what I do not understand is why it is happening or where it is occurring. I’d appreciate any feedback if available!
At the risk of not providing enough information this is my training and validation function:
# Training functioN
def train(model, device, train_loader, valid_loader, epochs, learning_rate):
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
train_loss, validation_loss = [], []
train_acc, validation_acc = [], []
for epoch in range(epochs):
#train
model.train()
running_loss = 0.
correct, total = 0, 0
steps = 0
for idx, batch in enumerate(train_loader):
text = batch["Sample"].to(device)
target = batch['Class'].to(device)
print(type(text), text.shape)
target = torch.autograd.Variable(target).long()
target = text.to(device), target.to(device)
# add micro for coding training loop
optimizer.zero_grad()
output = model(text)
loss = criterion(output, target)
loss.backward()
optimizer.step()
steps += 1
running_loss += loss.item()
# get accuracy
_, predicted = torch.max(output, 1)
total += target.size(0)
correct += (predicted == target).sum().item()
train_loss.append(running_loss/len(train_loader))
train_acc.append(correct/total)
print(f'Epoch: {epoch + 1}, '
f'Training Loss: {running_loss/len(train_loader):.4f}, '
f'Training Accuracy: {100*correct/total: .2f}%')
# evaluate on validation data
model.eval()
running_loss = 0.
correct, total = 0, 0
with torch.no_grad():
for idx, batch in enumerate(valid_loader):
text = batch["Sample"].to(device)
print(type(text), text.shape)
target = batch['Class'].to(device)
target = torch.autograd.Variable(target).long()
text, target = text.to(device), target.to(device)
optimizer.zero_grad()
output = model(text)
loss = criterion(output, target)
running_loss += loss.item()
# get accuracy
_, predicted = torch.max(output, 1)
total += target.size(0)
correct += (predicted == target).sum().item()
validation_loss.append(running_loss/len(valid_loader))
validation_acc.append(correct/total)
print (f'Validation Loss: {running_loss/len(valid_loader):.4f}, '
f'Validation Accuracy: {100*correct/total: .2f}%')
return train_loss, train_acc, validation_loss, validation_acc
Model
class VanillaRNN(nn.Module):
def __init__(self, output_size, input_size, RNN_size, fc_size,
device):
super(VanillaRNN, self).__init__()
self.RNN_size = RNN_size
self.fc_size = fc_size
# Define the RNN layer
self.rnn = nn.RNN(input_size, 100, 2)
# Define the fully connected layer
self.fc1 = nn.Linear(100, 11)
self.device = device
def forward(self, inputs):
h_0 = torch.zeros(2, input_size, self.RNN_size).to(self.device)
output, h_n = self.rnn(input, h_0)
h_n = h_n.permute(1, 0, 2)
h_n = h_n.contiguous().reshape(h_n.size()[0], self.RNN_size*self.fc_size)
logits = self.fc(h_n)
return logits
## Uncomment to test VanillaRNN class
sampleRNN = VanillaRNN(11, 300, 100, 50, DEVICE)
print(sampleRNN)
And this is where I call the training function
# Model hyperparamters
learning_rate = 1e-3
RNN_size = 100
output_size = 11
input_size = 300
epochs = 10
embed_length = 300
fc_size = 50
# Initialize model, training and testing
set_seed(SEED)
vanilla_rnn_model = VanillaRNN(output_size, input_size, RNN_size, fc_size, DEVICE)
vanilla_rnn_model.to(DEVICE)
vanilla_rnn_start_time = time.time()
vanilla_train_loss, vanilla_train_acc, vanilla_validation_loss, vanilla_validation_acc = train(vanilla_rnn_model, DEVICE, train_loader, valid_loader, learning_rate = learning_rate)