Merge pull request deutranium#180 from Lashuk1729/master

Implemented the Perceptron Algorithm in Python Language.

Author: deutranium

machineLearningAlgorithms/Perceptron/python/README.md

@@ -0,0 +1,30 @@
+# Perceptron Learning Algorithm:
+---
+
+>Note: This code is implemented from algorithm proposed by Frank Rosenblatt in 1943, later refined and carefully analyzed by Minsky and Papert in 1969.
+
+A single perceptron can only be used to implement linearly separable functions. It takes both real and boolean inputs and associates a set of weights to them, along with a bias.
+
+Our goal is to find the w vector that can perfectly classify positive inputs and negative inputs in our data. I will get straight to the algorithm. Here goes:
+
+![perceptron algorithm](./images/algorithm.png "Algorthm")
+
+- We initialize w with some random vector.
+- We then iterate over all the examples in the data, (P U N) both positive and negative examples.
+- Now if an input x belongs to P, ideally the dot product w.x be greater than or equal to 0.
+- And if x belongs to N, the dot product MUST be less than 0.
+---
+
+## Steps to run the code:
+
+1. Make sure you have Python 3.7 and a text editor installed.
+2. Install the required packages using pip install -r requirements.txt.
+3. In the main directory Run `python3 main.py` or `python main.py`.
+4. And wait for the results.
+
+---
+## Result on the Dummy Dataset:
+
+![perceptron result](./images/perceptron.gif "Results After Each Epoch")
+
+Result of Perceptron after Every Epoch

machineLearningAlgorithms/Perceptron/python/images/Acc.png

@@ -0,0 +1,53 @@
+import numpy as np
+from perceptron import Perceptron
+from plotting import plot, plot_error_history
+
+"""0. Create dataset"""
+train_data = (  # x, y, target
+    (0.2, 0.3, 0),
+    (0.8, 7, 0),
+    (2, 1, 0),
+    (2, 4, 0),
+    (1, 1, 0),
+    (2, 1, 0),
+    (2, 2.8, 0),
+    (2, 2.2, 0),
+    (3, 1, 0),
+    (5, 3, 1),
+    (5, 4, 1),
+    (4, 5, 1),
+    (4, 7, 1),
+    (5, 5.1, 1),
+    (5.5, 6, 1),
+    (6, 5, 1),
+    (6, 6.5, 1),
+    (6, 7, 1)
+)
+
+validate_data = (
+    (1, 1),
+    (2, 2),
+    (2, 1),
+    (5, 4),
+    (6, 5),
+    (6, 6)
+)
+
+X_train = np.array([x[:2] for x in train_data])  # list comprehension
+X_validate = np.array([x[:2] for x in validate_data])  # list comprehension
+y = np.array([x[-1] for x in train_data])
+
+"""1.Initialization perceptron"""
+perceptron = Perceptron(epochs=25, eta=0.01)
+
+"""2.perceptron training"""
+perceptron.train(X_train, target=y)
+print(f'Weights: {perceptron.w}')
+
+"""3.Prediction"""
+prediction = perceptron.predict(X_train)
+print(f'Output (Y): {prediction}')
+
+print('last')
+plot(X_train, prediction, perceptron, 25, None, perceptron.w)
+plot_error_history(perceptron.err)

machineLearningAlgorithms/Perceptron/python/images/algorithm.png

@@ -0,0 +1,40 @@
+import numpy as np
+from plotting import plot
+from sklearn.metrics import accuracy_score
+
+"""
+File: perceptron.py
+Author: Lashuk1729
+Description: Perceptron Rule
+"""
+
+
+class Perceptron(object):
+
+    def __init__(self, eta: float = 0.01, epochs: int = 50):
+        self.eta = eta  # learning reate
+        self.epochs = epochs
+
+    def train(self, X: np.ndarray, target: np.ndarray):  # Perceptron Rule
+        self.w = np.zeros(1 + X.shape[1])
+        self.err = []
+
+        print('Training progress..')
+        for epoch in range(self.epochs):
+            errors = 0
+            for x, y in zip(X, target):
+                update = self.eta * (y - self.predict(x))
+                self.w[1:] += update * x
+                self.w[0] += update
+                errors += int(update != 0.0)
+
+            accuracy = int(accuracy_score(self.predict(X), target) * 100)
+            self.err.append(accuracy)
+            plot(X, target, self, epoch, accuracy, self.w)
+        return self
+
+    def dot_product(self, X: np.ndarray) -> np.float64:
+        return np.dot(X, self.w[1:]) + self.w[0]
+
+    def predict(self, X: np.ndarray) -> int:
+        return np.where(self.dot_product(X) >= 0.0, 1, 0)

machineLearningAlgorithms/Perceptron/python/images/perceptron.gif

@@ -0,0 +1,24 @@
+from mlxtend.plotting import plot_decision_regions
+import matplotlib.pyplot as plt
+
+
+def plot(x, prediction, clf, epoch=None, accuracy=None, weights=None):
+    plot_decision_regions(x, prediction, clf=clf)
+
+    plt.title(f'Perceptron {weights}')
+
+    if epoch is not None:
+        plt.annotate(f'Epoch: {epoch}', xy=(2, 0), xytext=(5, 0.5))
+
+    if accuracy is not None:
+        plt.annotate(f'Accuracy: {accuracy}%', xy=(2, 0), xytext=(5, 0))
+
+    plt.xlabel('x')
+    plt.ylabel('y')
+    plt.show()
+
+
+def plot_error_history(err):
+    print(len(err))
+    plt.plot(err)
+    plt.show()

machineLearningAlgorithms/Perceptron/python/main.py

@@ -0,0 +1,4 @@
+mlxtend==0.19.0
+numpy==1.19.5
+matplotlib==3.3.2
+scikit_learn==1.0

machineLearningAlgorithms/Perceptron/python/perceptron.py

@@ -0,0 +1,16 @@
+import numpy as np
+
+
+x = [1, 2]
+w = [1, 1, 1]
+
+
+def net_input(X: np.ndarray) -> np.float64:
+    return np.dot(X, w[1:]) + w[0]
+
+
+def predict(X: np.ndarray) -> int:
+    return 1.0 if net_input(X) >= 0.0 else 0.0
+
+
+print(predict(x))