Minor fixes

Fixed weight initialization
Changed activation function output to 0 or 1

Author: 8bitkick

Color_Perceptron/Color_Perceptron.ino

@@ -0,0 +1,141 @@
+/*
+
+  Perceptron example
+
+  Hardware: Arduino Nano BLE Sense
+
+  Usage: Follow the prompts in the Serial Monitor and show two objects of different colors to the color sensor onboard the Arduino.
+  The sketch will train a perceptron using these examples, and then classify objects you show it in the future.
+
+*/
+
+#include <Arduino_APDS9960.h>
+#include <Arduino_Perceptron.h>
+
+const int   NUM_INPUTS          = 3;     // Classifier input is color sensor data; red, green and blue levels
+const int   CLASSES             = 2;     // The perceptron only has 2 possible classes
+const int   EXAMPLES            = 30;   // Number of samples for each object
+const int   MAX_EPOCHS          = 100;   // Maximum training iterations
+const float LEARNING_RATE       = 0.001; // Perceptron learning rate
+const int   THRESHOLD           = 5;     // Color sensor light threshold
+
+float       color[NUM_INPUTS];
+String      label[CLASSES] = {"object A", "object B"};
+
+Perceptron  perceptron(NUM_INPUTS, LEARNING_RATE);
+
+void setup() {
+  Serial.begin(9600);
+  while (!Serial);
+
+  if (!APDS.begin()) {
+    Serial.println("Failled to initialized APDS!");
+    while (1);
+  }
+
+  Serial.println("Arduino perceptron");
+
+  // Get color samples for our two objects
+  // -------------------------------------
+  for (int output = 0; output < 2; output ++) {
+
+    Serial.print("Show me ");
+    Serial.println(label[output]);
+
+    // Wait for the object to move away again
+    while (!APDS.proximityAvailable() || APDS.readProximity() == 0) {}
+
+    for (int n = 0; n < EXAMPLES; n++) {
+
+      // Sample object color - perceptron input
+      readColor(color);
+
+      // Add example color to the perceptron training set
+      perceptron.addExample(color, output);
+    }
+  }
+
+  // Train the perceptron
+  // --------------------
+  Serial.println("\nTraining perceptron");
+  int epoch = 0;
+  float accuracy = 0;
+
+  Serial.print("Start weights:");
+  printWeights();
+
+  while (epoch < MAX_EPOCHS && accuracy < 0.99) {
+    accuracy = perceptron.train();
+    epoch++;
+    Serial.print("Accuracy: ");
+    Serial.println(accuracy);
+  }
+
+  Serial.print("End weights:");
+  printWeights();
+
+
+  Serial.println("Training complete\n");
+}
+
+
+  // Classify objects shown
+  // ----------------------
+void loop() {
+
+  int output;
+
+  // Wait for the object to move away again
+  while (!APDS.proximityAvailable() || APDS.readProximity() == 0) {}
+
+  Serial.println("Let me guess your object");
+
+  // Wait for an object then read its color
+  readColor(color);
+
+  // CLassify the object using the perceptron
+  output = perceptron.classify(color);
+
+  Serial.print("You showed me ");
+  Serial.println(label[output]);
+}
+
+
+void printWeights() {
+  float weights[NUM_INPUTS];
+  perceptron.getWeights(weights);
+
+  Serial.print(weights[0]);
+  Serial.print(",");
+  Serial.print(weights[1]);
+  Serial.print(",");
+  Serial.println(weights[2]);
+}
+
+void readColor(float color[]) {
+  int red, green, blue, proximity, colorTotal = 0;
+
+  // Wait until we have a color bright enough
+  while (colorTotal < THRESHOLD) {
+
+    // Sample if color is available and object is close
+    if (APDS.colorAvailable() && APDS.proximityAvailable() && APDS.readProximity() == 0) {
+
+      // Read color and proximity
+      APDS.readColor(red, green, blue);
+      colorTotal = (red + green + blue);
+    }
+  }
+
+  // Normalise the color sample data and put it in the classifier input array
+  color[0] = (float)red / colorTotal;
+  color[1] = (float)green / colorTotal;
+  color[2] = (float)blue / colorTotal;
+
+  // Print the red, green and blue values
+  Serial.print(color[0]);
+  Serial.print(",");
+  Serial.print(color[1]);
+  Serial.print(",");
+  Serial.println(color[2]);
+}

examples/Color_Perceptron/Color_Perceptron.ino

@@ -1,32 +1,29 @@
 /*
 
-Color_Perceptron.ino
+  Perceptron example
 
-Perceptron color classification example
+  Hardware: Arduino Nano BLE Sense
 
-Hardware: Arduino Nano 33 BLE Sense
-
-Usage: Follow the prompts in the Serial Monitor and show two objects of different colors to the color sensor onboard the Arduino.
-The sketch will train a perceptron using these examples, and then classify objects you show it in the future.
+  Usage: Follow the prompts in the Serial Monitor and show two objects of different colors to the color sensor onboard the Arduino.
+  The sketch will train a perceptron using these examples, and then classify objects you show it in the future.
 
 */
 
 #include <Arduino_APDS9960.h>
 #include <Arduino_Perceptron.h>
 
