Merge pull request #70 from Krymancer/ml-perceptron

Adding perceptron algorithm

Author: probot-auto-merge[bot]

MachineLearning/Perceptron/CPP/main.cpp

@@ -0,0 +1,123 @@
+#include <iostream>
+#include <cstdlib>
+#include <vector>
+
+using namespace std;
+
+double f(double x){
+    const double m = 0.3;
+    const double b = 0.2;
+    return m * x + b;
+}
+
+class Perceptron{
+    public:
+        vector<double> weights;
+        double lr;
+
+        Perceptron(int inputLength, double learningRate){
+            weights.resize(inputLength,0);
+
+            for(int i=0; i<weights.size(); i++){
+                weights[i] = -1 + 2 * (double)rand()/RAND_MAX;
+            }
+
+            lr = learningRate;
+        }
+
+        double sing(double value){
+            return value > 0 ? 1 : -1;
+        }
+
+        double guess(vector<double> inputs){
+            double sum = 0;
+
+            for(int i=0; i<inputs.size(); i++){
+                sum += inputs[i] * weights[i];
+            }
+
+            return sing(sum);
+        }
+
+        void train(vector<double> inputs, double target){
+            double attempt = guess(inputs);
+            double error = target - attempt;
+
+            for(int i=0; i<weights.size(); i++){
+                weights[i] += error * inputs[i] * lr;
+            }
+        }  
+};
+
+class Point{
+    public:
+        double x,y,label;
+        double bias = 1;
+        
+        Point(){
+            x = -1 + 2 * (double)rand()/RAND_MAX;
+            y = -1 + 2 * (double)rand()/RAND_MAX;
+            label = y >= f(x) ? 1 : -1;
+        }
+};
+
+int main(){
+    srand(time(0));
+
+    int pointssize = 1000;
+    double trainedRate = 0;
+    double untrainedRate = 0;
+
+    Perceptron perceptron(3,0.1);
+
+    vector<Point> points;
+    points.resize(pointssize);
+
+    for(int i=0; i<points.size(); i++){
+        Point p;
+        points[i] = p;
+        //cout << points[i].x << endl;
+    }
+
+    for(int i=0; i<points.size(); i++){
+        vector<double> inputs;
+        inputs.push_back(points[i].x);
+        inputs.push_back(points[i].y);
+        inputs.push_back(points[i].bias);
+
+        double target = points[i].label;
+        double guess = perceptron.guess(inputs);
+
+        if(guess == target){
+            untrainedRate++;
+        }
+    }
+
+    for(int i=0; i<points.size(); i++){
+        vector<double> inputs;
+        inputs.push_back(points[i].x);
+        inputs.push_back(points[i].y);
+        inputs.push_back(points[i].bias);
+        double target = points[i].label;
+
+        perceptron.train(inputs,target);
+    }
+
+    for(int i=0; i<points.size(); i++){
+        vector<double> inputs;
+        inputs.push_back(points[i].x);
+        inputs.push_back(points[i].y);
+        inputs.push_back(points[i].bias);
+
+        double target = points[i].label;
+        double guess = perceptron.guess(inputs);
+
+        if(guess == target){
+            trainedRate++;
+        }
+    }
+
+    cout << "Trained: " << trainedRate/pointssize << " Untrained: " << untrainedRate/pointssize <<  endl;
+
+    return 0;
+}

MachineLearning/Perceptron/JavaScript/main.js

@@ -0,0 +1,102 @@
+class Perceptron{
+    constructor(inputLength, learningRate){
+        this.weights = [];
+        this.learningRate = learningRate;
+
+        for(let i=0; i < inputLength; i++){
+            this.weights[i] = this.random(1,-1);
+        }
+    }
+
+    sing(value){
+        return value > 0 ? 1 : -1;
+    }
+
+    random(max,min){
+        return Math.random() * (max  - min) + min;
+    }
+
+    guess(inputs){
+        let sum = 0;
+
+        this.weights.forEach((weight,index) => {
+            sum += inputs[index] * weight;
+        });
+
+        return this.sing(sum);
+    }
+
+    train(inputs, target){
+        const guess = this.guess(inputs);
+        const error = target - guess;
+
+        for(let i=0; i < this.weights.length; i++){
+            this.weights[i] += error * inputs[i] * this.learningRate;
+        }
+    }
+}
+
+class Point{
+    constructor(){
+        this.x = this.random(1,-1);
+        this.y = this.random(1,-1);
+        //this.label = this.x > this.y ? 1 : -1;
+        this.label = this.y >= f(this.x) ? 1 : -1;
+        this.bias = 1;
+    }
+
+    random(max,min){
+        return Math.random()    * (max  - min) + min;
+    }
+}
+
+function f(x){
+    const m = 0.3;
+    const b = 0.2; 
+    return m * x + b;
+}
+
+function main(){
+    const perceptron = new Perceptron(3,0.1);
+    const points = [];
+    const pointsLenght = 1000;
+    let rate = 0;
+    let untrainedRate = 0;
+
+    for(let i=0; i < pointsLenght; i++){
+        points.push(new Point());
+    }
+    
+    points.forEach(point => {
+        const input = [point.x, point.y, point.bias];
+        const target = point.label;
+        const guess = perceptron.guess(input);
+
+        if(guess === target){
+            untrainedRate++;
+        }
+    });
+
+    points.forEach(point => {
+        const input = [point.x, point.y, point.bias];
+        const target = point.label;
+        
+        perceptron.train(input, target);
+    });
+    
+    points.forEach(point => {
+        const input = [point.x, point.y, point.bias];
+        const target = point.label;
+        const guess = perceptron.guess(input);
+
+        if(guess === target){
+            rate++;
+        }
+    });
+    
+    console.log('Trained:', rate/pointsLenght, 
+                'Untrained:',untrainedRate/pointsLenght);
+}
+
+
+main();