├── LICENSE.md
├── README.md
├── cnnutil.js
├── cnnvis.js
├── process_images.py
├── tester.js
├── trainer.js
└── utilities.js


/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 birdID contributors
 4 | 
 5 | birdID uses a shared copyright model: each contributor holds copyright over
 6 | their contributions. The project versioning records all such
 7 | contribution and copyright details.
 8 | By contributing to this repository through pull-request, comment,
 9 | or otherwise, the contributor releases their content to the license and
10 | copyright terms herein.
11 | 
12 | Permission is hereby granted, free of charge, to any person obtaining a copy
13 | of this software and associated documentation files (the "Software"), to deal
14 | in the Software without restriction, including without limitation the rights
15 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
16 | copies of the Software, and to permit persons to whom the Software is
17 | furnished to do so, subject to the following conditions:
18 | 
19 | The above copyright notice and this permission notice shall be included in all
20 | copies or substantial portions of the Software.
21 | 
22 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
25 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
28 | SOFTWARE.
29 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | #BirdID_Convnetjs
 2 | ----------
 3 | 
 4 | How to use:
 5 | ----------
 6 | Format your dataset for use with process_images.py. It requires the images to be in the following folder structure:
 7 | 
 8 |     .
 9 |     |-- path_to_folders_with_images
10 |     |    |-- class1
11 |     |    |    |-- some_image1.jpg
12 |     |    |    |-- some_image1.jpg
13 |     |    |    |-- some_image1.jpg
14 |     |    |    └ ...
15 |     |    |-- class2
16 |     |    |    └ ...
17 |     |    |-- class3
18 |         ...
19 |     |    └-- classN
20 |   
21 | The code can be modified to create two versions of the dataset with different dimensions, to be used for augmentation.
22 | 
23 | - trainer.js: Define the network and train it
24 | 
25 | - tester.js: Run a trained network and output accuracy. Prints per-category accuracy and the accuracy of the top 2 and top 3 guesses as well.
26 | 
27 | 
28 | Dependencies:
29 | ----------
30 | 
31 | - [Node.js][4]
32 | - [convnetjs][1]
33 | - [graceful-fs][2]
34 | - [node-canvas][3]
35 | 
36 | [1]: https://github.com/karpathy/convnetjs
37 | [2]: https://github.com/isaacs/node-graceful-fs
38 | [3]: https://github.com/Automattic/node-canvas
39 | [4]: https://nodejs.org/
40 | 


--------------------------------------------------------------------------------
/cnnutil.js:
--------------------------------------------------------------------------------
 1 | 
 2 | // contains various utility functions 
 3 | var cnnutil = (function(exports){
 4 | 
 5 |   // a window stores _size_ number of values
 6 |   // and returns averages. Useful for keeping running
 7 |   // track of validation or training accuracy during SGD
 8 |   var Window = function(size, minsize) {
 9 |     this.v = [];
10 |     this.size = typeof(size)==='undefined' ? 100 : size;
11 |     this.minsize = typeof(minsize)==='undefined' ? 20 : minsize;
12 |     this.sum = 0;
13 |   }
14 |   Window.prototype = {
15 |     add: function(x) {
16 |       this.v.push(x);
17 |       this.sum += x;
18 |       if(this.v.length>this.size) {
19 |         var xold = this.v.shift();
20 |         this.sum -= xold;
21 |       }
22 |     },
23 |     get_average: function() {
24 |       if(this.v.length < this.minsize) return -1;
25 |       else return this.sum/this.v.length;
26 |     },
27 |     reset: function(x) {
28 |       this.v = [];
29 |       this.sum = 0;
30 |     }
31 |   }
32 | 
33 |   // returns min, max and indeces of an array
34 |   var maxmin = function(w) {
35 |     if(w.length === 0) { return {}; } // ... ;s
36 | 
37 |     var maxv = w[0];
38 |     var minv = w[0];
39 |     var maxi = 0;
40 |     var mini = 0;
41 |     for(var i=1;i<w.length;i++) {
42 |       if(w[i] > maxv) { maxv = w[i]; maxi = i; } 
43 |       if(w[i] < minv) { minv = w[i]; mini = i; } 
44 |     }
45 |     return {maxi: maxi, maxv: maxv, mini: mini, minv: minv, dv:maxv-minv};
46 |   }
47 | 
48 |   // returns string representation of float
49 |   // but truncated to length of d digits
50 |   var f2t = function(x, d) {
51 |     if(typeof(d)==='undefined') { var d = 5; }
52 |     var dd = 1.0 * Math.pow(10, d);
53 |     return '' + Math.floor(x*dd)/dd;
54 |   }
55 | 
56 |   exports = exports || {};
57 |   exports.Window = Window;
58 |   exports.maxmin = maxmin;
59 |   exports.f2t = f2t;
60 |   return exports;
61 | 
62 | })(typeof module != 'undefined' && module.exports);  // add exports to module.exports if in node.js
63 | 
64 | 
65 | 


