In this bonus exercise, implement the following function that evaluates the predictions of a multiclass classification task using PyTorch:

compute$\_$evaluations$($

logits: torch.Tensor,

targets: torch.Tensor,

num$\_$classes: int

$)->$ tuple$[$torch$.$Tensor, float, float$]$:

The function parameters are described as follows:

$$ logits: A $2$D tensor of shape $($n$\_$samples,num$\_$classes$)$ containing the raw model outputs

for all samples. The data type must be a floating point data type.

$$ targets: A $1$D tensor of shape $($n$\_$samples,$)$ containing the true target class labels for each

sample. The data type must be int. The order of samples is the same as in logits$.$

$$ num$\_$classes: The number of different classes. This must be a single integer.

In the function, you should generate the actual class predictions for each sample from logits and

then compute the confusion matrix, the accuracy and the balanced accuracy. In your implementation, you are only allowed to use PyTorch. Libraries such as scikit$-$learn $($sklearn$)$ are not allowed

in this exercise.

Your function should raise a TypeError if

$$ logits is not a torch.Tensor of floating point data type $($see torch.is$\_$floating$\_$point$).$

$$ targets is not a torch.Tensor of integer data type $($one of torch.uint$8,$ torch.int$8,$

torch.int$16,$ torch.int$32,$ torch.int$64).$

Your function should raise a ValueError if

$$ the shape of logits is not $2$D

$$ the shape of targets is not $1$D$.$

$$ the first dimension of logits does not have the same size as targets

$$ targets is not an integer tensor that contains values smaller than num$\_$classes. Example program execution:

if $\_\_$name$\_\_=="\_\_$main$\_\_"$:

torch.manual$\_$seed$(125)$

logits $=$ torch.rand$($size$=(100,10))*10-5$

targets $=$ torch.randint$($low$=0,$ high$=10,$ size$=(100,))$

num$\_$classes $=10$

confusion$\_$matrix, accuracy, balanced$\_$accuracy $=$

compute$\_$evaluations$($logits$,$ targets, num$\_$classes$)$

print$($confusion$\_$matrix$)$

print$($f$\text{'}$Accuracy: $\{$accuracy:$\mathrm{.}2$f$\}\text{'})$

print$($f$\text{'}$Balanced accuracy: $\{$balanced$\_$accuracy:$\mathrm{.}2$f$\}\text{'})$

Example output $($randomization might vary due to version differences$)$:

tensor$([[2,1,1,1,0,0,0,0,2,0],$

$[2,1,0,1,1,2,1,1,1,1],$

$[2,2,0,1,2,1,1,2,1,1],$

$[1,2,1,3,1,0,0,1,1,3],$

$[0,3,0,2,0,1,0,0,2,1],$

$[1,0,0,0,2,1,0,1,0,0],$

$[0,0,2,2,2,2,1,0,3,1],$

$[0,2,1,2,0,0,1,2,0,1],$

$[0,0,0,0,1,1,0,0,1,2],$

$[1,3,2,0,3,2,2,0,1,1]])$

Accuracy: $0\mathrm{.}12$

Balanced accuracy: $0\mathrm{.}14$