`
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
# 3 input image channel, 16 output channels, 3x3 square convolution kernel
self.conv1 = nn.Conv2d(3,16,kernel_size=3,stride=2,padding=1)
self.conv2 = nn.Conv2d(16, 32,kernel_size=3,stride=2, padding=1)
self.conv3 = nn.Conv2d(32, 64,kernel_size=3,stride=2, padding=1)
self.conv4 = nn.Conv2d(64, 64,kernel_size=3,stride=2, padding=1)
self.pool = nn.MaxPool2d(2, 2)
self.dropout = nn.Dropout2d(0.4)
self.batchnorm1 = nn.BatchNorm2d(16)
self.batchnorm2 = nn.BatchNorm2d(32)
self.batchnorm3 = nn.BatchNorm2d(64)
self.fc1 = nn.Linear(64*14*14,512)
self.fc2 = nn.Linear(512, 256)
self.fc3 = nn.Linear(256, 2)
def forward(self, x):
x = self.batchnorm1(F.relu(self.conv1(x)))
x = self.batchnorm2(F.relu(self.conv2(x)))
x = self.dropout(self.batchnorm2(self.pool(x)))
x = self.batchnorm3(self.pool(F.relu(self.conv3(x))))
x = self.dropout(self.conv4(x))
x = x.view(-1, 64*14*14) # Flatten layer
x = self.dropout(self.fc1(x))
x = self.dropout(self.fc2(x))
x = F.log_softmax(self.fc3(x),dim = 1)
return x
n_epochs = 12
print_every = 10
valid_loss_min = np.Inf
val_loss = []
val_acc = []
train_loss = []
train_acc = []
total_step = len(trainloader)
for epoch in range(1, n_epochs+1):
running_loss = 0.0
# scheduler.step(epoch)
correct = 0
total=0
print(f'Epoch {epoch}\n')
for batch_idx, (data_, target_) in enumerate(trainloader):
#data_, target_ = data_.to(device), target_.to(device)# on GPU
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = model(data_)
loss = criterion(outputs, target_)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
_,pred = torch.max(outputs, dim=1)
correct += torch.sum(pred==target_).item()
total += target_.size(0)
if (batch_idx) % 20 == 0:
print ('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'
.format(epoch, n_epochs, batch_idx, total_step, loss.item()))
train_acc.append(100 * correct / total)
train_loss.append(running_loss/total_step)
print(f'\ntrain loss: {np.mean(train_loss):.4f}, train acc: {(100 * correct / total):.4f}')
batch_loss = 0
total_t=0
correct_t=0
with torch.no_grad():
model.eval()
for data_t, target_t in (testloader):
#data_t, target_t = data_t.to(device), target_t.to(device)# on GPU
outputs_t = model(data_t)
loss_t = criterion(outputs_t, target_t)
batch_loss += loss_t.item()
_,pred_t = torch.max(outputs_t, dim=1)
correct_t += torch.sum(pred_t==target_t).item()
total_t += target_t.size(0)
val_acc.append(100 * correct_t / total_t)
val_loss.append(batch_loss/len(testloader))
network_learned = batch_loss < valid_loss_min
print(f'validation loss: {np.mean(val_loss):.4f}, validation acc: {(100 * correct_t / total_t):.4f}\n')
# Saving the best weight
if network_learned:
valid_loss_min = batch_loss
torch.save(model.state_dict(), 'model_classification_tutorial.pt')
print('Detected network improvement, saving current model')
model.train()
`
I am training on image classification where the size is 224*224. After creating CNN with a few method as shown in the code above, i got the mismatch shape.
Anyone can help?