-const int   NUM_INPUTS          = 3;      // Classifier has 3 inputs - red, green and blue levels
-const int   CLASSES             = 2;      // The perceptron only has 2 possible outputs (-1 and 1)
-const int   EXAMPLES            = 50;     // Number of samples for each object
-const int   MAX_EPOCHS          = 250;    // Maximum training iterations
-const float LEARNING_RATE       = 0.001;  // Perceptron learning rate
-const int   THRESHOLD           = 5;      // Color sensor light threshold
+const int   NUM_INPUTS          = 3;     // Classifier input is color sensor data; red, green and blue levels
+const int   CLASSES             = 2;     // The perceptron only has 2 possible classes
+const int   EXAMPLES            = 30;   // Number of samples for each object
+const int   MAX_EPOCHS          = 100;   // Maximum training iterations
+const float LEARNING_RATE       = 0.001; // Perceptron learning rate
+const int   THRESHOLD           = 5;     // Color sensor light threshold
 
 float       color[NUM_INPUTS];
 String      label[CLASSES] = {"object A", "object B"};
 
 Perceptron  perceptron(NUM_INPUTS, LEARNING_RATE);
 
-
 void setup() {
   Serial.begin(9600);
   while (!Serial);
@@ -38,12 +35,12 @@ void setup() {
 
   Serial.println("Arduino perceptron");
 
-  // Get color examples for the two objects
-  // --------------------------------------
-  for (int output = -1; output < 2; output += 2) {
+  // Get color samples for our two objects
+  // -------------------------------------
+  for (int output = 0; output < 2; output ++) {
 
     Serial.print("Show me ");
-    printLabel(output);
+    Serial.println(label[output]);
 
     // Wait for the object to move away again
     while (!APDS.proximityAvailable() || APDS.readProximity() == 0) {}
@@ -64,45 +61,56 @@ void setup() {
   int epoch = 0;
   float accuracy = 0;
 
-  // Iterate until the perceptron is 99% accurate or we hit max epochs
+  Serial.print("Start weights:");
+  printWeights();
+
   while (epoch < MAX_EPOCHS && accuracy < 0.99) {
     accuracy = perceptron.train();
     epoch++;
-
     Serial.print("Accuracy: ");
     Serial.println(accuracy);
   }
 
+  Serial.print("End weights:");
+  printWeights();
+
+
   Serial.println("Training complete\n");
 }
 
 
+  // Classify objects shown
+  // ----------------------
 void loop() {
+
   int output;
 
   // Wait for the object to move away again
   while (!APDS.proximityAvailable() || APDS.readProximity() == 0) {}
+
   Serial.println("Let me guess your object");
 
   // Wait for an object then read its color
   readColor(color);
+
+  // CLassify the object using the perceptron
   output = perceptron.classify(color);
 
   Serial.print("You showed me ");
-  printLabel(output);
+  Serial.println(label[output]);
 }
 
 
-void printLabel(int output) {
-// Perceptron output can only be -1 or 1
-  if (output ==  -1) {
-    Serial.println(label[0]);
-  } else {
-    Serial.println(label[1]);
-  }
-  Serial.println();
-}
+void printWeights() {
+  float weights[NUM_INPUTS];
+  perceptron.getWeights(weights);
 
+  Serial.print(weights[0]);
+  Serial.print(",");
+  Serial.print(weights[1]);
+  Serial.print(",");
+  Serial.println(weights[2]);
+}
 
 void readColor(float color[]) {
   int red, green, blue, proximity, colorTotal = 0;

keywords.txt

@@ -13,6 +13,7 @@ Perceptron	KEYWORD1
 
 addExample	KEYWORD2
 classify	KEYWORD2
+getWeights	KEYWORD2
 
 clearAllClasses	KEYWORD2
 

src/Perceptron.cpp

@@ -21,14 +21,14 @@
 #include "Perceptron.h"
 #include "utility/PerceptronNode.h"
 
-Perceptron::Perceptron(int inputLength, float learningRate) :
+Perceptron::Perceptron(const int inputLength, float learningRate) :
   _inputLength(inputLength),
   _learningRate(learningRate),
   _weights(new float[_inputLength]),
   _examples(NULL)
 {
   for (int i = 0; i < _inputLength; i++) {
-    _weights[i] = random(-1, 1);
+  _weights[i] = (2.0*rand()/RAND_MAX)-1;;
   }
 }
 
@@ -71,10 +71,16 @@ int Perceptron::classify(const float input[])
 
     // Activation function
     if (sum > 0) return 1;
-    else return -1;
+    else return 0;
 
 }
 
+void Perceptron::getWeights(float * weightArray){
+  for (int i = 0; i < _inputLength; i++) {
+    weightArray[i] = _weights[i];
+  }
+}
+
 float Perceptron::train()
 {
   float count=0, correct=0;
@@ -86,13 +92,13 @@ float Perceptron::train()
 
     float inputs[_inputLength];
 
-
     for (int i = 0; i < _inputLength; i++) {
       inputs[i] = node->input(i);
     }
 
     int guess = classify(inputs);
     float error = node->class_() - guess;
+
     if (error==0) {correct++;}
 
     for (int i = 0; i < _inputLength; i++) {

src/Perceptron.h

@@ -34,7 +34,7 @@ class Perceptron {
   void addExample(const float input[], int class_);
   int classify(const float input[]);
   float train();
-
+  void getWeights(float * weightArray);
 
 private:
   int _inputLength;