--------------------------------------------------------------------------------
/cnnvis.js:
--------------------------------------------------------------------------------
  1 | 
  2 | // contains various utility functions 
  3 | var cnnvis = (function(exports){
  4 | 
  5 |   // can be used to graph loss, or accuract over time
  6 |   var Graph = function(options) {
  7 |     var options = options || {};
  8 |     this.step_horizon = options.step_horizon || 1000;
  9 |     
 10 |     this.pts = [];
 11 |     
 12 |     this.maxy = -9999;
 13 |     this.miny = 9999;
 14 |   }
 15 | 
 16 |   Graph.prototype = {
 17 |     // canv is the canvas we wish to update with this new datapoint
 18 |     add: function(step, y) {
 19 |       var time = new Date().getTime(); // in ms
 20 |       if(y>this.maxy*0.99) this.maxy = y*1.05;
 21 |       if(y<this.miny*1.01) this.miny = y*0.95;
 22 | 
 23 |       this.pts.push({step: step, time: time, y: y});
 24 |       if(step > this.step_horizon) this.step_horizon *= 2;
 25 |     },
 26 |     // elt is a canvas we wish to draw into
 27 |     drawSelf: function(canv) {
 28 |       
 29 |       var pad = 25;
 30 |       var H = canv.height;
 31 |       var W = canv.width;
 32 |       var ctx = canv.getContext('2d');
 33 | 
 34 |       ctx.clearRect(0, 0, W, H);
 35 |       ctx.font="10px Georgia";
 36 | 
 37 |       var f2t = function(x) {
 38 |         var dd = 1.0 * Math.pow(10, 2);
 39 |         return '' + Math.floor(x*dd)/dd;
 40 |       }
 41 | 
 42 |       // draw guidelines and values
 43 |       ctx.strokeStyle = "#999";
 44 |       ctx.beginPath();
 45 |       var ng = 10;
 46 |       for(var i=0;i<=ng;i++) {
 47 |         var xpos = i/ng*(W-2*pad)+pad;
 48 |         ctx.moveTo(xpos, pad);
 49 |         ctx.lineTo(xpos, H-pad);
 50 |         ctx.fillText(f2t(i/ng*this.step_horizon/1000)+'k',xpos,H-pad+14);
 51 |       }
 52 |       for(var i=0;i<=ng;i++) {
 53 |         var ypos = i/ng*(H-2*pad)+pad;
 54 |         ctx.moveTo(pad, ypos);
 55 |         ctx.lineTo(W-pad, ypos);
 56 |         ctx.fillText(f2t((ng-i)/ng*(this.maxy-this.miny) + this.miny), 0, ypos);
 57 |       }
 58 |       ctx.stroke();
 59 | 
 60 |       var N = this.pts.length;
 61 |       if(N<2) return;
 62 | 
 63 |       // draw the actual curve
 64 |       var t = function(x, y, s) {
 65 |         var tx = x / s.step_horizon * (W-pad*2) + pad;
 66 |         var ty = H - ((y-s.miny) / (s.maxy-s.miny) * (H-pad*2) + pad);
 67 |         return {tx:tx, ty:ty}
 68 |       }
 69 | 
 70 |       ctx.strokeStyle = "red";
 71 |       ctx.beginPath()
 72 |       for(var i=0;i<N;i++) {
 73 |         // draw line from i-1 to i
 74 |         var p = this.pts[i];
 75 |         var pt = t(p.step, p.y, this);
 76 |         if(i===0) ctx.moveTo(pt.tx, pt.ty);
 77 |         else ctx.lineTo(pt.tx, pt.ty);
 78 |       }
 79 |       ctx.stroke();
 80 |     }
 81 |   }
 82 | 
 83 |   // same as graph but draws multiple lines. For now I'm lazy and duplicating
 84 |   // the code, but in future I will merge these two more nicely.
 85 |   var MultiGraph = function(legend, options) {
 86 |     var options = options || {};
 87 |     this.step_horizon = options.step_horizon || 1000;
 88 | 
 89 |     if(typeof options.maxy !== 'undefined') this.maxy_forced = options.maxy;
 90 |     if(typeof options.miny !== 'undefined') this.miny_forced = options.miny;
 91 | 
 92 |     this.pts = [];
 93 |     
 94 |     this.maxy = -9999;
 95 |     this.miny = 9999;
 96 |     this.numlines = 0;
 97 | 
 98 |     this.numlines = legend.length;
 99 |     this.legend = legend;
100 |     this.styles = ["red", "blue", "green", "black", "magenta", "cyan", "purple", "aqua", "olive", "lime", "navy"];
101 |     // 17 basic colors: aqua, black, blue, fuchsia, gray, green, lime, maroon, navy, olive, orange, purple, red, silver, teal, white, and yellow
102 |   }
103 | 
104 |   MultiGraph.prototype = {
105 |     // canv is the canvas we wish to update with this new datapoint
106 |     add: function(step, yl) {
107 |       var time = new Date().getTime(); // in ms
108 |       var n = yl.length;
109 |       for(var k=0;k<n;k++) {
110 |         var y = yl[k];
111 |         if(y>this.maxy*0.99) this.maxy = y*1.05;
112 |         if(y<this.miny*1.01) this.miny = y*0.95;
113 |       }
114 | 
115 |       if(typeof this.maxy_forced !== 'undefined') this.maxy = this.maxy_forced;
116 |       if(typeof this.miny_forced !== 'undefined') this.miny = this.miny_forced;
117 | 
118 |       this.pts.push({step: step, time: time, yl: yl});
119 |       if(step > this.step_horizon) this.step_horizon *= 2;
120 |     },
121 |     // elt is a canvas we wish to draw into
122 |     drawSelf: function(canv) {
123 |       
124 |       var pad = 25;
125 |       var H = canv.height;
126 |       var W = canv.width;
127 |       var ctx = canv.getContext('2d');
128 | 
129 |       ctx.clearRect(0, 0, W, H);
130 |       ctx.font="10px Georgia";
131 | 
132 |       var f2t = function(x) {
133 |         var dd = 1.0 * Math.pow(10, 2);
134 |         return '' + Math.floor(x*dd)/dd;
135 |       }
136 | 
137 |       // draw guidelines and values
138 |       ctx.strokeStyle = "#999";
139 |       ctx.beginPath();
140 |       var ng = 10;
141 |       for(var i=0;i<=ng;i++) {
142 |         var xpos = i/ng*(W-2*pad)+pad;
143 |         ctx.moveTo(xpos, pad);
144 |         ctx.lineTo(xpos, H-pad);
145 |         ctx.fillText(f2t(i/ng*this.step_horizon/1000)+'k',xpos,H-pad+14);
146 |       }
147 |       for(var i=0;i<=ng;i++) {
148 |         var ypos = i/ng*(H-2*pad)+pad;
149 |         ctx.moveTo(pad, ypos);
150 |         ctx.lineTo(W-pad, ypos);
151 |         ctx.fillText(f2t((ng-i)/ng*(this.maxy-this.miny) + this.miny), 0, ypos);
152 |       }
153 |       ctx.stroke();
154 | 
155 |       var N = this.pts.length;
156 |       if(N<2) return;
157 | 
158 |       // draw legend
159 |       for(var k=0;k<this.numlines;k++) {
160 |         ctx.fillStyle = this.styles[k % this.styles.length];
161 |         ctx.fillText(this.legend[k], W-pad-100, pad+20+k*16);
162 |       }
163 |       ctx.fillStyle = "black";
164 | 
165 |       // draw the actual curve
166 |       var t = function(x, y, s) {
167 |         var tx = x / s.step_horizon * (W-pad*2) + pad;
168 |         var ty = H - ((y-s.miny) / (s.maxy-s.miny) * (H-pad*2) + pad);
169 |         return {tx:tx, ty:ty}
170 |       }
171 |       for(var k=0;k<this.numlines;k++) {
172 | 
173 |         ctx.strokeStyle = this.styles[k % this.styles.length];
174 |         ctx.beginPath()
175 |         for(var i=0;i<N;i++) {
176 |           // draw line from i-1 to i
177 |           var p = this.pts[i];
178 |           var pt = t(p.step, p.yl[k], this);
179 |           if(i===0) ctx.moveTo(pt.tx, pt.ty);
180 |           else ctx.lineTo(pt.tx, pt.ty);
181 |         }
182 |         ctx.stroke();
183 |       }
184 | 
185 |     }
186 |   }
187 | 
188 |   exports = exports || {};
189 |   exports.Graph = Graph;
190 |   exports.MultiGraph = MultiGraph;
191 |   return exports;
192 | 
193 | })(typeof module != 'undefined' && module.exports);  // add exports to module.exports if in node.js
194 | 
195 | 
196 | 


