import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from numpy.random import seed
class AdalineGD(object):
def __init__(self,eta=0.01,n_iter=10,shuffle=True,random_state=None):
self.eta = eta
self.n_iter = n_iter
self.shuffle = shuffle
self.w_initialized = False
if random_state:
seed(random_state)
def fit(self,X,y):
self._initialize_weights(X.shape[1])
self.cost_ = []
for _ in range(self.n_iter):
if self.shuffle:
X,y=self._shuffle(X,y)
cost=[]
for xi,target in zip(X,y):
cost.append(self._update_weights(xi,target))
avg_cost=sum(cost)/len(y)
self.cost_.append(avg_cost)
return self
def partial_fit(self,X,y):
if not self.w_initialized:
self._initialize_weights(X.shape[1])
if y.ravel().shape[0]>1:
for xi,target in zip(X,y):
self._update_weights(xi, target)
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.net_input(xi)
error = (target-output)
self.w_[1:]+=self.eta*xi.dot(error)
self.w_[0]+=self.eta*error
cost=0.5*error**2
return cost
def net_input(self,X):
re = np.dot(X,self.w_[1:])+self.w_[0]
return re
def activation(self,X):
return self.net_input(X)
def predict(self,X):
return np.where(self.activation(X)>=0.0,1,-1)
def plot_decision_regions(X,y,classifier,resolution=0.02):
markers=("s",'x','o',"^",'v')
colors=("red","blue","lightgreen","gray","cyan")
cmap = ListedColormap(colors[:len(np.unique(y))])
x1_min,x1_max = X[:,0].min()-1, X[:,0].max()+1
x2_min,x2_max = X[:,1].min()-1, X[:,1].max()+1
xx1,xx2 = np.meshgrid(np.arange(x1_min,x1_max,resolution),np.arange(x2_min,x2_max,resolution))
Z = classifier.predict(np.array([xx1.ravel(),xx2.ravel()]).T)
Z = Z.reshape(xx1.shape)
plt.contourf(xx1,xx2,Z,alpha=0.4,cmap=cmap)
plt.xlim(xx1.min(),xx1.max())
plt.ylim(xx2.min(),xx2.max())
for idx,cl in enumerate(np.unique(y)):
plt.scatter(x=X[y==cl,0],y=X[y==cl,1],alpha=0.8,c=cmap(idx),marker=markers[idx],label=cl)
df = pd.read_csv("https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data",header=None)
y = df.iloc[0:100,4].values
y = np.where(y=="Iris-versicolor",-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()
ada=AdalineGD(0.01,15,random_state=1)
ada.fit(X_std,y)
plot_decision_regions(X_std,y,classifier=ada)
plt.title("Adaline-stochastic Gradient Descent")
plt.xlabel("sepal length [standardized]")
plt.ylabel("petal length [standardized]")
plt.legend(loc="upper left")
plt.show()
plt.plot(range(1,len(ada.cost_)+1),ada.cost_,marker='o')
plt.xlabel("Epochs")
plt.ylabel("Average Cost")
plt.show()
