The following code is a perceptron implementation $($with three do$-$nothing lines $59-61).$

import numpy as np

class Perceptron$($object$)$:

$"""$Perceptron classifier.

Parameters

$-----------\_$

n$\_$iter : int

Passes over the training dataset.

random$\_$state : int

Random number generator seed for random weight

initialization.

Attributes

$\_-----------$

w$\_$ : $1$d$-$array

Weights after fitting.

errors$\_$ : list

Number of misclassifications $($updates$)$ in each epoch.

iter$\_$trained : int

The number of iterations it took for training.

$"!"!$

def $($self$,$ n$\_$iter$=50,$ random$\_$state$=1)$:

self.n$\_$iter $=$ n$\_$iter

self.random$\_$state $=$ random$\_$state

self.iter$\_$trained $=-1$

def fit$($self$,$ X$,$ y$)$:

$"""$Fit training data.

Parameters

X : $\{$array$-$like$\},$ shape $=[$n$\_$examples, n$\_$features$]$

Training vectors, where n$\_$examples is the number of examples and

n$\_$features is the number of features.

y : array$-$like, shape $=[$n$\_$examples$]$

Target values.

Returns Returns

self : object

$"\backslash$prime$")$

rgen $=$ np$.$random.RandomState$($self$.$random$\_$state$)$

self.w$\_=$ rgen.normal$($loc$=0\mathrm{.}0,$ scale$=0\mathrm{.}01,$ size$=1+$ X$.$shape$[1])$

self.errors$\_=[]$

for $\_$ in range$($self$.$n$\_$iter$)$:

errors $=0$

for xi$,$ target in zip$($X$,$ y$)$:

update $=$ self.predict$($xi$)-$ target

self.w$\_[1$:$]+=$ update $*$ xi

self.w$\_[0]+=$ update

errors $+=$ int$($update $!=0\mathrm{.}0)$

self.errors$\_.$append$($errors$)$

####### New code for doing nothing. $-$ MEH

this$\_$code$\_$does$\_$nothing $=$ Truereturn self

def net$\_$input$($self$,$ X$)$:

$"""$Calculate net input"""

return np$.$dot$($X$,$ self.w$\_[1$:$])+$ self.w$\_[0]$

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

$"""$Return class label after unit step"""

return np$.$where$($self$.$net$\_$input$($X$)>=0\mathrm{.}0,1,-1)$

There are significant errors and omissions in the above perceptron implementation. Work on the above cell and modify the code so that:

$($i$)$ The lines containing errors are commented out, and new lines are added with corrected code.

$($ii$)$ The omissions are corrected.

$($iii$)$ The fit function stops when no more iterations are necessary, and stores the number of iterations required for the training.

$($iv$)$ The perceptron maintains a history of its weights, i$.$e$.$ the set of weights after each point is processed.

At each place where you have modified the code, please add clear comments surrounding it$,$ similarly to the $"$do$-$nothing" code. Make sure you

evaluate the cell again, so that following cells will be using the modified perceptron. Question $2$: Experimenting with hyperparameters

ppn $=$ Perceptron$($eta$=0\mathrm{.}0001,$ n iter$=20,$ random$\_$state$=1)$

ppn$.$fit$($X$,$ y$)$

plt$.$plot$($range$(1,$ len$($ppn$.$errors$\_)+1),$ ppn$.$errors$\_,$ marker$=\text{'}$o$\text{'})$

plt$.$xticks$($range$(1,21))$ # Set integer x$-$axis labels

plt$.$xlabel$(\text{'}$Epochs$\text{'})$

plt$.$ylabel$(\text{'}$Number of updates'$)$

plt$.$show$()$

Show hidden output

Next steps:

Explain error

Running the above code, you can verify whether your modification in Question $1$ works correctly. The point of this question is to experiment with

the hyperparameter $,$ the learning rate. Here are some specific questions:

$($i$)$ Find values of $$ for which the process requires $10,20,30,$ and $40$ iterations to converge.

$($ii$)$ Is it always the case that raising $$ leads to a reduced $($or equal$)$ number of iterations? Explain with examples.

$($iii$)$ Find two different settings for the random state, that give different convergence patterns for the same value of $.$

$($iv$)$ Based on your experiences in parts $($i$)-($iii$),$ would binary search be an appropriate strategy for determining values of $$ for which the

perceptron converges within a desired number of iterations?

Please give your answers in the cell below.