--------------------------------------------------------------------------------
/process_images.py:
--------------------------------------------------------------------------------
 1 | #run in the directory containing separate folders for each bird type
 2 | 
 3 | import numpy
 4 | from scipy.misc import imread, imresize, imsave
 5 | import cPickle, gzip, sys, os.path
 6 | folders = os.listdir(".")
 7 | features = ( )
 8 | for foldername in folders:
 9 |   if foldersname == ".DS_Store":
10 |     continue
11 |   files = os.listdir(foldername)
12 |     for file in files:
13 |       if file == ".DS_Store":
14 |         continue
15 |       img = imread(foldername + "/" + file)
16 |       img = imresize(img, (128, 128))
17 |       print "Adding image " + file + " with dimensions " + str(img.shape)
18 |       features = features + (img,)
19 | 
20 | 
21 | features = numpy.array(list(features))
22 | idx = 0
23 | for image in features:
24 |   imsave("../128/bird" + str(idx) + ".png", image)	
25 |   idx = idx + 1
26 |   print "Saving" + str(idx - 1)
27 | 


--------------------------------------------------------------------------------
/tester.js:
--------------------------------------------------------------------------------
  1 | var convnetjs = require("convnetjs");
  2 | var fs = require("graceful-fs");
  3 | var Canvas = require('canvas');
  4 | var zlib = require('zlib');
  5 | var ts = require('./utilities.js');
  6 | 
  7 | //path containing the validation images
  8 | var birdpath = "../cnn_dataset/128/";
  9 | 
 10 | var retrainID = 1435340786541;//ID of the instance being retrained
 11 | 
 12 | var test_type = 2;//0 for training set, 1 for validation set, 2 for testing test
 13 | //there might not be a separate "testing" set because only training and validation splits are needed to train
 14 | 
 15 | var debug = false;
 16 | 
 17 | 
 18 | var dim = 128;//dimension of the images
 19 | 
 20 | //convnetjs' utilities for visualization
 21 | var cnnutil = require('./cnnutil.js');
 22 | var cnnvis = require('./cnnvis.js');
 23 | 
 24 | 
 25 | var canvas = new Canvas(dim, dim); //all images are 512x512
 26 | var ctx = canvas.getContext('2d');
 27 | var Image = Canvas.Image;
 28 | 
 29 | global.canvas = canvas;
 30 | global.ctx = ctx;
 31 | global.Image = Image;
 32 | 
 33 | var ID = Date.now();//will be used in file names to uniquely identify this run
 34 | 
 35 | var img_to_vol = ts.img_to_vol;
 36 | 
 37 | //CNN Definition
 38 | //load from state
 39 | var state = fs.readFileSync("states/cnn_state_" + retrainID + "_tmp.txt");
 40 | var net = new convnetjs.Net();
 41 | net.fromJSON(JSON.parse(state));
 42 | 
 43 | //Generate array of file names and labels
 44 | var split = JSON.parse(fs.readFileSync("splits/cnn_split" + retrainID + ".txt", "utf8" )).data;
 45 | var names = split[0];
 46 | var labels = split[1];
 47 | 
 48 | 
 49 | var valAccWindow = new cnnutil.Window(names[test_type].length);
 50 | var top2AccWindow = new cnnutil.Window(names[test_type].length);
 51 | var top3AccWindow = new cnnutil.Window(names[test_type].length);
 52 | 
 53 | //Tracking accuracy by category
 54 | var bird_accuracies = { };
 55 | 
 56 | for (var i = 0; i < net.layers[net.layers.length - 1].out_depth; i++)
 57 | {
 58 | 
 59 |   bird_accuracies[i] = new cnnutil.Window(names[test_type].length, 1);//this assigns too many spaces on the window but it will not cause any problems
 60 | 
 61 | }
 62 | 
 63 | console.log("[" + retrainID + "] Starting testing...");
 64 | console.time("Testing time");
 65 | 
 66 | for (var i = 0; i < names[test_type].length; i++)//loops batches
 67 |   {
 68 |     var x = img_to_vol(birdpath + names[test_type][i]);
 69 |     var output = net.forward(x);
 70 | 
 71 |     pred = net.getPrediction();
 72 |     acc = pred == labels[test_type][i] ? 1.0 : 0.0;
 73 |     valAccWindow.add(acc);
 74 |     bird_accuracies[labels[test_type][i]].add(acc);
 75 | 
 76 |     pred2 = ts.getTopPrediction(net.layers[net.layers.length - 1], 2);
 77 |     if(pred2[0] == labels[test_type][i] || pred2[1] == labels[test_type][i])
 78 |       top2AccWindow.add(1.0);
 79 |     else
 80 |       top2AccWindow.add(0.0);
 81 | 
 82 |     pred3 = ts.getTopPrediction(net.layers[net.layers.length - 1], 3);
 83 |     if(pred3[0] == labels[test_type][i] || pred3[1] == labels[test_type][i] || pred3[2] == labels[test_type][i])
 84 |       top3AccWindow.add(1.0);
 85 |     else
 86 |       top3AccWindow.add(0.0);
 87 | 
 88 |   }
 89 | 
 90 | console.log("Testing accuracy: " + valAccWindow.get_average());
 91 | console.log("Top 2 accuracy:" + top2AccWindow.get_average());
 92 | console.log("Top 3 accuracy:" + top3AccWindow.get_average());
 93 | 
 94 | 
 95 | for (var i = 0; i < net.layers[net.layers.length - 1].out_depth; i++)
 96 | {
 97 | 
 98 |   console.log("Accuracy for category " + i + " [" + bird_accuracies[i].v.length + "]: " + bird_accuracies[i].get_average());
 99 | 
100 | }
101 | 
102 | console.timeEnd("Testing time");
103 | 


