In [0]:
import sklearn.datasets
import numpy as np
import pandas as pd
In [0]:
breast_cancer = sklearn.datasets.load_breast_cancer()
In [0]:
y = breast_cancer.data
x = breast_cancer.target
In [0]:
df = pd.DataFrame(breast_cancer.data,columns = breast_cancer.feature_names)
In [0]:
df['class'] = breast_cancer.target
In [0]:
df.describe()
Out[0]:
In [0]:
df.groupby('class').mean()
Out[0]:
Train_test_split¶
In [0]:
from sklearn.model_selection import train_test_split as tt
In [0]:
x = df.drop('class',axis = 1)
y = df['class']
In [0]:
x_train,x_test,y_train,y_test=tt(x,y,test_size = 0.5,stratify = y,random_state = 1)
In [0]:
print(x_train.shape,y_test.shape)
In [0]:
print(y_train.mean(),y.mean(),y_test.mean())
In [0]:
print(x.mean(),x_train.mean(),x_test.mean())
Binarization of input¶
In [0]:
import matplotlib.pyplot as plt
In [0]:
plt.plot(x_test.T,'*')
plt.xticks(rotation = 'vertical')
plt.show()
In [0]:
binx_train = x_train['mean area'].map(lambda x:0 if x <1000 else 1)
In [0]:
plt.plot(binx_train,'*')
Out[0]:
In [0]:
x_bin_train = x_train.apply(pd.cut, bins = 2 ,labels=[1,0])
x_bin_test= x_test.apply(pd.cut, bins = 2 ,labels=[1,0])
plt.plot(x_bin_train.T,'*')
plt.xticks(rotation = 'vertical')
plt.show()
In [0]:
x_bin_train = x_bin_train.values
x_bin_test= x_bin_test.values
MP Neuron Model¶
In [0]:
from random import randint
In [0]:
def DSE(y,yp):
return(np.dot((y-yp).T,(y-yp)))
In [0]:
def Acc(y,yp):
return((list((y-yp)).count(0))/len(y))
In [0]:
for i in range(x_bin_train.shape[1] + 1):
y_pred = []
for x , y in zip(x_bin_train,y_train):
if np.sum(x) >= i:
y_pred.append(1)
else:
y_pred.append(0)
print('For b = ',i,'DSE =',DSE(np.asarray(y_pred),np.asarray(y_train)),'Accuracy =',Acc(np.asarray(y_pred),np.asarray(y_train)))
Now going to check the test data for accuracy
In [0]:
from sklearn.metrics import accuracy_score
In [0]:
y_pred = []
b = 28
for x in x_bin_test:
if np.sum(x) >= b:
y_pred.append(1)
else:
y_pred.append(0)
print('For b = ',b,'DSE =',DSE(np.asarray(y_pred),np.asarray(y_test)),'Accuracy =',Acc(np.asarray(y_pred),np.asarray(y_test)))
print('For b = ',b,'DSE =',DSE(np.asarray(y_pred),np.asarray(y_test)),'Accuracy =', accuracy_score(y_test,y_pred))
In [0]:
class MPneuron():
def __init__(self):
self.b = 0
def model(self,X):
return(np.sum(X)>=self.b)
def predict(self,X):
y = []
for i in X:
y.append(self.model(i))
return(np.array(y))
def fit(self,X,Y):
acc = {}
for b in range(X.shape[1] + 1):
self.b = b
y_pred = self.predict(X)
acc[b] = accuracy_score(Y,y_pred)
best_b = max(acc,key= acc.get)
self.b = best_b
print(acc)
print('The best b is :',self.b)
print('The optimal Accuracy is :',acc[self.b])
In [0]:
MP = MPneuron()
MP.fit(x_bin_train,y_train)
In [0]:
for i in x_bin_train:
print(np.sum(i))
Perceptron Model¶
In [0]:
class perceptron():
def __init__(self):
self.w = None
self.b = None
self.epoch = 1
def model(self,x):
return 1 if( np.dot(self.w,x) >= self.b ) else 0
def predict(self,x):
y_pred = []
for i in x:
y_pred.append(self.model(i))
return (np.array(y_pred))
def loss(self,y,y_hat):
yl=[]
for i ,j in zip(y,y_hat):
if i != j:
yl.append(1)
else:
yl.append(0)
return(np.sum(np.array(yl)))
def fit(self,x,y,epochs,lr= 1):
wt_matrix = []
acc = 0
if (not epochs):
epochs = self.epoch
self.w = np.ones(x.shape[1])
self.b = 0
accuracy = {}
loss = {}
for i in range(epochs):
for y_acc,x_case in zip(y,x):
y_pred = self.model(x_case)
if y_pred == 0 and y_acc == 1:
self.w = self.w + lr * x_case
self.b = self.b + lr * 1
elif y_pred == 1 and y_acc == 0:
self.w = self.w - lr * x_case
self.b = self.b - lr * 1
wt_matrix.append(self.w)
accuracy[i] = accuracy_score(self.predict(x),y)
loss[i] = self.loss(self.predict(x),y)
if(accuracy[i] > acc):
chptw = self.w
chptb = self.b
self.w = chptw
self.b = chptb
plt.plot(list(accuracy.values()))
plt.show()
plt.plot(list(loss.values()))
plt.show()
self.epoch = max(accuracy,key = accuracy.get)
print('Max accuracy at epoch: ',max(accuracy,key = accuracy.get),'With accuracy :',accuracy[max(accuracy,key = accuracy.get)])
print('Lowest Loss at epoch: ',min(loss,key = loss.get),'With loss :',loss[min(loss,key = loss.get)])
return(np.asarray(wt_matrix))
In [0]:
percep = perceptron()
In [0]:
x_train = np.asarray(x_train)
y_train = np.asarray(y_train)
In [0]:
wt_matrix = percep.fit(x_train,y_train,100)
In [0]:
y_pred = percep.predict(np.asarray(x_test))
accuracy_score(y_test,y_pred)
Out[0]:
In [0]:
plt.plot(percep.w)
plt.show()
In [0]:
%matplotlib inline
from matplotlib import animation, rc
from IPython.display import HTML
In [0]:
fig, ax = plt.subplots()
ax.set_xlim(( 0, wt_matrix.shape[1]))
ax.set_ylim((-10000, 25000))
line, = ax.plot([], [], lw=2)
In [0]:
# animation function. This is called sequentially
def animate(i):
x = list(range(wt_matrix.shape[1]))
y = wt_matrix[i,:]
line.set_data(x, y)
return (line,)
In [0]:
# call the animator. blit=True means only re-draw the parts that have changed.
anim = animation.FuncAnimation(fig, animate,frames=1000, interval=200, blit=True)
In [0]:
HTML(anim.to_html5_video())
Out[0]: