## PERCEPTRON ALGORITHM

### Perceptron Algorithm is one of the most used algorithm in classifying data.It frequently seems little tough while learning first time.

### In today's post , We'll try to understand it well in brief with full explanation.

### Perceptron Algorithm is used whenever given dataset can be classified into two parts or it has only two labels.(One can consider it as +1, -1)

###
__There are three version of Perceptron Algorithm:__

###
- Simple Perceptron
- Average Percepron
- Pegasos Algorithm or Support Vector Machine

Relax! Terms are sounding dangerous but they are really very easy.Let me explain you.

###
__1.Simple Perceptron:__

### The single target of perceptron algorithm is to find a Linear classifier( say Linear equation) on one side of which are all positively labelled point and on another side all negatively labelled points are there.

### As we know any linear equation can be written as,

Y=Î¸.X + Î¸

_{0}###
Using Perceptron Our Aim is to find those value of Î¸ vector and Î¸_{0} , with which formed line divide our dataset into two part , one part of which will be positively labelled and another part will be negatively labelled.See below pic:
_{
}

###
- It is also an iterative method.We'll start with Î¸ = 0 vector and Î¸
_{0=0}

_{In each iteration ,for every data point ,}

_{0=0}_{In each iteration ,for every data point ,}- if ((y
^{i})*(Î¸.x^{i}+Î¸_{0})<=0) : - Update (Î¸=Î¸
_{old }+ (y^{i}.x^{i}))(Î¸_{0}=Î¸_{0 }+ y^{i})

### Reason For above updates can be derived using stochastic gradient descent algorithm.We'll derive above updation.If you are not familiar with Stochastic Gradient Descent ,Click Below Link.

###
__
2. Averaged Perceptron :__

###
In Averaged Perceptron , Our Averaged Perceptron Function returns the average value of Î¸ and Î¸_{0 ,updated in every iteration.While in "Only Perceptron Algorithm" , We return the last updated value of Î¸ and }_{Î¸0 .}

###
_{See the Below Code of a sample implementation}

###
_{ }

###
__3. Pegasos Algorithm/Support Vector Machine:__

### In above two algorithm, we have taken care of getting best linear classifier, Which can well classify our dataset, but what if there are many classifier existing that can classify the dataset in two part.See Below pic

### In above picture, It can be seen quite clearly that all the classifier line is well classifying our training set.

###
If you think little wisely, you can say the classifier with a high margin boundary will be said to best fit.

###

In such a case we should choose, which have large margin(d) on both side (positively labelled and negatively labelled) .

###
Now, there are two things :

- Loss : Loss on misclassifying a data
- Regularization : Responsible for maintaining large boundary

Remember we are concerned only about its correct classification.If our classifier classifies any point wrongly , we will give some penalty to our classifier.
Also Notice if any point will be classified correctly and not on decision boundary, then :

###
label*Y_{predicted} >0

### Since we want no point inside margin boundary too, We'll give penalty, when it will inside margin boundary too.So there will be no loss if :

###
(y^{i}(Î¸.X^{i}+Î¸_{0}))>=1

### Otherwise we'll give some penalty to our model, this is known as Hinge Loss, and it is defined as:

###
H(z)=max{0,1-z}, z=(y^{i}(Î¸.X^{i}+Î¸_{0}))

means , Loss will be zero if z>1 else 1-z

### So, Our Objective function will be

### J = Loss + Regularization

**J(Î¸,Î¸**

_{0}) = (1/n)[Î£_{i}^{n}_{=1}H(y^{i}(Î¸.X

^{i}**+Î¸**

_{0})) + (Î»/2)||Î¸||^{2 }]###
Our target is to find those value of Î¸,Î¸_{0 }For which value of objective function is least or we have to minimize Objective function.We'll do it using Stochastic gradient descent Algorithm

### So, in each iteration we will consider only one point and will calculate cost only for that and update.

**J(Î¸,Î¸**

_{0}) = H(y^{i}(Î¸.X

^{i}**+Î¸**

_{0}^{i})) + (Î»/2)||Î¸||^{2 }**∂H(z)/∂Î¸ = {0 if z>1 ,-∂z/∂Î¸ otherwise}**

^{Since, }
So,the iteration formula from stochastic Gradient Descent:

if z<=1:

Î¸

_{new}=Î¸_{old}- Î·[-y^{i}.x^{i }+Î».Î¸_{old}]**Î¸**

_{new}=Î¸_{old}+Î·y^{i}.x^{i }-**Î·.**

**Î».Î¸**

_{old}**Î¸o**

_{new}=Î¸o_{old}^{ }+**Î·.**

**y**

^{i}

^{}
else:

**Î¸**

_{new}=Î¸_{old}^{ }- Î».Î¸_{old}**Î¸o**

_{new}=Î¸o_{old}**We will make Î· getting decreased as iteration will increase.**

**Try to implement and Uderstand Below code**

If we remove the regularization term , and take

**Î·=1**, it becomes Simple Perceptron Algorithm.

_{}
## 0 Comments