--------------------------------------------------------------------------------
/trainer.js:
--------------------------------------------------------------------------------
  1 | var convnetjs = require("convnetjs");
  2 | var fs = require("graceful-fs");
  3 | var Canvas = require('canvas');
  4 | var zlib = require('zlib');
  5 | var ts = require('./utilities.js');//tools are being referenced from the utilities.js file within the same directory
  6 | 
  7 | var birdpath = "../cnn_dataset/160_auto/";
  8 | var valpath = "../cnn_dataset/128_auto/";//folder to validate from
  9 | //two folders are needed because the training set is larger but augmented
 10 | 
 11 | 
 12 | var ratios = [0.6, 0.4]//training - validation - testing ratios
 13 | //testing images can be omitted
 14 | 
 15 | var debug = false;//enable to output which image is being trained with and the accuracy of the prediction on that specific image
 16 | 
 17 | var checkpoint = 5;//save network state and calculate validation accuracy every x runs
 18 | 
 19 | var preaug_dim = 160;//dimension of the the training images before augmentation
 20 | var dim = 128;//dimension of the images after augmentation (default size of the validation images)
 21 | var per_category = 98;//images per category in both folders
 22 | var categories = 9;//number of categories
 23 | 
 24 | 
 25 | //convnetjs' utilities for visualization
 26 | var cnnutil = require('./cnnutil.js');
 27 | var cnnvis = require('./cnnvis.js');
 28 | 
 29 | 
 30 | var canvas = new Canvas(dim, dim); //all images are 512x512
 31 | var ctx = canvas.getContext('2d');
 32 | var Image = Canvas.Image;
 33 | 
 34 | global.canvas = canvas;
 35 | global.ctx = ctx;
 36 | global.Image = Image;
 37 | 
 38 | var ID = Date.now();//will be used in file names to uniquely identify this run
 39 | 
 40 | var drawImg = ts.drawImg;
 41 | var img_to_vol = ts.img_to_vol;
 42 | var split_dataset = ts.split_dataset;
 43 | var getSVMPrediction = ts.getSVMPrediction;
 44 | 
 45 | //CNN Definition starts here
 46 | 
 47 | var layer_defs = [];
 48 | 
 49 | layer_defs.push({type:'input', out_sx:dim, out_sy:dim, out_depth:3}); // declare size of input
 50 | 
 51 | layer_defs.push({type:'conv', sx:5, filters:16, stride:1, pad:2, activation:'relu'});
 52 | layer_defs.push({type:'pool', sx:2, stride:2});
 53 | 
 54 | layer_defs.push({type:'conv', sx:5, filters:32, stride:1, pad:2, activation:'relu'});
 55 | layer_defs.push({type:'pool', sx:2, stride:2});
 56 | 
 57 | 
 58 | layer_defs.push({type:'conv', sx:5, filters:64, stride:1, pad:2, activation:'relu'});
 59 | layer_defs.push({type:'pool', sx:2, stride:2});
 60 | 
 61 | layer_defs.push({type:'softmax', num_classes:categories});
 62 | 
 63 | net = new convnetjs.Net();
 64 | net.makeLayers(layer_defs);
 65 | 
 66 | trainer = new convnetjs.SGDTrainer(net, {method:'adadelta', batch_size:1, l2_decay:0.0001});
 67 | 
 68 | 
 69 | 
 70 | //Generate array of file names and labels
 71 | var all_names = [ ];
 72 | var all_labels = [ ];
 73 | for (var i = 0; i < per_category * categories; i++)
 74 | {
 75 |   all_names.push("bird" + i + ".png");
 76 |   all_labels.push(Math.floor(i / per_category));
 77 | }
 78 | 
 79 | var split = split_dataset(all_names, all_labels, ratios);
 80 | var names = split[0];
 81 | var labels = split[1];
 82 | 
 83 | //save the split for future reference for testing
 84 | var json = {};
 85 | json.data = split;
 86 | fs.writeFileSync("splits/cnn_split" + ID + ".txt", JSON.stringify(json) );
 87 | 
 88 | 
 89 | //Create windows to log accuracy
 90 | var valAccWindow = new cnnutil.Window(names[1].length);
 91 | var testAccWindow = new cnnutil.Window(names[0].length, 1);
 92 | 
 93 | 
 94 | console.log("[" + ID + "] Starting training...");
 95 | console.time("Training time");
 96 | 
 97 | //epochs
 98 | for (var e = 0; e < 301; e++)
 99 | {
100 | 
101 |   //convert each image to vols and train with them in batches
102 |   for (var i = 0; i < names[0].length; i++)//loops batches
103 |   {
104 | 
105 |     if (Math.floor(Math.random() * 2) == 1)//50% chance of augmentation
106 |     {
107 |       var canvas = new Canvas(preaug_dim, preaug_dim); 
108 |       var ctx = canvas.getContext('2d');
109 |       global.canvas = canvas;
110 |       global.ctx = ctx;
111 | 
112 |       var x = img_to_vol(birdpath + names[0][i]);
113 | 
114 | 
115 |       //augment
116 |       //random crops and flips
117 |       var canvas = new Canvas(dim, dim); 
118 |       var ctx = canvas.getContext('2d');
119 |       global.canvas = canvas;
120 |       global.ctx = ctx;
121 | 
122 |       x = convnetjs.augment(x, dim, Math.floor(Math.random() * (preaug_dim - dim)), Math.floor(Math.random() * (preaug_dim - dim)), Math.floor(Math.random() * 2) == 1);
123 | 
124 |     } else {
125 | 
126 |       var canvas = new Canvas(dim, dim); 
127 |       var ctx = canvas.getContext('2d');
128 |       global.canvas = canvas;
129 |       global.ctx = ctx;
130 |       var x = img_to_vol(valpath + names[0][i]);
131 |       //50% chance of flipping
132 |       
133 |       if (Math.floor(Math.random() * 2) == 1)
134 |         x = convnetjs.augment(x, dim, 0, 0, true);
135 | 
136 |     }
137 | 
138 |     var output = trainer.train(x, labels[0][i]);
139 | 
140 |     fs.appendFileSync("logs/cnn_log" + ID + ".txt", "Epoch # "+ (e + 1)  + ", Run #" + (i + 1) + "\n" + JSON.stringify(output) + "\n");
141 | 
142 |     //resetting fs to avoid "too many open files" errors
143 |     fs = [];
144 |     fs = require("graceful-fs");
145 | 
146 |     //if the classifier layer is an SVM, this can be used
147 |     //var pred = getSVMPrediction(net.layers[net.layers.length - 1]);
148 |     var pred = net.getPrediction();
149 |     var acc = pred==labels[0][i] ? 1.0 : 0.0;
150 |     testAccWindow.add(acc);
151 | 
152 | 
153 |     if(debug){
154 | 
155 |       var chance = net.layers[net.layers.length - 1].out_act.w[labels[0][i]];
156 |       console.log("Trained image number " +i+ " with label " + labels[0][i] + ", chance: " + chance);
157 |     }
158 | 
159 |   }
160 | 
161 | 
162 |   if (Math.floor(e / 5) == (e/5))
163 |     console.log("Finished epoch #" + (e+1));
164 | 
165 | 
166 |   console.log("Training accuracy: " +testAccWindow.get_average());
167 |   testAccWindow.reset();
168 | 
169 | 
170 | 
171 |   //Save network state every x epochs
172 |   if (Math.floor(e/checkpoint) == (e/checkpoint) && e != 0)
173 |   {
174 | 
175 |     var json = net.toJSON();
176 |     var str = JSON.stringify(json);
177 |     //var gzip = zlib.createGzip({ level: 9 });
178 | 
179 | 
180 |     var filename = "states/cnn_state_" + ID +"_tmp.txt";
181 |     fs.writeFileSync(filename, str);
182 |     
183 |     //network states can be compressed using the code below, but thisis done asynchoronously and is therefore really only useful for a final save
184 |     
185 |     //var rStream = fs.createReadStream(filename);
186 |     //var wStream = fs.createWriteStream(filename + ".gz");
187 | 
188 |     /*rStream.pipe(gzip).pipe(wStream).on('finish', function () {
189 |       fs.unlinkSync(filename);//remove the huge plaintext file
190 |       });
191 |       */
192 | 
193 | 
194 |     //validate here
195 | 
196 |     for (var i = 0; i < names[1].length; i++)//loops batches
197 |     {
198 |       var x = img_to_vol(valpath + names[1][i]);
199 |       var output = net.forward(x);
200 | 
201 |       //pred = getSVMPrediction(net.layers[net.layers.length - 1]);
202 | 
203 |       var pred = net.getPrediction();
204 |       acc = pred==Math.floor(labels[1][i]) ? 1.0 : 0.0;
205 |       valAccWindow.add(acc);
206 |     }
207 | 
208 |     console.log("Validation accuracy: " + valAccWindow.get_average());
209 | 
210 |     valAccWindow.reset();
211 | 
212 |   }
213 | 
214 | 
215 | 
216 | 
217 | }
218 | 
219 | console.timeEnd("Training time");
220 | 
221 | //Save the network
222 | var json = net.toJSON();
223 | var str = JSON.stringify(json);
224 | 
225 | //Date.now() to prevent overwriting states
226 | filename = "states/cnn_state_" + ID +".txt";
227 | fs.writeFileSync(filename, str);
228 | 
229 | //compression code below if needed
230 | /*
231 |    rStream = fs.createReadStream(filename);
232 |    wStream = fs.createWriteStream(filename + ".gz");
233 | 
234 |    rStream.pipe(gzip)//compress
235 |    .pipe(wStream)//write
236 |    .on('finish', function () {  // finished
237 |    fs.unlinkSync(filename);//remove the huge plaintext file
238 |    }); */
239 | 


