Hello everyone, my name is Marcin and I’m quite new on Deep Learning. I tried to develop my first model in PyTorch based on Pneumonia analysis dataset. I’m not corious why I’m getting same result on each epoch during the training and validating session. Would someone’s mind to explain me my mistakes to let me improve my knowledge? Thanks!
train_data_path = './chest_xray/train/'
test_data_path = './chest_xray/val/'

train_dataset = torchvision.datasets.ImageFolder(
        root=train_data_path,
        transform=transform,
    )
train_loader = torch.utils.data.DataLoader(
        train_dataset,
        batch_size=batch_size,
        num_workers=0,
        shuffle=True
    )


test_dataset = torchvision.datasets.ImageFolder(
        root=test_data_path,
        transform=transform,
    )
test_loader = torch.utils.data.DataLoader(
        test_dataset,
        batch_size=batch_size,
        num_workers=0,
        shuffle=False
    )

dataloaders = {
    "train" : train_loader,
    "validation" : test_loader
}


class MultilayerNeuralNet(nn.Module):
    def __init__(self, input_size):
        super(MultilayerNeuralNet, self).__init__()    
        # hidden layers sizes, you can play with it as you wish!
        hidden1 = 64
        hidden2 = 32
        hidden3 = 16
        self.pool = nn.MaxPool2d(2, 2)
        self.conv1 = nn.Conv2d(3, 8, 3)        
        self.conv2 = nn.Conv2d(8, 16, 3)
        self.fc1 = nn.Linear(conv_size, hidden1) 
        self.relu1 = nn.ReLU()
        self.fc2 = nn.Linear(hidden1, hidden2) 
        self.relu2 = nn.ReLU()       
        self.fc3 = nn.Linear(hidden2, hidden3)
        self.relu3 = nn.ReLU()
        self.output = nn.Linear(hidden3, 2) 
    
    def forward(self, x):
        '''
        This method takes an input x and layer after layer compute network states.
        Last layer gives us predictions.
        '''
        
        x = x.view(batch_size,channels,hight,width)
        #print(x.shape)
        state = self.pool(F.relu(self.conv1(x)))
        #print("Po pierwszym Conv2d: ",state.shape)
        state = self.pool(F.relu(self.conv2(state)))
        #print("Po drugim Conv2d: ",state.shape)
        state=state.view(-1,conv_size)
        #print("Przed Linear: ",state.shape)
        state = self.fc1(state)
        state = self.relu1(state)
        state = self.fc2(state)
        state = self.relu2(state)
        state = self.fc3(state)
        state = self.relu3(state)
        state = self.output(state)
        return state


# Model, loss and optimizer
model = MultilayerNeuralNet(input_size).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

# set our model in the training mode
def train_model(model, criterion, optimizer, num_epochs):
    liveloss = PlotLosses()
    model = model.to(device)
    
    for epoch in range(num_epochs):
        logs = {}
        for phase in ['train', 'validation']:
            if phase == 'train':
                model.train()
            else:
                model.eval()
            correct = 0
            epoch_loss = 0
            
            
        for inputs, labels in dataloaders[phase]:
            inputs = inputs.reshape(-1, input_size).to(device)
            labels = labels.to(device)
            prediction = model(inputs)
            loss = criterion(prediction, labels)
            
            if phase == 'train':
                optimizer.zero_grad()
                loss.backward()
                optimizer.step() 

            _, predicted = torch.max(prediction, 1)
            epoch_loss += loss.detach() * inputs.size(0)
            correct += torch.sum(predicted == labels.data)
        
        epoch_loss = epoch_loss / len(train_loader.dataset)
        acc = correct.float() / len(test_loader.dataset)
        
        
        prefix = ''
        if phase == 'validation':
            prefix = 'val_'
            
        logs[prefix + 'log loss'] = epoch_loss.item()
        logs[prefix + 'accuracy'] = acc.item()
        print(f'Epoch [{epoch+1}/{num_epochs}]], Loss: {epoch_loss:.4f} Test acc: {acc}')

train_model(model, criterion, optimizer, num_epochs)

The output of the last block is:
Epoch [1/50]], Loss: 0.0022 Test acc: 0.5
Epoch [2/50]], Loss: 0.0022 Test acc: 0.5
Epoch [3/50]], Loss: 0.0022 Test acc: 0.5
Epoch [4/50]], Loss: 0.0022 Test acc: 0.5
Epoch [5/50]], Loss: 0.0022 Test acc: 0.5
Epoch [6/50]], Loss: 0.0022 Test acc: 0.5
Epoch [7/50]], Loss: 0.0022 Test acc: 0.5
Epoch [8/50]], Loss: 0.0022 Test acc: 0.5
Epoch [9/50]], Loss: 0.0022 Test acc: 0.5
Epoch [10/50]], Loss: 0.0022 Test acc: 0.5