Calculate train accuracy of the model in segmentation task

I think I don’t have a good understanding of train accuracy. This is the snippet for train the model and calculates the loss and train accuracy for segmentation task.

 for epoch in range(2):  # loop over the dataset multiple times
        
        running_loss = 0
        total_train = 0
        correct_train = 0
        for i, data in enumerate(train_loader, 0):
            # get the inputs
            t_image, mask = data
            t_image, mask = Variable(t_image.to(device)), Variable(mask.to(device))
        

            # zeroes the gradient buffers of all parameters
            optimizer.zero_grad()
            # forward + backward + optimize
            outputs = model(t_image) # forward
            loss = criterion(outputs, mask) # calculate the loss
            loss.backward() # back propagation
            optimizer.step() # update gradients
            running_loss += loss.item()
            
            # accuracy
            _, predicted = torch.max(outputs.data, 1)
            total_train += mask.size(0)
            correct_train += predicted.eq(mask.data).sum().item()
            train_accuracy = 100 * correct_train / total_train
           #avg_accuracy = train_accuracy / len(train_loader)                                     
            
            print('Epoch {}, train Loss: {:.3f}'.format(epoch, loss.item()), "Training Accuracy: %d %%" % (train_accuracy))

I am getting a number like below for the training accuracy which I assume is the amount of pixel which corresponds with the ground truth (mask). is that correct?

Epoch 0, train Loss: 0.721 Training Accuracy: 500300 %
Epoch 0, train Loss: 0.707 Training Accuracy: 676000 %

How can I calculate the accuracy of the network that shows the performance of the model? (ex. The accuracy of the network on the 10000 test images: 54 % in pytorch tutorial but this is for the classification task )

You are currently summing all correctly predicted pixels and divide it by the batch size. To get a valid accuracy between 0 and 100% you should divide correct_train by the number of pixels in your batch.
Try to calculate total_train as total_train += mask.nelement().

2 Likes

@ptrblck yes it works. Thanks a lot

1 Like

I this piece of code of yours

# accuracy
            _, predicted = torch.max(outputs.data, 1)
            total_train += mask.size(0)
            correct_train += predicted.eq(mask.data).sum().item()`

what are you trying to do in first line with torch.max especially why 1 and not 0. In 3rd line with predicted.eq()

1 Like

@singhvishal0209 sorry for late reply.

first line: return the indices of max values along rows in softmax probability output (torch.max returns a tuple containing the maximum value and the index of the maximum value within the tensor. Since the index in our case represents the classified category itself, we will only take that ignoring the actual probability).

second line: number of pixel in the batch

third line: By summing the output of the .eq() function, we get a count of the number of times the neural network has produced a correct output, and we take an accumulating sum of these correct predictions so that we can determine the accuracy of the network.