--------------------------------------------------------------------------------
/utilities.js:
--------------------------------------------------------------------------------
  1 | var utilities = (function(exports){
  2 | 
  3 |   var convnetjs = require("convnetjs");
  4 |   var fs = require("fs");
  5 |   var Canvas = require('canvas');
  6 | 
  7 |   //used as the callback in the img_to_vol method to draw the given picture on the canvas
  8 |   var drawImg = function(err, pic){
  9 |     if (err) throw err;
 10 |     img = new Image;
 11 |     img.src = pic;
 12 |     ctx.drawImage(img, 0, 0);
 13 |   };
 14 | 
 15 | 
 16 |   //adapted from convnetjs.img_to_vol
 17 |   //converts the image from the given path into a Vol object to be used by the CNN
 18 |   var img_to_vol = function(img_path) {
 19 | 
 20 |     //fs.readFile(img_path, drawImg);
 21 | 
 22 |     img = new Image;
 23 |     img.src = fs.readFileSync(img_path);
 24 |     ctx.drawImage(img, 0, 0);
 25 | 
 26 |     try {
 27 |       var img_data = ctx.getImageData(0, 0, canvas.width, canvas.height);
 28 |     } catch (e) {
 29 | 
 30 |       if(e.name === 'IndexSizeError') {
 31 |         return false;
 32 |       } else {
 33 |         throw e;
 34 |       }
 35 |     }
 36 | 
 37 |     // prepare the input: get pixels and normalize them
 38 |     var p = img_data.data;
 39 |     var W = img.width;
 40 |     var H = img.height;
 41 |     var pv = []
 42 | 
 43 |       for(var i=0;i<p.length;i++) {
 44 |         pv.push(p[i]/255.0-0.5); // normalize image pixels to [-0.5, 0.5]
 45 |       }
 46 | 
 47 |     var x = new convnetjs.Vol(W, H, 4, 0.0); //input volume (image)
 48 |     x.w = pv;
 49 | 
 50 |     return x;
 51 | 
 52 |   }
 53 | 
 54 | 
 55 |   //Draws the activations of A (of type Vol)
 56 |   //returns an RGB canvas
 57 |   var draw_activations = function(A, scale) {
 58 | 
 59 |     var s = scale || 2; // scale
 60 |     // get max and min activation to scale the maps automatically
 61 |     var w = A.w;
 62 |     var mm = convnetjs.maxmin(w);
 63 | 
 64 |     var result = [ ];
 65 | 
 66 |     var canv = new Canvas(32, 32); //all images are 512x512
 67 |     canv.className = 'actmap';
 68 |     var W = A.sx * s;
 69 |     var H = A.sy * s;
 70 |     canv.width = W;
 71 |     canv.height = H;
 72 |     var ctx = canv.getContext('2d');
 73 |     var g = ctx.createImageData(W, H);
 74 | 
 75 |     for(var d=0;d<3;d++) {
 76 |       for(var x=0;x<A.sx;x++) {
 77 |         for(var y=0;y<A.sy;y++) {
 78 |           var dval = Math.floor((A.get(x,y,d)-mm.minv)/mm.dv*255);  
 79 | 
 80 |           for(var dx=0;dx<s;dx++) {
 81 |             for(var dy=0;dy<s;dy++) {
 82 |               var pp = ((W * (y*s+dy)) + (dx + x*s)) * 4;
 83 |               g.data[pp + d] = dval;
 84 |               if(d===0) g.data[pp+3] = 255; // alpha channel
 85 |             }
 86 |           }
 87 |         }
 88 |       }
 89 |       //result.push(canv);
 90 |     }
 91 |     ctx.putImageData(g, 0, 0);
 92 |     return canv;
 93 |   }
 94 | 
 95 |   //splits the given arrays of names and labels into groups based on the provided ratios
 96 |   //returns a 3D array with the structure [[names], [labels]]
 97 |   // the 2d arrays have their contents split into groups according to the ratios
 98 |   var split_dataset = function(names, labels, ratios) {
 99 | 
100 |     if (!(names instanceof Array && labels instanceof Array && ratios instanceof Array)){
101 |       return;
102 |     }
103 | 
104 |     //check if ratios sum to 1
105 |     var sum = 0;
106 |     for (var i = 0; i < ratios.length; i++) {
107 | 
108 |       sum = sum + ratios[i];
109 |     }
110 | 
111 |     if (sum !== 1)
112 |       return;
113 | 
114 | 
115 |     var total = names.length;
116 |     var amounts = [ ];//to store the amount of elemets to have in each group
117 | 
118 | 
119 |     for (var i = 0; i < ratios.length; i++) {
120 | 
121 |       amounts.push(Math.floor(total * ratios[i]));
122 | 
123 |     }
124 | 
125 |     //make sure the assigned numbers add up to the sum
126 | 
127 |     sum = 0;
128 |     for (var i = 0; i < amounts.length; i++) {
129 | 
130 |       sum = sum + amounts[i];
131 |     }
132 |     //if too few items assigned, increment the last one
133 |     if (sum < total){
134 |       while (sum < total){
135 |         amounts[amounts.length - 1]++;
136 |         sum++;
137 |       }
138 |     } else if (sum > total) {//if too many, decrement the last one
139 |       while (sum > total) {
140 |         amounts[amounts.length - 1]--;
141 |         sum--;
142 |       }
143 |     }
144 | 
145 |     //randomly assign names to each group
146 |     var name_clone = names.slice(0);
147 |     var label_clone = labels.slice(0);
148 |     var result = [[ ], [ ] ];
149 |     //names, labels
150 | 
151 |     for (var i = 0; i < amounts.length; i++){
152 |       result[0].push([ ]);//initializing the corresponding arrays
153 |       result[1].push([ ]);
154 |       for (var j = 0; j < amounts[i]; j++){
155 |         var index = Math.floor(Math.random() * name_clone.length);
156 |         result[0][i].push(name_clone.splice(index, 1)[0]);
157 |         result[1][i].push(label_clone.splice(index, 1)[0]);//remove one element at the calculated random index
158 |         //the splice method returns an array of one item, so that item is pushed to the appropriate index in the result array
159 |       }
160 |     }
161 | 
162 |     return result;
163 |   }
164 | 
165 |   //given the softmax layer, returns an array of the top predictions from the layer, in desencding order. "amount" determines how many predictions to return.
166 |   var getTopPrediction = function(softmax_layer, amount) {
167 | 
168 |     //assert(softmax_layer.layer_type === 'softmax', 'getTopPrediction() requires a softmax layer');
169 |     
170 |     if (softmax_layer.layer_type !== 'softmax')
171 |       return;
172 | 
173 |     var p = Object.keys(softmax_layer.out_act.w).map(function(k) { return softmax_layer.out_act.w[k] });//made into an array
174 | 
175 |     var result = [ ];
176 | 
177 |     if (p.length < amount || amount === 0)//requested too many
178 |       return;
179 | 
180 |     for (var a = 0; a < amount; a++) {
181 | 
182 |       var maxV = p[0];
183 |       var maxi = 0;
184 | 
185 |       for (var i = 1; i < p.length; i++) {
186 | 
187 |         if (p[i] > maxV) {
188 | 	  maxV = p[i];
189 | 	  maxi = i;
190 | 	}
191 |       }
192 | 
193 |       result.push(maxi);
194 |       p[maxi] = 0;//set the element to zero so that it is not picked up again
195 | 
196 |     }
197 |     return result;
198 |   }
199 | 
200 |   var getSVMPrediction = function (svm_layer) {
201 | 
202 |     if (svm_layer.layer_type !== 'svm')
203 |       return;
204 | 
205 |     var p = svm_layer.out_act.w;
206 |     var maxV = p[0];
207 |     var maxi = 0;
208 | 
209 |     for (var i = 1; i < p.length; i++) {
210 | 
211 |       if (p[i] > maxV) {
212 |         maxV = p[i];
213 |         maxi = i;
214 |       }
215 |     }
216 | 
217 |     return maxi;//returns the index of the class with the highest score
218 |   }
219 | 
220 |   exports = exports || {};
221 |   exports.img_to_vol = img_to_vol;
222 |   exports.drawImg= drawImg;
223 |   exports.draw_activations = draw_activations;
224 |   exports.split_dataset = split_dataset;
225 |   exports.getTopPrediction = getTopPrediction;
226 |   exports.getSVMPrediction = getSVMPrediction;
227 |   return exports;
228 | 
229 | })(module.exports);//added to exports
230 | 


--------------------------------------------------------------------------------