Machine learning question, use jupyter lab, no AI plz:

Import this:

import sys

from packaging import version

import sklearn

import matplotlib.pyplot as plt

import numpy as np

import tensorflow as tf

from sklearn.preprocessing import add$\_$dummy$\_$feature

from sklearn.datasets import make$\_$blobs

from sklearn import metrics #Import scikit$-$learn metrics module for accuracy calculation

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

from sklearn.metrics import confusion$\_$matrix, ConfusionMatrixDisplay

print$("$Sklearn package",sys$.$version$\_$info$)$

print$("$Sklearn package",sklearn.$\_\_$version$\_\_)$

print$("$TensorFlow version:", tf$.\_\_$version$\_\_)$

assert sys$.$version$\_$info $>=(3,7)$

assert version.parse$($sklearn$.\_\_$version$\_\_)>=$ version.parse$("1\mathrm{.}0\mathrm{.}1")$

plt$.$rc$(\text{'}$font$\text{'},$ size$=12)$

plt$.$rc$(\text{'}$axes$\text{'},$ labelsize$=14,$ titlesize$=14)$

plt$.$rc$(\text{'}$legend$\text{'},$ fontsize$=14)$

plt$.$rc$(\text{'}$xtick$\text{'},$ labelsize$=10)$

plt$.$rc$(\text{'}$ytick$\text{'},$ labelsize$=10)$

$----$

Questions:

$7.$ Q$5-$ Constructing three layer neural network for binary classification.

$7\mathrm{.}0\mathrm{.}1.$ Modify the two layer network for binary classification from the tutorial. The new code should have two hidden layers.

def sigmoid$($x$)$:

return $1/(1+$ np$.$exp$(-$x$))$

#Calculating the loss function.

def cross$\_$entropy$($preds$,$ labels$)$:

return $-$np$.$sum$($labels $*$ np$.$log$($preds$)+(1-$ labels$)*$ np$.$log$(1-$ preds$))$

#return $-$np$.$mean$($labels $*$ np$.$log$($preds$)+(1-$ labels$)*$ np$.$log$(1-$ preds$))$

#Write your code here

class ThreeLayersBinaryClassifier$()$:

def $\_\_$init$\_\_($self$,$ input$\_$size, hidden$1\_$size, hidden$2\_$size, output$\_$size, lr$=1$e$-4)$:

$"""$

Initialize the model. Weights are initialized to random values.

w$1$: First layer weights; has shape $($input$\_$size, hidden$\_$size$)$

w$2$: Second layer weights; has shape $($hidden$\_$size, output$\_$size$)$

Inputs:

$-$ input$\_$size: The dimension D of the input data.

$-$ hidden$2\_$size: The number of neurons in the first hidden layer.

$-$ hidden$2\_$size: The number of neurons in the second hidden layer.

$-$ output$\_$size: The number of classes C$.$

$"""$

# reset seed before start

np$.$random.seed$(1)$

#initialize self.w$1,$ self.w$2,$ selfw$3$

#Give X$,$ a matrix with N by D dimensions

#Calculate y$\_$pred, N by $1$

def predict$($self$,$ X$)$:

#calculate z$1$ from X and W$1$ and calculate h$1$ from sigmoid$($z$1)$

#calculate z$2$ from h$1$ and W$2$ and calculate h$2$ from sigmoid$($z$2)$

#calculate z$3$ from h$2$ and W$3$ and calculate y$\_$pred from sigmoid$($z$3)$

y$\_$pred $=$ None

return$($y$\_$pred$)$

def forward$\_$backward$($self$,$ X$,$ y$)$:

loss $=0$

grad$\_$w$1=$ None

grad$\_$w$2=$ None

grad$\_$w$3=$ None

#

return$($loss$,$ grad$\_$w$1,$ grad$\_$w$2,$ grad$\_$w$3)$

def train$($self$,$ X$\_$train, y$\_$train, learning$\_$rate$=1$e$-4,$ epochs$=1000)$:

loss$\_$history $=[]$

for iter in range$($epochs$)$:

print$($iter$)$

#get loss and grad$\_1,$grad$\_2,$ grad$\_3$ from the forward$\_$backward method

#update self.w$1,$self.w$2,$self.w$3$

#loss$\_$history.append$($loss$)$

return $($loss$\_$history$)$

#Testing the three layers network

N$,$ D$\_$in$,$ H$1,$ H$2,$ D$\_$out $=200,2,100,50,1$

np$.$random.seed$(42)$ # to make this code example reproducible

class$\_$centers $=$ np$.$array$([[1\mathrm{.}8,3\mathrm{.}5],[4\mathrm{.}2,6]])$

X$,$ y $=$ make$\_$blobs$($n$\_$samples $=$ N$,$ centers $=$ class$\_$centers, n$\_$features $=$ D$\_$in$,$random$\_$state$=42)$

y $=$ y$.$reshape$(($N$,1))$

print$("$X$.$shape$=",$ X$.$shape, $"$y$.$shape$=",$y$.$shape$)$

plt$.$scatter$($X$[$:$,0],$ X$[$:$,1],$ c$=$y$)$

X$\_$train, X$\_$test, y$\_$train, y$\_$test $=$ train$\_$test$\_$split$($X$,$ y$,$ test$\_$size$=0\mathrm{.}2,$ shuffle$=$False$)$

epochs $=1000$

learning$\_$rate $=0\mathrm{.}01$

print$($D$\_$in$,$ H$1,$ H$2,$ D$\_$out, learning$\_$rate$)$

clf $=$ ThreeLayersBinaryClassifier$($D$\_$in$,$ H$1,$ H$2,$ D$\_$out, learning$\_$rate$)$

loss$\_$path $=$ clf$.$train$($X$\_$train,y$\_$train, learning$\_$rate, epochs$)$

print$("$Three Layers Binary Classification"$)$

print$("$Final Loss",loss$\_$path$[-1])$

#Print Final Prediction

y$\_$pred $=$ clf$.$predict$($X$\_$test$)$ #It has the updated W$1,$ W$2,$ and W$3$

y$\_$pred$[$y$\_$pred$>=\mathrm{.}5]=1$

y$\_$pred$[$y$\_$pred$<\mathrm{.}5]=0$

print$("$Testing Accuracy:", metrics.accuracy$\_$score$($y$\_$test$[$:$,0],$ y$\_$pred$[$:$,0]))$