Model accuracy stuck at ~0.5 and loss stuck at ~0.69

cagedgandalf: <p>Hi, I am new to PyTorch. I am trying to make a binary classifier for dogs and cats but the model does not seem to be learning. I suspect it is the way I calculate the accuracy and loss but I am not sure.<br>
How I preprocessed the data:</p>
<pre><code class="lang-auto">class DataProcess:

    def __init__(self):
        self.batch_size = 32
        self.resolution = (64, 64)

    def dataload(self, path):
        mean, std = self.get_mean_std()
        train_t = transforms.Compose([transforms.Resize(self.resolution),
                                      transforms.RandomResizedCrop(self.resolution, ratio=(1.2, 1.2)),
                                      transforms.RandomHorizontalFlip(),
                                      transforms.ToTensor(),
                                      transforms.Normalize(mean, std)])
        test_t = transforms.Compose([transforms.Resize(self.resolution),
                                     transforms.ToTensor()])
        training_set = torchvision.datasets.ImageFolder(path + 'training_set',
                                                        transform=train_t)
        test_set = torchvision.datasets.ImageFolder(path + 'test_set',
                                                    transform=test_t)
        training_set = DataLoader(training_set, batch_size=self.batch_size, shuffle=True)
        test_set = DataLoader(test_set, batch_size=self.batch_size, shuffle=True)
        return training_set, test_set, self.batch_size
</code></pre>
<p>This is my code for the model:</p>
<pre><code class="lang-auto">class ConvNet(nn.Module):

    def __init__(self):
        super(ConvNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, 7)
        self.max_pool1 = nn.MaxPool2d(3, 3)
        self.conv2 = nn.Conv2d(64, 32, 3)
        self.conv3 = nn.Conv2d(32, 64, 3)
        self.avg_pool1 = nn.AvgPool2d(2, 2)
        self.fc1 = nn.Linear(64 * 7 * 7, 500)
        self.fc2 = nn.Linear(500, 1)

    def forward(self, x):
        x = self.max_pool1(f.relu(self.conv1(x)))
        x = f.relu(self.conv2(x))
        x = self.avg_pool1(f.relu(self.conv3(x)))
        x = x.view(-1, 64 * 7 * 7)
        x = f.relu(self.fc1(x))
        x = self.fc2(x)
        return x
</code></pre>
<p>Model training:</p>
<pre><code class="lang-auto">optimizer = optim.Adam(net.parameters(), lr=0.001)
training_bar = ProgressBar(250)  # from my loading bar module
for epoch in range(2):
    running_loss = 0.
    correct = 0.
    net.train()
    for i, training_i in enumerate(training_set, 0):
        data, target = training_i
        target = target.float()
        optimizer.zero_grad()
        output = net(data)
        loss = criterion(output, target.unsqueeze(1))
        loss.backward()
        optimizer.step()
        correct += (output == target.unsqueeze(1)).float().sum()
        running_loss += loss.item()
        acc = correct / ((i + 1) * batch_size)
        training_bar.trainingbar(epoch + 1, 2, acc, loss=running_loss / (i + 1))  # helps me see the progress of the training
print('Finished Training')
</code></pre>
<p>Thanks for the help in advance!!</p>

Abhilash_Srivastava: <p>Your training code looks fine to me. A few things to try out:</p>
<ol>
<li>Check how good your training data is and what’s the datasize like. A larger amount of high quality (and unbiased dataset) would result in a better performance.</li>
<li>Once, you’re happy with the initial model, try different hyperparams (number of conv layers, hidden size, learning rate etc).</li>
<li>Run for more number of epochs. Calculate the average loss for each epoch (not just each iteration).</li>
</ol>