Write a function that reports the testing precision, recall and f$1-$score of a classifier based on an artificial neural network. Also report the trained model. $(15\%)$ a$.$ Create a list of NN models, based on the list of numbers in hidden. b$.$ Study the data loader, then, implement the training loop using the provided loss$\_$function and optimizer. c$.$ Study the data loader in the training loop, use the data loader for the testing set. d$.$ Calculate the metrics $($precision$,$ recall and f$1-$score$)$ based on the testing set.

Note: You can increase the max$\_$epoch, and it will take a very long time to train. Note: The example model in this problem is too small and insufficient to solve this problem. If you really want to solve this problem using ANN, you need to use a much bigger one. This problem covers the basics of a neuron network. $```$

import numpy as np

import pandas as pd

from sklearn.model$\_$selection import train$\_$test$\_$split

from sklearn import metrics

import torch

import torch.nn as nn

from torch.utils.data import Dataset, DataLoader

# Problem $2$

## when you include batch size in the training process,

# you need to use dataloader

class MyDataset$($Dataset$)$:

def $\_\_$init$\_\_($self$,$ x$,$ y$)$:

self.X$=$torch.tensor$($X$.$values, dtype$=$torch.float$32)$

self.y$=$torch.tensor$($y$.$values, dtype$=$torch.float$32)$

def $\_\_$len$\_\_($self$)$:

return len$($self$.$y$)$

$```$

$```$

def $\_\_$getitem$\_\_($self$,$ idx$)$:

return self.x$[$idx$],$ self.y$[$idx$]$

def problem$\_2($df$,$ Xlabel, ylabel, hidden$=[3,3,3],$ test$\_$size$=0\mathrm{.}3,$

batch$\_$size$=100,$ learning$\_$rate$=0\mathrm{.}01,$ max$\_$epochs$=50000)$:

# write your logic here, model is the trained ANN model

model $=[]$

precision $=0$

recall $=0$

f$1$score $=0$

random$\_$state $=4320$ # default is $4320$

module $=[]$

# YOUR CODE HERE: create the list of modules

# the output layer is fixed to $1$ neural and sigmoid

module.append$($nn$.$Linear$($hidden $[-1],1))$

module.append$($nn$.$Sigmoid$())$

# create the nn model based on the list

model $=$ nn$.$Sequential$(*$module$)$

# split the dataset

X$\_$train, X$\_$test, y$\_$train, y$\_$test $=$ train$\_$test$\_$split$($df$[$xlabel$],$

df$[$ylabel$],$ test$\_$size$=$test$\_$size, random$\_$state$=$random$\_$state$)$

# create the DataLoader for the training set

mytrain $=$ MyDataset$($x$\_$train, y$\_$train$)$

train$\_$loader $=$ DataLoader$($mytrain$,$ batch$\_$size$=$batch$\_$size,

shuffle$=$False$)$

# use MSE loss function, and SGD optimizer

loss$\_$function $=$ nn$.$MSELoss$()$

optimizer $=$ torch.optim.SGD$($model$.$parameters$(),$ lr$=$learning$\_$rate$)$

# training loop

for epoch in range$($max$\_$epochs$)$:

# you can uncomment the line below,

# to visualize the slow training process

# print$("$Debug: at epoch: $",$ epoch$)$

for data, labels in train$\_$loader:

# YOUR CODE HERE: training loop

# YOUR CODE HERE: follow the training set

# to create dataloader for testing

# then, calculate the metrics

return model, precision, recall, f$1$score

$```$