I am not understand this line

[ammarsaf]

I have completed the course but I don't understand this one line;

train_acc += (y_prediction_class == y).sum().item() / len(y_prediction)

what and why you used it instead of using the previous accuracy_function

def accuracy_function(y_true, y_pred):
    correct = torch.eq(y_true, y_pred).sum().item()
    acc = (correct/len(y_pred)) * 100
    return acc

Hopefully anyone can explain this to me. Huge thanks.

[AlienSarlak]

Hi,

I am still learning, but they are the same. Aren't they?
train_acc += (y_prediction_class == y).sum().item() / len(y_prediction)

By
(y_prediction_class == y).sum().item()
You count the number of classes they predicted precisely like the actual class label "y". (Summing them up)
Then you divided this number (sum of all corrected predictions) by the " len(y_prediction)". Which is the per cent of accuracy in decimal points [0-1.0]. e.g. 0.2 instead of, let's say, 20%

[ammarsaf]

What does the y_prediction_class == y means? Why there is a operator == for this?

[AlienSarlak]

Hi,

The == means 0 or 1 in case the two variables are equal it's 1 otherwise it's 0. So, it counts the number of cases in which y and y_pred are equal. Which is the main idea of accuracy calculation.
Because we are looking for all cases in which our model predicts like the ground truth label here (y == y_pred)

[AlienSarlak]

Is your question still unanswered? If not have a look at the below example it might help:

This part makes two random boolean list of size 10 each:

import torch
torch.manual_seed(SEED)
X = torch.randint(0, 2, (10,))
Y = torch.randint(0, 2, (10,))


Output: 
```python
(tensor([0, 1, 0, 1, 1, 1, 1, 0, 1, 1])
 tensor([0, 1, 1, 0, 1, 1, 1, 1, 1, 1]))

Then by the following line we actually count the indices where two arrays have the same value:

sum = (X == Y).sum()

The output is look like:

tensor(7) 

And to get the value itself:

sum = sum.item()

Output:

7.0

Which means that 7 entries in the arrays have the same values:

[**0**, **1**, 0, 1, **1**, **1**, **1**, 0, **1**, **1**]
[**0**, **1**, 1, 0, **1**, **1**, **1**, 1, **1**, **1**]

Now if we divide this value (sum) by the length of array (either X or Y because they have same size (10)) we have the percentage of similarity (in our context can interpret as accuracy):

acc = sum / len(X)

The output is:

0.7

Which we can multiply it by 100 and return it as a percentage of accuracy:

print(f"{(sum/len(X))*100}%")

Output:

70.0%

[mrdbourke]

Thank you for helping! Formatted the answer slightly and marked it as correct.

[mrdbourke]

Hi @Ammar-Azman,

@AlienSarlak is correct (in the above), the two equations are the same.

You can use both of them or either of them.

== is the equality operator.

With tensors, it's basically like saying "are the elements in this tensor equal to the elements in this other tensor?

See this example:

import torch

# Create three tensors
A = torch.tensor([1, 2, 3])
B = torch.tensor([1, 2, 3])
C = torch.tensor([4, 5, 6])

# See if they are equal
print(A == B) # equal 
print(A == C) # not equal
print(B == C) # not equal

>>> 
tensor([True, True, True])
tensor([False, False, False])
tensor([False, False, False])

[ammarsaf]

I see. So if the value is equal, then sum the value up?