In [2]:

    

import numpy as np


    

In [3]:

    

class Perceptron(object):
    """
    A simple Perceptron classifier
    
    Parameters
    ----------
    eta : float
        Learning rate (between 0.00 and 1.0)
    n_iter : int
        Passes over the training dataset
        
    Attributes
    ----------
    w_ : 1d-array
        Weights after fitting
    errors_ : list
        Number of misclassification in every ephoch
        
    """
    
    def __init__(self, eta, n_iter):
        self.eta = eta
        self.n_iter = n_iter
        
    def fit(self, X,Y):
        """
        Fit training data
        
        Parameters
        ----------
        X: {array-like}, shape = [n_samples, n_features]
            Training vectors, where n_samples is the number of samples and 
            n_features is the number of features
        Y: array-like, shape = [n_samples]
            Target values
        
        Returns
        -------
        self : object
        """
        
        self.w_ = np.zeros(1 + X.shape[1])
        self.errors_= []
        
        for _ in self.n_iter:
            error = 0
            for xi, target in zip(X,Y):
                update = self.eta * (target - self.predict(xi))
                self.w_[1:] += update*xi
                self.w_[0] += update
                errors += int(update != 0.0)
            self.errors_.append(errors)
        return(self)
    
    def net_input(self, X):
        """Calculate net input"""
        return np.dot(X, self.w_[1:] + self.w_[0])
    
    def predict(self, X):
        """Returns class label after after unit step"""    
        return(np.where(self.net_input(X)) >= 0.0, 1, -1)


    

In [5]:

    

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


    

In [7]:

    

df.to_csv("flower_dataset.csv")


#Next we will use perceptron object to run classification on iris dataset


    

In [ ]: