I get the correct picture however I still not sure my programming is correct or not

Please refer to the attached file -

import numpy as np

class AdalineSGD (object):

def __init__(self, eta=0.01, n_iter=10, shuffle=True, random_state=None, batch=10):

self.batch = 100/batch

self.eta = eta

self.n_iter = n_iter

self.w_initialized = False

self.shuffle = shuffle

self.random_state = random_state

def fit (self,X, y):

self._initialize_weights(X.shape[1])

self.cost_ = []

for i in range(self.n_iter):

if self.shuffle:

X, y=self._shuffle(X,y)

cost = []

mini_X = np.array_split(X,self.batch)

mini_y = np.array_split(y,self.batch)

for xi, target in zip (mini_X, mini_y):

cost.append(self._update_weights(xi, target))

avg_cost = sum(cost)/len(cost)

self.cost_.append(avg_cost)

return self

def partial_fit(self, X, y):

if not self.w_initialized:

self._inintialize_weights(X.shape[1])

if y.ravel().shape[0] > 1:

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

self._update_weights(xi,target)

else:

self._update_weights(X,y)

return self

def _shuffle(self, X, y):

r = np.random.permutation(len(y))

return X[r], y[r]

def _initialize_weights(self, m):

self.w_ = np.zeros(1 + m)

self.w_initialized = True

def _update_weights(self, xi, target):

output = self.activation(self.net_input(xi))

error = (target - output)

self.w_[1:] += self.eta * error.dot(xi)

self.w_[0] += self.eta * error.sum()

cost = 0.5 * (error**2).sum()

return cost

def net_input(self, X):

return np.dot(X, self.w_[1:]) + self.w_[0]

def activation (self, X):

return X

def predict(self, X):

return np.where(self.activation(self.net_input(X))>= 0.0, 1, -1)

import pandas as pd

df = pd.read_csv('https://archive.ics.uci.edu/ml/''machine-learning-databases/iris/iris.data',header=None)

df.tail()

import matplotlib.pyplot as plt

y = df.iloc[0:100,4].values

y = np.where(y=='Iris-setosa',-1,1)

X = df.iloc[0:100,[0,2]].values

X_std = np.copy(X)

X_std[:,0] = (X[:,0]-X[:,0].mean())/X[:,0].std()

X_std[:,1] = (X[:,1]-X[:,1].mean())/X[:,1].std()

ada1 = AdalineSGD(n_iter=15, eta=0.01, random_state=1, batch=1)

ada2 = AdalineSGD(n_iter=15, eta=0.01, random_state=1, batch=2)

ada3 = AdalineSGD(n_iter=15, eta=0.01, random_state=1, batch=10)

ada1.fit(X_std,y)

ada2.fit(X_std,y)

ada3.fit(X_std,y)

plt.plot(range(1, len(ada1.cost_) + 1), ada1.cost_, marker='o', color='blue', label='batch=1')

plt.plot(range(1, len(ada2.cost_) + 1), ada2.cost_, marker='o', color='orange', label='batch=2')

plt.plot(range(1, len(ada3.cost_) + 1), ada3.cost_, marker='o', color='green', label='batch=10')

plt.legend(loc='upper right')

plt.title('Mini-Batch Learning')

plt.xlabel('Epochs')

plt.ylabel('Avaerage Cost')

plt.show()

Please check the programming if you can help