// Cloned by Sumit Khopkar on 3 Dec 2021 from World "Character recognition neural network" by "Coding Train" project
// Please leave this clone trail here.
// Port of Character recognition neural network from here:
// https://github.com/CodingTrain/Toy-Neural-Network-JS/tree/master/examples/mnist
// with many modifications
// --- defined by MNIST - do not change these ---------------------------------------
const PIXELS = 28; // images in data set are tiny
const PIXELSSQUARED = PIXELS * PIXELS;
// number of training and test exemplars in the data set:
const NOTRAIN = 60000;
const NOTEST = 10000;
//--- can modify all these --------------------------------------------------
// no of nodes in network
const noinput = PIXELSSQUARED;
const nohidden = 64;
const nooutput = 3;
const learningrate = 0.1; // default 0.1
//CA686//
let do_training;
let nn_exists = false; //Variable to check if object of neural network exists
//Load the neural network object from the server if it exists
AB.queryDataExists ( function ( exists ) {
if(exists){
do_training = false; //if neural network object retrieved then do not train
AB.restoreData ( function ( nn ) {
nn_exists = true;
} );
}
else{
do_training = true; //if neural network object is not retrieved then train
}
} );
//CA686//
// how many to train and test per timestep
const TRAINPERSTEP = 10;
const TESTPERSTEP = 1;
// multiply it by this to magnify for display
const ZOOMFACTOR = 70;
const ZOOMPIXELS = ZOOMFACTOR * PIXELS;
// 3 rows of
// large image + 50 gap + small image
// 50 gap between rows
const canvaswidth = ( PIXELS + ZOOMPIXELS ) + 50;
const canvasheight = ( ZOOMPIXELS * 3 ) + 100;
const DOODLE_THICK = 18; // thickness of doodle lines
const DOODLE_BLUR = 1; // blur factor applied to doodles
let nn;
// images in LHS:
let doodle, demo;
let doodle_exists = false;
//let demo_exists = false;
let mousedrag = false; // are we in the middle of a mouse drag drawing?
// save inputs to global var to inspect
// type these names in console
var train_inputs, test_inputs, demo_inputs, doodle_inputs;
// make run header bigger
AB.headerCSS ( { "max-height": "95vh" } );
//--- start of AB.msgs structure: ---------------------------------------------------------
// We output a serious of AB.msgs to put data at various places in the run header
var thehtml;
// 1 Doodle header
thehtml = "<hr> <h1> Doodle </h1>" +
" Draw your doodle in LHS. It can be either a cat, a rainbow, or a train. <button onclick='wipeDoodle();' class='normbutton' >Clear doodle</button> <br> ";
AB.msg ( thehtml, 1 );
const greenspan = "<span style='font-weight:bold; font-size:x-large; color:darkgreen'> " ;
//--- end of AB.msgs structure: ---------------------------------------------------------
//CA686//
//function to calculate sigmoid value
function sigmoid(x) {
return 1 / (1 + Math.exp(-x));
}
//function to calculate tanh value
function dsigmoid(y) {
// return sigmoid(x) * (1 - sigmoid(x));
return y * (1 - y);
}
//Implemented softmax
function softmax(arr) {
let sum = 0;
let softmax_arr = [[0], [0], [0]];
console.log("arr", arr);
for(let i = 0; i < arr.length; i++){
sum = sum + Math.exp(arr[i]);
}
for(let i = 0; i < arr.length; i++){
softmax_arr[i][0] = Math.exp(arr[i]) / sum;
}
console.log("arr", arr);
return softmax_arr;
}
//class Matrix contains methods to perform Matrix Operations
class Matrix {
constructor(rows, cols) {
this.rows = rows;
this.cols = cols;
this.data = [];
for (let i = 0; i < this.rows; i++) {
this.data[i] = [];
for (let j = 0; j < this.cols; j++) {
this.data[i][j] = 0;
}
}
}
static fromArray(arr) {
let m = new Matrix(arr.length, 1);
for (let i = 0; i < arr.length; i++) {
m.data[i][0] = arr[i];
}
return m;
}
static subtract(a, b) {
// Return a new Matrix a-b
let result = new Matrix(a.rows, a.cols);
for (let i = 0; i < result.rows; i++) {
for (let j = 0; j < result.cols; j++) {
result.data[i][j] = a.data[i][j] - b.data[i][j];
}
}
return result;
}
//Implemented categorical cross-entropy
//Failed due to infinity error
static cross_entropy(target_out, model_out){
let cross_ent_err = new Matrix(target_out.rows, target_out.cols);
for(let i = 0; i < cross_ent_err.rows; i++){
for (let j = 0; j < cross_ent_err.cols; j++){
cross_ent_err.data[i][j] = cross_ent_err.data[i][j] + (target_out.data[i][j]*Math.log(model_out.data[i][j]));
}
}
for(let i = 0; i < cross_ent_err.rows; i++){
for (let j = 0; j < cross_ent_err.cols; j++){
cross_ent_err.data[i][j] = -cross_ent_err.data[i][j];
}
}
return cross_ent_err;
}
toArray() {
let arr = [];
for (let i = 0; i < this.rows; i++) {
for (let j = 0; j < this.cols; j++) {
arr.push(this.data[i][j]);
}
}
return arr;
}
randomize() {
for (let i = 0; i < this.rows; i++) {
for (let j = 0; j < this.cols; j++) {
this.data[i][j] = Math.random() * 2 - 1;
}
}
}
add(n) {
if (n instanceof Matrix) {
for (let i = 0; i < this.rows; i++) {
for (let j = 0; j < this.cols; j++) {
this.data[i][j] += n.data[i][j];
}
}
} else {
for (let i = 0; i < this.rows; i++) {
for (let j = 0; j < this.cols; j++) {
this.data[i][j] += n;
}
}
}
}
static transpose(matrix) {
let result = new Matrix(matrix.cols, matrix.rows);
for (let i = 0; i < matrix.rows; i++) {
for (let j = 0; j < matrix.cols; j++) {
result.data[j][i] = matrix.data[i][j];
}
}
return result;
}
static multiply(a, b) {
// Matrix product
if (a.cols !== b.rows) {
console.log('Columns of A must match rows of B.')
return undefined;
}
let result = new Matrix(a.rows, b.cols);
for (let i = 0; i < result.rows; i++) {
for (let j = 0; j < result.cols; j++) {
// Dot product of values in col
let sum = 0;
for (let k = 0; k < a.cols; k++) {
sum += a.data[i][k] * b.data[k][j];
}
result.data[i][j] = sum;
}
}
return result;
}
multiply(n) {
console.log("non-static multiply");
if (n instanceof Matrix) {
// hadamard product
for (let i = 0; i < this.rows; i++) {
for (let j = 0; j < this.cols; j++) {
this.data[i][j] *= n.data[i][j];
}
}
} else {
// Scalar product
for (let i = 0; i < this.rows; i++) {
for (let j = 0; j < this.cols; j++) {
this.data[i][j] *= n;
}
}
}
}
map(func) {
// Apply a function to every element of matrix
for (let i = 0; i < this.rows; i++) {
for (let j = 0; j < this.cols; j++) {
let val = this.data[i][j];
this.data[i][j] = func(val);
}
}
}
static map(matrix, func) {
let result = new Matrix(matrix.rows, matrix.cols);
// Apply a function to every element of matrix
for (let i = 0; i < matrix.rows; i++) {
for (let j = 0; j < matrix.cols; j++) {
let val = matrix.data[i][j];
result.data[i][j] = func(val);
}
}
return result;
}
print() {
console.table(this.data);
}
}
if (typeof module !== 'undefined') {
module.exports = Matrix;
}
class NeuralNetwork {
//Added code for learning rate
constructor(input_nodes, hidden_nodes, output_nodes, learning_rate) {
console.log("Constructor");
console.error("error");
this.input_nodes = input_nodes;
this.hidden_nodes = hidden_nodes;
this.output_nodes = output_nodes;
this.weights_ih = new Matrix(this.hidden_nodes, this.input_nodes);
this.weights_ho = new Matrix(this.output_nodes, this.hidden_nodes);
this.weights_ih.randomize();
this.weights_ho.randomize();
this.bias_h = new Matrix(this.hidden_nodes, 1);
this.bias_o = new Matrix(this.output_nodes, 1);
this.bias_h.randomize();
this.bias_o.randomize();
this.learning_rate = learning_rate; //Change to CodingTrain code
}
feedforward(input_array) {
// Generating the Hidden Outputs
let inputs = Matrix.fromArray(input_array);
let hidden = Matrix.multiply(this.weights_ih, inputs);
hidden.add(this.bias_h);
// activation function!
hidden.map(sigmoid);
// Generating the output's output!
let output = Matrix.multiply(this.weights_ho, hidden);
output.add(this.bias_o);
output.map(sigmoid);
// Sending back to the caller!
return output.toArray();
}
train(input_array, target_array) {
// Generating the Hidden Outputs
let inputs = Matrix.fromArray(input_array);
console.log("inputs", inputs);
let hidden = Matrix.multiply(this.weights_ih, inputs);
hidden.add(this.bias_h);
// activation function!
hidden.map(sigmoid);
// Generating the output's output!
console.log("this.weights_ho", this.weights_ho);
let outputs = Matrix.multiply(this.weights_ho, hidden);
outputs.add(this.bias_o);
//CA686//
//outputs.map(sigmoid);
outputs.data = softmax(outputs.data); //The outputs now pass through softmax function instead of sigmoid function
//CA686//
console.log("outputs.data", outputs.data);
// Convert array to matrix object
let targets = Matrix.fromArray(target_array);
// Calculate the error
// ERROR = TARGETS - OUTPUTS
//CA686//
let output_errors = Matrix.subtract(targets, outputs);
//let output_errors = Matrix.cross_entropy(targets, outputs); //Failed attempt to implement cross-entropy
//CA686//
console.log("output_errors", output_errors);
console.log("outputs", outputs);
// let gradient = outputs * (1 - outputs);
// Calculate gradient
let gradients = Matrix.map(outputs, dsigmoid);
gradients.multiply(output_errors);
console.log("gradients", gradients);
gradients.multiply(this.learning_rate);
// Calculate deltas
let hidden_T = Matrix.transpose(hidden);
let weight_ho_deltas = Matrix.multiply(gradients, hidden_T);
// Adjust the weights by deltas
this.weights_ho.add(weight_ho_deltas);
// Adjust the bias by its deltas (which is just the gradients)
this.bias_o.add(gradients);
// Calculate the hidden layer errors
let who_t = Matrix.transpose(this.weights_ho);
let hidden_errors = Matrix.multiply(who_t, output_errors);
// Calculate hidden gradient
let hidden_gradient = Matrix.map(hidden, dsigmoid);
hidden_gradient.multiply(hidden_errors);
hidden_gradient.multiply(this.learning_rate);
// Calcuate input->hidden deltas
let inputs_T = Matrix.transpose(inputs);
let weight_ih_deltas = Matrix.multiply(hidden_gradient, inputs_T);
this.weights_ih.add(weight_ih_deltas);
// Adjust the bias by its deltas (which is just the gradients)
this.bias_h.add(hidden_gradient);
// outputs.print();
// targets.print();
// error.print();
}
predict(input_array) {
// Generating the Hidden Outputs
console.log("input_array", input_array);
let inputs = Matrix.fromArray(input_array);
let hidden = Matrix.multiply(this.weights_ih, inputs);
hidden.add(this.bias_h);
// activation function!
//hidden.map(this.activation_function.func);
hidden.map(sigmoid);
// Generating the output's output!
let output = Matrix.multiply(this.weights_ho, hidden);
output.add(this.bias_o);
//output.map(this.activation_function.func);
//CA686//
//output.map(sigmoid);
output.data = softmax(output.data); ////The outputs now pass through softmax function instead of sigmoid function
//CA686//
// Sending back to the caller!
console.log("output", output);
return output.toArray();
}
}
const len = 784; //Total number of pixels
const totalData = 500; //Total images to be considered
//Assign integers for deciding the class of the objects
const CAT = 0;
const RAINBOW = 1;
const TRAIN = 2;
let catsData;
let trainsData;
let rainbowsData;
let cats = {};
let trains = {};
let rainbows = {};
var doodle_list = [];
var doodle_list_data = [];
var doodle_num_list = [];
var epochCounter = 0;
//failed to generalize
function preload() {
catsData = loadBytes('uploads/sumitkhopkar25/cats1000.bin');
trainsData = loadBytes('uploads/sumitkhopkar25/trains1000.bin');
rainbowsData = loadBytes('uploads/sumitkhopkar25/rainbows1000.bin');
}
//CA686//
function setup()
{
createCanvas ( canvaswidth, canvasheight );
doodle = createGraphics ( ZOOMPIXELS, ZOOMPIXELS ); // doodle on larger canvas
doodle.pixelDensity(1);
// JS load other JS
// maybe have a loading screen while loading the JS and the data set
AB.loadingScreen();
//CA686//
console.log ("All JS loaded");
if(nn_exists == false){
nn = new NeuralNetwork( noinput, nohidden, nooutput, learningrate);
}
//nn.setLearningRate ( learningrate );
loadData();
console.log("cats.training", cats.training);
//CA686//
}
// load data set from local file (on this server)
function loadData()
{
//CA680//
// Preparing the data
doodle_list = [cats, rainbows, trains];
doodle_list_data = [catsData, rainbowsData, trainsData];
doodle_num_list = [CAT, RAINBOW, TRAIN];
for(let j = 0; j < doodle_list.length; j++){
console.log("j", j);
doodle_list[j].training = [];
doodle_list[j].testing = [];
//Create training and testing data
for (let i = 0; i < totalData; i++) {
let offset = i * len;
let threshold = floor(0.8 * totalData);
if (i < threshold) {
doodle_list[j].training[i] = doodle_list_data[j].bytes.subarray(offset, offset + len);
doodle_list[j].training[i].label = doodle_num_list[j];
} else {
doodle_list[j].testing[i - threshold] = doodle_list_data[j].bytes.subarray(offset, offset + len);
doodle_list[j].testing[i - threshold].label = doodle_num_list[j];
}
}
}
console.log("cats.training", cats.training);
AB.removeLoading(); // if no loading screen exists, this does nothing
//CA680//
}
//CA686//
function trainEpoch(training) {
shuffle(training, true);
// Train for one epoch
for (let i = 0; i < training.length; i++) {
let data = training[i];
let inputs = Array.from(data).map(x => x / 255);
let label = training[i].label;
let targets = [0, 0, 0];
targets[label] = 1;
console.log("inputs", inputs);
console.log("targets", targets);
console.log("nn.weights_ih", nn.weights_ih);
nn.train(inputs, targets);
}
}
function testAll(testing) {
let correct = 0;
// Test for one epoch
for (let i = 0; i < testing.length; i++) {
// for (let i = 0; i < 1; i++) {
let data = testing[i];
let inputs = Array.from(data).map(x => x / 255);
let label = testing[i].label;
let guess = nn.predict(inputs);
let m = max(guess);
let classification = guess.indexOf(m);
if (classification === label) {
correct++;
}
}
let percent = 100 * correct / testing.length;
return percent;
}
//CA686//
function trainit (show) // train the network with a single exemplar, from global var "train_index", show visual on or off
{
//CA686//
// Randomizing the data
let training = [];
console.log("cats in training", cats);
//Prepare entire training dataset
training = training.concat(cats.training);
training = training.concat(rainbows.training);
training = training.concat(trains.training);
console.log("training", training);
trainEpoch(training);
epochCounter++;
console.log("Epoch: " + epochCounter);
}
function testit() // test the network with a single exemplar, from global var "test_index"
{
//CA686//
let testing = [];
//Prepare testing data
testing = testing.concat(cats.testing);
testing = testing.concat(rainbows.testing);
testing = testing.concat(trains.testing);
let percent = testAll(testing);
console.log("Percent: " + nf(percent, 2, 2) + "%");
let inputs = [];
let img = get();
img.resize(28, 28);
img.loadPixels();
for (let i = 0; i < len; i++) {
let bright = img.pixels[i * 4];
inputs[i] = (255 - bright) / 255.0;
}
let guess = nn.predict(inputs);
//Classify as per the highest probability from the probability distribution
let m = max(guess);
let classification = guess.indexOf(m);
if (classification === CAT) {
console.log("cat");
} else if (classification === RAINBOW) {
console.log("rainbow");
} else if (classification === TRAIN) {
console.log("train");
}
//CA686//
}
// --- the draw function -------------------------------------------------------------
// every step:
function draw()
{
// check if libraries and data loaded yet:
//CA686//
if ( typeof doodle_list == 'undefined' || doodle_list.length == 0 ) return; //Doodle list is defined after loadData and draw is called at every step
//CA686//
// how can we get white doodle on black background on yellow canvas?
// background('#ffffcc'); doodle.background('black');
background ('black');
if ( do_training )
{
// do some training per step
for (let i = 0; i < TRAINPERSTEP; i++)
{
if (i == 0) trainit(true); // show only one per step - still flashes by
else trainit(false);
}
do_training = false;
AB.saveData ( nn ); //Save the model onto the server
// do some testing per step
for (let i = 0; i < TESTPERSTEP; i++)
testit();
}
//throw new Error("Something went badly wrong!");
// keep drawing demo and doodle images
// and keep guessing - we will update our guess as time goes on
/*if ( demo_exists )
{
drawDemo();
guessDemo();
}*/
if ( doodle_exists )
{
drawDoodle();
guessDoodle(); //Guess the doodle tgat is draw on the screen
}
// detect doodle drawing
// (restriction) the following assumes doodle starts at 0,0
if ( mouseIsPressed ) // gets called when we click buttons, as well as if in doodle corner
{
// console.log ( mouseX + " " + mouseY + " " + pmouseX + " " + pmouseY );
var MAX = ZOOMPIXELS + 20; // can draw up to this pixels in corner
if ( (mouseX < MAX) && (mouseY < MAX) && (pmouseX < MAX) && (pmouseY < MAX) )
{
mousedrag = true; // start a mouse drag
doodle_exists = true;
doodle.stroke('white');
doodle.strokeWeight( DOODLE_THICK );
doodle.line(mouseX, mouseY, pmouseX, pmouseY);
}
}
else
{
// are we exiting a drawing
if ( mousedrag )
{
mousedrag = false;
// console.log ("Exiting draw. Now blurring.");
//Removed because it was slowing the prediction
//doodle.filter (BLUR, DOODLE_BLUR); // just blur once
// console.log (doodle);
}
}
}
//--- doodle -------------------------------------------------------------
function drawDoodle()
{
// doodle is createGraphics not createImage
let theimage = doodle.get();
image ( theimage, 0, 0, ZOOMPIXELS, ZOOMPIXELS ); // original
image ( theimage, ZOOMPIXELS+50, 0, PIXELS, PIXELS ); // shrunk
}
function guessDoodle()
{
// doodle is createGraphics not createImage
let img = doodle.get();
img.resize ( PIXELS, PIXELS );
img.loadPixels();
// set up inputs
let inputs = [];
for (let i = 0; i < PIXELSSQUARED ; i++)
{
inputs[i] = img.pixels[i * 4] / 255;
}
doodle_inputs = inputs; // can inspect in console
// feed forward to make prediction
let prediction = nn.predict(inputs); // array of outputs
//CA686//
console.log("prediction", prediction);
let m = max(prediction);
let classification = prediction.indexOf(m);
if (classification === CAT) {
classification = "cat";
} else if (classification === RAINBOW) {
classification = "rainbow";
} else if (classification === TRAIN) {
classification = "train";
}
thehtml = " We classify it as: " + greenspan + classification + "</span> <br>" +
//CA686//
AB.msg ( thehtml, 2 );
}
function wipeDoodle()
{
doodle_exists = false;
doodle.background('black');
}