├── .editorconfig
├── .gitignore
├── .jscsrc
├── .jshintrc
├── LICENSE
├── README.md
├── bower.json
├── package.json
└── src
    ├── agent.js
    ├── config.js
    ├── main.js
    ├── rat.js
    ├── ratsim.js
    ├── robot.js
    ├── ros.js
    ├── utils.js
    └── vendor
        ├── convnet.js
        └── uncertain
            ├── convnet.js
            └── deepqlearn.js


/.editorconfig:
--------------------------------------------------------------------------------
1 | [*.js]
2 | indent_style = space
3 | indent_size = 2
4 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Logs
 2 | logs
 3 | *.log
 4 | 
 5 | # Runtime data
 6 | pids
 7 | *.pid
 8 | *.seed
 9 | 
10 | # Directory for instrumented libs generated by jscoverage/JSCover
11 | lib-cov
12 | 
13 | # Coverage directory used by tools like istanbul
14 | coverage
15 | 
16 | # Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
17 | .grunt
18 | 
19 | # node-waf configuration
20 | .lock-wscript
21 | 
22 | # Compiled binary addons (http://nodejs.org/api/addons.html)
23 | build/Release
24 | 
25 | # Dependency directory
26 | # https://www.npmjs.org/doc/misc/npm-faq.html#should-i-check-my-node_modules-folder-into-git
27 | node_modules
28 | bower_components
29 | 
30 | brains
31 | 


--------------------------------------------------------------------------------
/.jscsrc:
--------------------------------------------------------------------------------
 1 | {
 2 |     "disallowEmptyBlocks": true,
 3 |     "disallowKeywordsOnNewLine": ["else"],
 4 |     "disallowMultipleLineStrings": true,
 5 |     "disallowNewlineBeforeBlockStatements": true,
 6 |     "disallowOperatorBeforeLineBreak": ["."],
 7 |     "disallowSpaceAfterObjectKeys": true,
 8 |     "disallowSpaceAfterPrefixUnaryOperators": ["++", "--", "~", "!"],
 9 |     "disallowSpaceBeforePostfixUnaryOperators": ["++", "--"],
10 |     "disallowSpacesInCallExpression": true,
11 |     "disallowSpacesInsideArrayBrackets": true,
12 |     "disallowTrailingComma": true,
13 |     "disallowYodaConditions": true,
14 |     "requireCommaBeforeLineBreak": true,
15 |     "requireSpaceAfterKeywords": [
16 |         "do",
17 |         "for",
18 |         "if",
19 |         "else",
20 |         "case",
21 |         "try",
22 |         "catch",
23 |         "while",
24 |         "with",
25 |         "return"
26 |     ],
27 |     "requireSpaceBeforeBlockStatements": true,
28 |     "requireSpaceBeforeKeywords": [
29 |         "else",
30 |         "while",
31 |         "catch"
32 |     ],
33 |     "requireSpaceBeforeObjectValues": true,
34 |     "requireSpacesInForStatement": true,
35 |     "safeContextKeyword": "_self"
36 | }
37 | 


--------------------------------------------------------------------------------
/.jshintrc:
--------------------------------------------------------------------------------
1 | {
2 |   "esnext": false
3 | }
4 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # ROS + DQN + RatSLAM
 2 | 
 3 | Training Deep Q-Learning neural network based on ConvNetJS demo to use sonar range sensors and RatSLAM goals.
 4 | 
 5 | * [ConvNetJS - demo](http://cs.stanford.edu/people/karpathy/convnetjs/demo/rldemo.html)
 6 | * [ROSLibJS](https://github.com/RobotWebTools/roslibjs/)
 7 | * [RatSLAM fork](https://github.com/mryellow/ratslam) (extended ROS integration)
 8 | 
 9 | # Status
10 | 
11 | Got busy and distracted, it works well enough for direct goal seeking and that may be enough to train up an agent which makes pretty maps in RatSLAM (if not straying too far before turning back). Have some decent [experiments](https://github.com/mryellow/reinforcejs/tree/demo-multiagent) with [ReinforceJS](http://cs.stanford.edu/people/karpathy/reinforcejs/). Finding goals on the other side of walls and traps will require a different implementation, namely Actor-critic and/or Actor-mimic style architectures to get around these opstacles (when a goal can be seen on the other side of a trap). 
12 | 
13 | # Setup
14 | 
15 | ```
16 | npm install
17 | bower install
18 | ```
19 | 
20 | # TODO
21 | 
22 | * [ ] Teleop.
23 | * [ ] Integrate IMU/tilt/odom feedback.
24 | * [ ] Catkin-ise.
25 | * [ ] Define custom ROS messages.
26 | * [ ] LTM/STM with long-term sets of "important" experiences.
27 | * [ ] Save/load DQN experience sets.
28 | 
29 | # Usage
30 | 
31 | ```
32 | roslaunch kulbu_base sim.launch world:=rat1
33 | roslaunch kulbu_slam rat.launch use_rat_odom:=false topic_odom:=/kulbu/odometry/filtered
34 | rosrun turtlebot_teleop turtlebot_teleop_key /turtlebot_teleop/cmd_vel:=/kulbu/diff_drive_controller/cmd_vel
35 | 
36 | roslaunch rosbridge_server rosbridge_websocket.launch # ROSLibJS
37 | node src/main.js
38 | node src/main.js --noise # Generate noise on extra sensors.
39 | node src/ratsim.js # Simulate RatSLAM goals for training.
40 | rqt_plot /dqn/reward:epsilon
41 | rqt_plot /dqn/avg_reward:avg_loss
42 | 
43 | rostopic pub -1 /dqn/status std_msgs/String -- '"{\"learning\": true, \"moving\": true, \"sensors\": false}"' # TODO: Custom message format.
44 | rostopic pub -1 /dqn/save std_msgs/String -- 'file'   # Save DQN as JSON.
45 | rostopic pub -1 /dqn/load std_msgs/String -- 'file'   # Load DQN from JSON.
46 | rostopic pub -1 /dqn/set_age std_msgs/String -- '"100000"' # FIXME: Datatype.
47 | ```
48 | 
49 | # Future work
50 | 
51 | ## RatSLAM
52 | 
53 | * [x] Reverse goal order and tweak for use on exploration tasks.
54 | * [ ] Discard experiences with *many* links.
55 | * [ ] Quality metric for LV. Don't link low quality experiences.
56 | * [ ] Reject closures with vastly different magnetic reading?
57 | * [ ] Implement multi Experience Maps [RatSLAM on Humanoids](https://www2.informatik.uni-hamburg.de/wtm/ps/M%C3%BCller_ICANN2014_CR.pdf)
58 | 
59 | ## DQN
60 | 
61 | * Further test [Dropout uncertainty](https://github.com/yaringal/DropoutUncertaintyDemos/).
62 | * Implement in [Caffe](https://github.com/muupan/dqn-in-the-caffe) [fork](https://github.com/mhauskn/dqn) or [Theano](https://github.com/spragunr/deep_q_rl) if not [Torch](https://github.com/kuz/DeepMind-Atari-Deep-Q-Learner)
63 | 


--------------------------------------------------------------------------------
/bower.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "dqn-ros",
 3 |   "version": "0.0.0",
 4 |   "authors": [
 5 |     "Mr-Yellow <mr-yellow@mr-yellow.com>"
 6 |   ],
 7 |   "main": "src/dqn.js",
 8 |   "moduleType": [
 9 |     "node"
10 |   ],
11 |   "license": "MIT",
12 |   "ignore": [
13 |     "**/.*",
14 |     "node_modules",
15 |     "bower_components",
16 |     "test",
17 |     "tests"
18 |   ],
19 |   "dependencies": {
20 |     "convnetjs": "https://github.com/karpathy/convnetjs.git"
21 |   },
22 |   "devDependencies": {
23 |     "convnetjs": "https://github.com/karpathy/convnetjs.git"
24 |   }
25 | }
26 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "ros-dqn-rat-js",
 3 |   "version": "1.0.0",
 4 |   "description": "",
 5 |   "main": "src/main.js",
 6 |   "scripts": {
 7 |     "test": "echo \"Error: no test specified\" && exit 1"
 8 |   },
 9 |   "author": "Mr-Yellow",
10 |   "license": "MIT",
11 |   "devDependencies": {
12 |     "fs": "0.0.2",
13 |     "jStat": "^1.3.0",
14 |     "path": "^0.11.14",
15 |     "roslib": "^0.15.0"
16 |   }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/agent.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Sensor sensor has a maximum range and senses walls
  3 |  * @class
  4 |  * @constructor {object} input
  5 |  */
  6 | var Sensor = function(input) {
  7 |   console.log('Creating sensor', input.name);
  8 |   this.name             = (input && input.name)?      input.name:'';
  9 |   this.angle            = (input && input.angle)?     input.angle:0;
 10 |   this.fov              = (input && input.fov)?       input.fov:(15*Math.PI/180); // Default 15deg.
 11 |   this.max_range        = (input && input.max_range)? input.max_range:4;
 12 |   this.max_type         = (input && input.max_type)?  input.max_type:1;
 13 |   this.sensed_proximity = this.max_range;
 14 |   this.sensed_type      = -1; // what does the eye see?
 15 | 
 16 |   // Watch for updates, syncing framerate to sensors.
 17 |   this.updated = false;
 18 | };
 19 | 
 20 | 
 21 | // RatSLAM Goal log for rewarding distance.
 22 | var Goal = function(id, dis, rad) {
 23 |   //console.log('Creating goal', id, dis, rad);
 24 |   this.id  = id;
 25 |   this.dis = dis;
 26 |   this.rad = rad;
 27 | };
 28 | 
 29 | /**
 30 |  * A single agent
 31 |  * @class Agent
 32 |  * @param {Ros} ros
 33 |  * @param {object} sensors
 34 |  * @param {array} actions
 35 |  * @param {object} brain_opts
 36 |  */
 37 | var Agent = function(ros, sensors, actions, brain_opts) {
 38 |   if (!ros) throw new Exception('ROS instance must be passed to RatSLAM.');
 39 |   this.ros = ros;
 40 |   var i,j;
 41 | 
 42 |   // TODO: Validate given configs and throw errors.
 43 | 
 44 |   this.repeat_cnt = 0;
 45 | 
 46 |   // Initialise eyes from config passed in.
 47 |   // TODO: Handle any number of sensor types.
 48 |   var num_inputs = 0;
 49 |   this.sensors = {};
 50 |   for (j in sensors) {
 51 |     if (sensors.hasOwnProperty(j)) {
 52 |       for (i=0; i<sensors[j].length; i++) {
 53 |         if (typeof(sensors[j][i].angle) !== 'undefined' && typeof(sensors[j][i].fov) !== 'undefined') {
 54 |           if (typeof(this.sensors[j]) === 'undefined') this.sensors[j] = [];
 55 |           this.sensors[j].push(new Sensor(sensors[j][i]));
 56 |           num_inputs += sensors[j][i].max_type;
 57 |         }
 58 |       }
 59 |     }
 60 |   }
 61 | 
 62 |   this.actions = (actions)?actions:[
 63 |     // Default actions.
 64 |     [1.0,0.0],
 65 |     [1.0,-3.0],
 66 |     [1.0,3.0],
 67 |     [0.0,-4.0],
 68 |     [0.0,4.0]
 69 |   ];
 70 | 
 71 |   // Remember RatSLAM goals for rewarding distance.
 72 |   // FIXME: We only need the last one right? Was expecting to compare them...
 73 |   this.goals = [];
 74 | 
 75 |   var num_actions     = this.actions.length;
 76 |   var temporal_window = brain_opts.temporal_window; // amount of temporal memory. 0 = agent lives in-the-moment :)
 77 |   var network_size = num_inputs*temporal_window + num_actions*temporal_window + num_inputs;
 78 |   console.log('Input network size:', network_size);
 79 | 
 80 |   // the value function network computes a value of taking any of the possible actions
 81 |   // given an input state. Here we specify one explicitly the hard way
 82 |   // but user could also equivalently instead use opt.hidden_layer_sizes = [20,20]
 83 |   // to just insert simple relu hidden layers.
 84 |   var layer_defs = [];
 85 |   layer_defs.push({type: 'input', out_sx: 1, out_sy: 1, out_depth: network_size});
 86 |   layer_defs.push({type: 'fc', num_neurons: 50, activation: 'relu'});
 87 |   //layer_defs.push({type: 'dropout', drop_prob: 0.2}); // Uncertainty approximation.
 88 |   layer_defs.push({type: 'fc', num_neurons: 50, activation: 'relu'});
 89 |   layer_defs.push({type: 'regression', num_neurons: num_actions});
 90 | 
 91 |   brain_opts.layer_defs = layer_defs;
 92 | 
 93 |   var brain = new deepqlearn.Brain(num_inputs, num_actions, brain_opts); // woohoo
 94 | 
 95 |   this.brain = brain;
 96 | 
 97 |   this.reward_bonus = 0.0;
 98 |   this.digestion_signal = 0.0;
 99 | 
100 |   // outputs on world
101 |   this.linX = 0.0; // Linear velocity forwards.
102 |   this.angZ = 0.0; // Angular velocity rotation.
103 | };
104 | 
105 | Agent.prototype = {
106 |   /**
107 |    * Add RatSLAM goal to memory for later reward
108 |    * @method addGoal
109 |    * @param {integer} id
110 |    * @param {float} dis
111 |    * @param {float} rad
112 |    */
113 |   addGoal: function(id, dis, rad) {
114 |     // TODO: If Goal ID has changed, publish an "eat" reward?
115 |     // Does it only change when eaten? Not really, it changes when shortcut too.
116 |     this.goals.push(new Goal(id, dis, rad));
117 |     // Truncate log, only need a few to gauge getting closer.
118 |     this.goals = this.goals.slice(-2);
119 |   },
120 |   forward: function() {
121 |     // in forward pass the agent simply behaves in the environment
122 | 
123 |     // create input to brain
124 |     var i,j;
125 |     var idx = 0;
126 |     var num_inputs = 0;
127 |     for (j in this.sensors) {
128 |       if (this.sensors.hasOwnProperty(j)) {
129 |         num_inputs += this.sensors[j].length;
130 |       }
131 |     }
132 |     var input_array = new Array(num_inputs * 1);
133 | 
134 |     var idx_last = 0;
135 |     for (j in this.sensors) {
136 |       if (this.sensors.hasOwnProperty(j)) {
137 |         for (i=0; i<this.sensors[j].length; i++) {
138 |           var s = this.sensors[j][i];
139 |           idx = (i * s.max_type)+idx_last;
140 |           for (k=0; k<s.max_type; k++) {
141 |             input_array[idx+k] = 1.0;
142 |           }
143 |           if (s.sensed_type !== -1) {
144 |             input_array[idx+s.sensed_type] = s.sensed_proximity/s.max_range; // normalize to [0,1]
145 |           }
146 |         }
147 |         // Offset the next sensor group by this much.
148 |         idx_last = this.sensors[j].length * this.sensors[j][0].max_type;
149 |       }
150 |     }
151 | 
152 |     // get action from brain
153 |     var actionix = this.brain.forward(input_array);
154 |     var action = this.actions[actionix];
155 |     this.actionix = actionix; //back this up
156 | 
157 |     // demultiplex into behavior variables
158 |     this.linX = action[0]*1;
159 |     this.angZ = action[1]*1;
160 |   },
161 |   backward: function() {
162 |     // in backward pass agent learns.
163 |     // compute reward
164 |     var proximity_reward = 0.0;
165 |     var num_eyes = this.sensors.eyes.length;
166 |     for (var i=0; i<num_eyes; i++) {
167 |       var e = this.sensors.eyes[i];
168 |       // agents dont like to see walls, especially up close
169 |       proximity_reward += e.sensed_type === 0 ? e.sensed_proximity/e.max_range : 1.0;
170 |     }
171 |     proximity_reward = proximity_reward/num_eyes;
172 |     proximity_reward = Math.min(1.0, proximity_reward * 2);
173 | 
174 |     // agents like to be near goals
175 |     var goal_factor = 0.0;
176 |     var goal_reward = 0.0;
177 |     /*
178 |     Deprecated, interesting results, come back to this with more experiments.
179 |     if (this.goals[this.goals.length-1] && this.goals[this.goals.length-1].dis > 0) {
180 |       goal_factor = Math.max(0.0, Math.min(1.0, 1/this.goals[this.goals.length-1].dis));
181 |       //goal_reward = 0.1 * goal_factor * proximity_reward;
182 |     }
183 |     */
184 | 
185 |     // agents like to go straight forward, more-so towards goals. // FIXME: "near" goals... side-effect, max towards goal.
186 |     var forward_reward = 0.0;
187 |     // TODO: Put thresholds in config.
188 |     // TODO: Refactor to overloadable functions like `random_action`.
189 |     if ((this.actionix === 0 || this.actionix === 1 || this.actionix === 2)) {
190 |       // Some forward reward, some forward goal reward.
191 |       // Instead of proximity threshold, a lower limit of 0.2.
192 |       forward_reward = 0.1 * Math.pow(proximity_reward, 2);
193 |       // Half as much for forward turns.
194 |       if (this.actionix === 1 || this.actionix === 2) {
195 |         forward_reward = forward_reward / 2;
196 |       }
197 |     }
198 | 
199 |     // agents like to eat good things
200 |     var digestion_reward = this.digestion_signal;
201 |     this.digestion_signal = 0.0;
202 | 
203 |     var reward = proximity_reward + forward_reward + goal_reward + digestion_reward;
204 | 
205 |     // Log repeating actions.
206 |     // FIXME: Age stops increasing when not learning, spams log.
207 |     if (this.brain.age % 10 === 0) {
208 |       console.log(
209 |         ' a:'+this.actionix,
210 |         //'/'+this.repeat_cnt,
211 |         ' =:'+reward.toFixed(5),
212 |         ' p:'+proximity_reward.toFixed(3),
213 |         ' f:'+forward_reward.toFixed(3),
214 |         //' g:'+goal_reward.toFixed(3),
215 |         ' d:'+digestion_reward.toFixed(3)
216 |       );
217 |     }
218 | 
219 |     // Pause publishing statistics when not learning.
220 |     if (this.brain.learning) {
221 |       //this.ros.pubTopic('/dqn/learning',   'std_msgs/Float32', this.ros.createStdMsg('float', (this.brain.learning)?1:0));
222 |       //this.ros.pubTopic('/dqn/reward',     'std_msgs/Float32', this.ros.createStdMsg('float', reward));
223 |       //this.ros.pubTopic('/dqn/action',   'std_msgs/Float32', this.ros.createStdMsg('float', this.actionix));
224 |       //this.ros.pubTopic('/dqn/epsilon',    'std_msgs/Float32', this.ros.createStdMsg('float', this.brain.epsilon));
225 |       this.ros.pubTopic('/dqn/avg_loss',   'std_msgs/Float32', this.ros.createStdMsg('float', this.brain.average_loss_window.get_average()));
226 |       this.ros.pubTopic('/dqn/avg_reward', 'std_msgs/Float32', this.ros.createStdMsg('float', this.brain.average_reward_window.get_average()));
227 |       //this.ros.pubTopic('/dqn/age',      'std_msgs/Float32', this.ros.createStdMsg('float', this.brain.age));
228 |     }
229 | 
230 |     // pass to brain for learning
231 |     this.brain.backward(reward);
232 |   }
233 | };
234 | 
235 | module.exports = Agent;
236 | 


--------------------------------------------------------------------------------
/src/config.js:
--------------------------------------------------------------------------------
 1 | var nostril_fov = 2*Math.PI/31; // 31 per revolution
 2 | 
 3 | var nostrils = [];
 4 | for (var x=1; x<=31; x++) {
 5 |   nostrils.push('nostril_'+x);
 6 | }
 7 | 
 8 | module.exports = {
 9 |   main_loop: 30, // Hz
10 |   goal_distance: 20, // How many RatSLAM experiences ago to set goal?
11 |   sensors: {
12 |     eyes: {
13 |       names: ['range_3l','range_2l','range_1l','range_0','range_1r','range_2r','range_3r'],
14 |       fov: 15*Math.PI/180, // 15deg
15 |       range: 4,
16 |       types: 1
17 |     },
18 |     nostrils: {
19 |       names: nostrils,
20 |       fov: nostril_fov,
21 |       range: 25,
22 |       types: 1
23 |     }
24 |   },
25 |   actions: [
26 |     [1.0,0.0],
27 |     [1.0,-3.0], // FIXME: 4 will work... less forward? pub some of these 1 time to see.
28 |     [1.0,3.0],
29 |     [0.0,-4.0],
30 |     [0.0,4.0]
31 |   ],
32 |   brain_opts: {
33 |     temporal_window: 2,
34 |     behavior_policy: 'greedy', // TODO: Implement 'thompson' Dropout uncertainty.
35 |     experience_size: 100000,
36 |     start_learn_threshold: 1000,
37 |     gamma: 0.7,
38 |     learning_steps_total: 300000,
39 |     learning_steps_burnin: 3000,
40 |     epsilon_min: 0.05,
41 |     epsilon_test_time: 0.05,
42 |     // options for the Temporal Difference learner that trains the net
43 |     // by backpropping the temporal difference learning rule.
44 |     tdtrainer_options: {
45 |       learning_rate: 0.001,
46 |       momentum: 0.0,
47 |       batch_size: 64,
48 |       l2_decay: 0.01
49 |     },
50 |     // Prefer turning, to easier get unstuck while training.
51 |     random_action_distribution: [0.1, 0.15, 0.15, 0.3, 0.3]
52 |   },
53 |   ratsim_opts: {
54 |     goal_timeout: 60, // Seconds
55 |     goal_model: 'rat_goal',
56 |     goal_height: 1.25,
57 |     goal_reached: 0.2,
58 |     robot_model: 'kulbu',
59 |     bounds: {
60 |       x: {
61 |         min: -5,
62 |         max: 5
63 |       },
64 |       y: {
65 |         min: -1,
66 |         max: 5
67 |       }
68 |     }
69 |   }
70 | };
71 | 


--------------------------------------------------------------------------------
/src/main.js:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env node
  2 | 
  3 | var ROSLIB = require('roslib');
  4 | var fs = require('fs');
  5 | var jStat = require('jStat').jStat;
  6 | 
  7 | //http://mlg.eng.cam.ac.uk/yarin/blog_3d801aa532c1ce.html
  8 | //GLOBAL.convnetjs   = require('./vendor/uncertain/convnet.js');
  9 | //GLOBAL.deepqlearn  = require('./vendor/uncertain/deepqlearn.js');
 10 | 
 11 | // Global to bring into scope for ConvNetJS.
 12 | //GLOBAL.convnetjs   = require('./vendor/convnet.js'); // Not included in repo.
 13 | GLOBAL.convnetjs   = require('../bower_components/convnetjs/build/convnet.js'); // Compiled with `cd bower_components/convnetjs/compile && ant -lib yuicompressor-2.4.8.jar -f build.xml`
 14 | GLOBAL.deepqlearn  = require('../bower_components/convnetjs/build/deepqlearn.js');
 15 | GLOBAL.cnnutil     = require('../bower_components/convnetjs/build/util.js');
 16 | 
 17 | var config = require('./config.js');
 18 | var Ros    = require('./ros.js');
 19 | var Robot  = require('./robot.js');
 20 | var Rat    = require('./rat.js');
 21 | var Agent  = require('./agent.js');
 22 | var Utils  = require('./utils.js');
 23 | 
 24 | var ros = new Ros();
 25 | var rob = new Robot(ros, '/kulbu', 'diff_drive_controller/cmd_vel');
 26 | var rat = new Rat(ros);
 27 | 
 28 | /**
 29 |  * Initialise sensor positions.
 30 |  * @function
 31 |  * @return {object}
 32 |  */
 33 | var initSensors = function() {
 34 |   var res = {};
 35 |   for (var j in config.sensors) {
 36 |     if (config.sensors.hasOwnProperty(j)) {
 37 |       var fov   = config.sensors[j].fov;
 38 |       var types = config.sensors[j].types;
 39 |       var range = config.sensors[j].range;
 40 |       for (var i=0; i<config.sensors[j].names.length; i++) {
 41 |         var rad = (i-((config.sensors[j].names.length-1)/2))*fov;
 42 |         if (typeof(res[j]) === 'undefined') res[j] = [];
 43 |         res[j].push({
 44 |           name:      config.sensors[j].names[i],
 45 |           angle:     rad,
 46 |           fov:       fov,
 47 |           max_range: range,
 48 |           max_type:  config.sensors[j].types
 49 |         });
 50 |       }
 51 |     }
 52 |   }
 53 |   console.log(res);
 54 |   return res;
 55 | };
 56 | 
 57 | /**
 58 |  * Initialise Agent
 59 |  */
 60 | var agt = new Agent(
 61 |   ros,
 62 |   initSensors(),
 63 |   config.actions,
 64 |   config.brain_opts
 65 | );
 66 | 
 67 | /**
 68 |  * Overload `random_action` to randomly turn on the spot.
 69 |  * Simulated robot with wheels out front not as slippery as original demo.
 70 |  * @function
 71 |  * @return {integer}
 72 |  */
 73 | var repeat_cnt = 0;
 74 | var repeat_act = 0;
 75 | agt.brain.random_action_legacy = agt.brain.random_action;
 76 | agt.brain.random_action = function() {
 77 |     // Going badly for a long time, or at start of training.
 78 |     // Robot physics make getting unstuck harder than original, give it a hand.
 79 |     if (agt.brain.average_reward_window.get_average() < 0.6 || agt.brain.epsilon > 0.3) {
 80 |         var seed = convnetjs.randi(0, 150);
 81 |         if (seed < 1) {
 82 |             repeat_act = convnetjs.randi(3, 5);
 83 |             repeat_cnt = 30;
 84 |             console.log('Repeat: ' + repeat_act);
 85 |         }
 86 |         if (repeat_cnt > 0) {
 87 |             repeat_cnt--;
 88 |             return repeat_act;
 89 |         }
 90 |     }
 91 |     return agt.brain.random_action_legacy();
 92 | };
 93 | 
 94 | /**
 95 |  * Lookup a sensor array by name.
 96 |  * @function
 97 |  * @param {array} arr
 98 |  * @param {string} name
 99 |  * @return {mixed}
100 |  */
101 | var findByName = function(arr, name) {
102 |   for (var i=0; i<arr.length; i++) {
103 |     if (arr[i].name === name) {
104 |       return arr[i];
105 |     }
106 |   }
107 |   return;
108 | };
109 | 
110 | /**
111 |  * Lookup a sensor array by view direction.
112 |  * @function
113 |  * @param {array} arr
114 |  * @param {float} rad
115 |  * @return {mixed}
116 |  */
117 | var findByAngle = function(arr, rad) {
118 |   for (var i=0; i<arr.length; i++) {
119 |     // FIXME: `=` missing exact gap between, grabbing it from one side, half it?
120 |     if (rad > arr[i].angle - (arr[i].fov/2) && rad <= arr[i].angle + (arr[i].fov/2)) {
121 |       return arr[i];
122 |     }
123 |   }
124 |   return;
125 | };
126 | 
127 | /**
128 |  * Lookup a sensor array by view direction.
129 |  * @function
130 |  * @param {array} arr
131 |  */
132 | var resetSensors = function(arr) {
133 |   for (var i=0; i<arr.length; i++) {
134 |     arr[i].sensed_proximity = arr[i].max_range;
135 |     arr[i].sensed_type = -1;
136 |     arr[i].updated = true;
137 |   }
138 | };
139 | 
140 | /**
141 |  * Inform agent of range sensors from ROS
142 |  * @callback getRange
143 |  * @param {object} message
144 |  * @todo validate message
145 |  */
146 | var getRange = function(message) {
147 |   var frameId = message.header.frame_id;
148 |   var topicName = frameId.replace('_link', '');
149 |   var s = findByName(agt.sensors.eyes, topicName);
150 |   if (s) {
151 |     s.sensed_proximity = message.range;
152 |     s.sensed_type = 0;
153 |     s.updated = true;
154 |   }
155 |   //console.log('getRange', message.range, e);
156 | };
157 | 
158 | /**
159 |  * Inform agent of sub goals from RatSLAM
160 |  * @callback getGoal
161 |  * @param {object} message
162 |  */
163 | var getGoal = function(message) {
164 |   // Reset all goal sensors.
165 |   resetSensors(agt.sensors.nostrils);
166 | 
167 |   // Update the matching sensor.
168 |   var s = findByAngle(agt.sensors.nostrils, message.rad);
169 |   if (s) {
170 |     s.sensed_proximity = message.dis;
171 |     s.sensed_type = 0;
172 |     s.updated = true;
173 |   }
174 |   // Record for rewarding later.
175 |   agt.addGoal(message.id, message.dis, message.rad);
176 | };
177 | 
178 | /**
179 |  * Create goals each time RatSLAM map updates
180 |  * @callback getMap
181 |  * @param {object} message
182 |  */
183 | var getMap = function(message) {
184 |   var past_exp = message.node[message.node.length - config.goal_distance];
185 |   if (past_exp && past_exp.pose && past_exp.pose.position && agt.brain.epsilon < 0.5 && message.node.length < 50000) {
186 |     // FIXME: Use `id` instead. No need to map distances and lookup nearest, we already have it.
187 |     rat.createGoal(past_exp.pose.position.x, past_exp.pose.position.y);
188 |   }
189 | 
190 |   // Reset now as we won't get a SubGoal signal when goals are completed.
191 |   // FIXME: Not reset when goal is lacking and map is yet to arrive.
192 |   resetSensors(agt.sensors.nostrils);
193 | };
194 | 
195 | // Subscribe to each range sensors ROS topic.
196 | for (var i=0; i<config.sensors.eyes.names.length; i++) {
197 |   rob.subRange(config.sensors.eyes.names[i], getRange);
198 | }
199 | 
200 | // Subscribe to RatSLAM `SubGoal`.
201 | rat.subGoal(getGoal);
202 | 
203 | // Subscribe to RatSLAM `Map`.
204 | rat.subMap(getMap);
205 | 
206 | var utils = new Utils(ros, '/dqn', agt);
207 | 
208 | /**
209 |  * Main loop.
210 |  */
211 | agt.repeat_cnt = 0; // Counter for limiting logs to repeating events.
212 | var actionix = 0;
213 | 
214 | //var wait_cnt = 0;
215 | var timer_cnt = 0;
216 | var timer_time = 0;
217 | var tick = function() {
218 |   var time_start = new Date().getTime();
219 |   var i,j;
220 | 
221 |   // Foward
222 |   agt.forward();
223 | 
224 |   // Mark eyes/sensors as not updated.
225 |   var num_sens = 0;
226 |   for (j in agt.sensors) {
227 |     if (agt.sensors.hasOwnProperty(j)) {
228 |       for (i=0; i<agt.sensors[j].length; i++) {
229 |         agt.sensors[j][i].updated = false;
230 |         num_sens++;
231 |       }
232 |     }
233 |   }
234 | 
235 |   // Execute the move.
236 |   if (utils.moving) rob.doMove(agt.linX, agt.angZ);
237 | 
238 |   // Keep track of how many repeats of same command.
239 |   // FIXME: Keeps counting when paused.
240 |   if (actionix === agt.actionix) {
241 |     agt.repeat_cnt++;
242 |   } else {
243 |     agt.repeat_cnt = 0;
244 |   }
245 | 
246 |   // Give the state a chance to change.
247 |   var timer = setInterval(function() {
248 |     // Wait for an update from all eyes/sensors.
249 |     var i;
250 |     var updated = 0;
251 |     for (j in agt.sensors) {
252 |       if (agt.sensors.hasOwnProperty(j)) {
253 |         for (i=0; i<agt.sensors[j].length; i++) {
254 |           if (agt.sensors[j][i].updated) updated++;
255 |         }
256 |       }
257 |     }
258 |     // TODO: Wait for sensors also.
259 |     //console.log('updated', updated, num_sens);
260 |     //wait_cnt++;
261 | 
262 |     if (updated >= num_sens) {
263 |       //wait_cnt = 0;
264 |       clearInterval(timer);
265 | 
266 |       // agents like to look at goals, especially up close, but not through walls
267 | 
268 |       // Digestion reward if in centre eye and close.
269 |       var s = findByAngle(agt.sensors.nostrils, 0);
270 |       var e = findByName(agt.sensors.eyes, 'range_0');
271 |       if (s.sensed_proximity < 0.5) {
272 |         agt.digestion_signal += 0.1 * (e.sensed_proximity/e.max_range) * (1/(s.sensed_proximity/s.max_range));
273 |         console.log('Digestion:', agt.digestion_signal);
274 |       }
275 | 
276 |       /*
277 |       var eye = agt.eyes[findEye('range_0')];
278 |       var ran = agt.sensors[findByName(agt.sensors.nostrils, 'goal_range')];
279 |       var dir = agt.sensors[findSensor('goal_direction')];
280 |       if (dir.active && ran.sensed_value < ran.max_value) {
281 |         // Inversely proportional to the square of the distance.
282 |         var ran_factor = 1/Math.pow(ran.sensed_value, 2);
283 | 
284 |         // FIXME: Use all eyes or expose agent proximity reward?
285 |         var wall_factor = eye.sensed_proximity/eye.max_range;
286 | 
287 |         // Proportional to the closeness to centre of view.
288 |         var cen_factor = jStat.normal.pdf(dir.sensed_value, 180, 45)*100;
289 | 
290 |         var dir_reward = 5 * ran_factor * wall_factor * cen_factor;
291 |         /
292 |         console.log(
293 |           'dir_reward',
294 |           ' =:'+dir_reward.toFixed(5),
295 |           ' r:'+ran_factor.toFixed(3),
296 |           ' w:'+wall_factor.toFixed(3),
297 |           ' c:'+cen_factor.toFixed(3),
298 |           parseInt(dir.sensed_value)
299 |         );
300 |         /
301 |         agt.digestion_signal += dir_reward;
302 |       }
303 |       */
304 | 
305 |       // Backward
306 |       agt.backward();
307 |       actionix = agt.actionix;
308 | 
309 |       if (timer_time > 5000) {
310 |         console.log(
311 |           'fps:' + (timer_cnt/(timer_time/1000)).toFixed(1),
312 |           'e:' + agt.brain.epsilon.toFixed(2),
313 |           'l:' + agt.brain.average_loss_window.get_average().toFixed(2),
314 |           'r:' + agt.brain.average_reward_window.get_average().toFixed(2)
315 |         );
316 |         timer_time = 0;
317 |         timer_cnt = 0;
318 |       }
319 |       var time_end = new Date().getTime();
320 |       timer_time += time_end - time_start;
321 |       timer_cnt++;
322 | 
323 |       tick();
324 |     }
325 |   }, (1000/config.main_loop)); // Hz, Faster than sonars but checking for their updates.
326 | };
327 | tick();
328 | 


--------------------------------------------------------------------------------
/src/rat.js:
--------------------------------------------------------------------------------
 1 | var ROSLIB = require('roslib');
 2 | 
 3 | /**
 4 |  * RatSLAM.
 5 |  * @class Rat
 6 |  * @param {Ros} ros
 7 |  * @param {string} namespace
 8 |  */
 9 | var Rat = function(ros, namespace) {
10 |   if (!ros) throw new Exception('ROS instance must be passed to RatSLAM.');
11 |   this.ros          = ros;
12 |   this.namespace    = (namespace)?namespace:'/ratslam';
13 | };
14 | 
15 | /**
16 |  * Create goal on Experience Map
17 |  * @method createGoal
18 |  * @param {float} x
19 |  * @param {float} y
20 |  */
21 | Rat.prototype.createGoal = function(x, y) {
22 |   //console.log('Rat_createGoal');
23 |   var goal = new ROSLIB.Message({
24 |     /*
25 |     header: {
26 |       seq: 0,
27 |       stamp: {
28 |         secs: now/1000,
29 |         nsecs: now
30 |       },
31 |       frame_id: "1"
32 |     },
33 |     */
34 |     pose: {
35 |       position: {
36 |         x: parseFloat(x),
37 |         y: parseFloat(y),
38 |         z: 0
39 |       },
40 |       orientation: {
41 |         x: 0,
42 |         y: 0,
43 |         z: 0,
44 |         w: 0
45 |       }
46 |     }
47 |   });
48 |   console.log('goal', goal.pose.position);
49 |   this.ros.pubTopic(
50 |     this.namespace + '/ExperienceMap/SetGoalPose',
51 |     'geometry_msgs/PoseStamped',
52 |     goal
53 |   );
54 | };
55 | 
56 | /**
57 |  * Subscribe to RatSLAM experiences.
58 |  * @method subMap
59 |  * @param {function} callback
60 |  */
61 | Rat.prototype.subMap = function(callback) {
62 |   //console.log('Rat_subMap');
63 |   this.ros.subTopic(
64 |     this.namespace + '/ExperienceMap/Map',
65 |     'ratslam_ros/TopologicalMap',
66 |     callback
67 |   );
68 | };
69 | 
70 | /**
71 |  * Subscribe to sub goals from RatSLAM.
72 |  * @method subGoal
73 |  * @param {function} callback
74 |  */
75 | Rat.prototype.subGoal = function(callback) {
76 |   //console.log('Rat_subGoal');
77 |   this.ros.subTopic(
78 |     this.namespace + '/ExperienceMap/SubGoal',
79 |     'ratslam_ros/TopologicalGoal',
80 |     callback
81 |     //1000/25 // Incoming 50Hz, throttle.
82 |   );
83 | };
84 | 
85 | module.exports = Rat;
86 | 


--------------------------------------------------------------------------------
/src/ratsim.js:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env node
  2 | 
  3 | var ROSLIB = require('roslib');
  4 | 
  5 | var config = require('./config.js');
  6 | var Ros    = require('./ros.js');
  7 | 
  8 | // TODO: Throw errors on invalid config.
  9 | 
 10 | var ros = new Ros();
 11 | 
 12 | /**
 13 |  * Store current goal position.
 14 |  * @property {object} saved_goal
 15 |  */
 16 | var saved_goal = {};
 17 | 
 18 | /**
 19 |  * Calculate direction and distance to goal.
 20 |  * @function updateGoal
 21 |  * @param {float} robot_x
 22 |  * @param {float} robot_y
 23 |  * @param {float} robot_r
 24 |  * @param {float} goal_x
 25 |  * @param {float} goal_y
 26 |  */
 27 | var updateGoal = function (robot_x, robot_y, robot_r, goal_x, goal_y) {
 28 |   if (typeof(robot_x) === 'undefined' || typeof(robot_y) === 'undefined' ||
 29 |     typeof(goal_x) === 'undefined' || typeof(goal_y) === 'undefined') return;
 30 |   //console.log('updateGoal', robot_x.toFixed(4), robot_y.toFixed(4), robot_r.toFixed(4), goal_x.toFixed(4), goal_y.toFixed(4));
 31 | 
 32 |   //`tan(rad) = Opposite / Adjacent = (y2-y1)/(x2-x1)`
 33 |   var rad = Math.atan2(goal_y - robot_y, goal_x - robot_x);
 34 | 
 35 |   //`Hypotenuse = (y2-y1)/sin(rad)`
 36 |   var dis = Math.abs((goal_y - robot_y)/Math.sin(rad));
 37 | 
 38 |   // Minus robot pose from goal direction.
 39 |   rad -= robot_r;
 40 |   if (rad > Math.PI) {
 41 |     rad -= 2 * Math.PI;
 42 |   } else if (rad < -Math.PI) {
 43 |     rad += 2 * Math.PI;
 44 |   }
 45 | 
 46 |   // Publish SubGoal relative to this position.
 47 |   pubGoal(rad, dis);
 48 | 
 49 |   // If the goal distance is below threshold, publish a new one nearby.
 50 |   if (dis < config.ratsim_opts.goal_reached) {
 51 |     console.log('Goal reached');
 52 |     var new_x = robot_x + Math.random() - (config.ratsim_opts.goal_reached*3);
 53 |     var new_y = robot_y + Math.random() - (config.ratsim_opts.goal_reached*3);
 54 |     moveGoal(new_x, new_y);
 55 |   }
 56 | };
 57 | 
 58 | /**
 59 |  * Move goal to new location.
 60 |  * @function moveGoal
 61 |  * @param {integer} x
 62 |  * @param {integer} y
 63 |  */
 64 | var moveGoal = function(x, y) {
 65 |   if (typeof(x) === 'undefined' || typeof(y) === 'undefined') return;
 66 |   //console.log('moveGoal', x.toFixed(3), y.toFixed(3));
 67 |   saved_goal = {
 68 |     x: x,
 69 |     y: y
 70 |   };
 71 | 
 72 |   /**
 73 |    * gazebo_msgs/ModelState
 74 |    * {string} model_name
 75 |    * {geometry_msgs/Pose} pose
 76 |    * {geometry_msgs/Twist} twist
 77 |    * {string} reference_frame
 78 |    */
 79 |   var msg = new ROSLIB.Message({
 80 |     model_name: config.ratsim_opts.goal_model,
 81 |     pose: {
 82 |       position: { x: x, y: y ,z: config.ratsim_opts.goal_height },
 83 |       orientation: { x: 0, y: 0, z: 0, w: 0 }
 84 |     },
 85 |     twist: {
 86 |       linear: { x: 0, y: 0, z: 0 },
 87 |       angular: { x: 0, y: 0, z: 0 }
 88 |     },
 89 |     reference_frame: 'world'
 90 |   });
 91 | 
 92 |   ros.pubTopic(
 93 |     '/gazebo/set_model_state',
 94 |     'gazebo_msgs/ModelState',
 95 |     msg
 96 |   );
 97 | };
 98 | 
 99 | /**
100 |  * Publish simulated RatSLAM SubGoal message.
101 |  * @function pubGoal
102 |  * @param {float} rad
103 |  * @param {float} dis
104 |  */
105 | var pubGoal = function(rad, dis) {
106 |   if (typeof(dis) === 'undefined' || typeof(rad) === 'undefined') return;
107 |   //console.log('pubGoal', rad.toFixed(3), dis.toFixed(3));
108 | 
109 |   var msg = new ROSLIB.Message({
110 |     /*
111 |     header: {
112 |       seq: 0,
113 |       stamp: {
114 |         secs: now/1000,
115 |         nsecs: now
116 |       },
117 |       frame_id: "1"
118 |     },
119 |     */
120 |     id:  0,
121 |     dis: dis,
122 |     rad: rad
123 |   });
124 | 
125 |   ros.pubTopic(
126 |     '/ratslam/ExperienceMap/SubGoal',
127 |     'ratslam_ros/TopologicalGoal',
128 |     msg
129 |   );
130 | };
131 | 
132 | var cnt = 0;
133 | /**
134 |  * Gazebo model states topic.
135 |  * @callback getState
136 |  * @param {object} message
137 |  */
138 | var getState = function(message) {
139 |   var idx = message.name.indexOf(config.ratsim_opts.robot_model);
140 | 
141 |   // Every `move_every` ticks, move goal model.
142 |   if (cnt > config.ratsim_opts.goal_timeout * 50) cnt = 0;
143 |   // Do one straight away.
144 |   if (cnt === 0) {
145 |     var position = {};
146 |     position = {
147 |       x: Math.random() * (config.ratsim_opts.bounds.x.max - config.ratsim_opts.bounds.x.min) + config.ratsim_opts.bounds.x.min,
148 |       y: Math.random() * (config.ratsim_opts.bounds.y.max - config.ratsim_opts.bounds.y.min) + config.ratsim_opts.bounds.y.min
149 |     };
150 |     console.log('moveGoal', position.x.toFixed(3), position.y.toFixed(3));
151 |     moveGoal(position.x, position.y);
152 |   }
153 | 
154 |   // Periodically update the goal, sometimes it misses. Only for human, robot doesn't need it.
155 |   if (cnt % 200 === 0) moveGoal(saved_goal.x, saved_goal.y);
156 | 
157 |   // Extract angles from quaternion.
158 |   // http://stackoverflow.com/a/18115837/2438830
159 |   var q = message.pose[idx].orientation;
160 |   //var roll? = Math.atan2(2.0*(q.y*q.z + q.w*q.x), q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z);
161 |   //var pitch? = Math.asin(-2.0*(q.x*q.z - q.w*q.y));
162 |   var yaw = Math.atan2(2.0*(q.x*q.y + q.w*q.z), q.w*q.w + q.x*q.x - q.y*q.y - q.z*q.z);
163 |   //console.log(yaw.toFixed(3), pitch.toFixed(3), roll.toFixed(3));
164 | 
165 |   // Get publish goal position relative to current.
166 |   updateGoal(
167 |     message.pose[idx].position.x,
168 |     message.pose[idx].position.y,
169 |     yaw,
170 |     saved_goal.x,
171 |     saved_goal.y
172 |   );
173 | 
174 |   cnt++;
175 | };
176 | 
177 | /**
178 |  * Main loop.
179 |  * Slaved to gazebo topic.
180 |  * Throttled to 50Hz matching RatSLAM.
181 |  */
182 | ros.subTopic(
183 |   '/gazebo/model_states',
184 |   'gazebo_msgs/ModelStates',
185 |   getState,
186 |   50
187 | );
188 | 


--------------------------------------------------------------------------------
/src/robot.js:
--------------------------------------------------------------------------------
 1 | var ROSLIB = require('roslib');
 2 | 
 3 | /**
 4 |  * Robot.
 5 |  * @class Robot
 6 |  * @param {Ros} ros
 7 |  * @param {string} namespace
 8 |  * @param {string} topic
 9 |  */
10 | var Robot = function(ros, namespace, topic) {
11 |   if (!ros) throw new Exception('ROS instance must be passed to Robot.');
12 |   this.ros          = ros;
13 |   this.namespace    = (namespace)?namespace:'/';
14 |   this.topic_cmdvel = (topic)?topic:'cmd_vel';
15 | };
16 | 
17 | /**
18 |  * Execute a move action
19 |  * @method doMove
20 |  * @param {float} linX
21 |  * @param {float} angZ
22 |  */
23 | Robot.prototype.doMove = function(linX, angZ) {
24 |   //console.log('Robot_doMove');
25 |   var twist = new ROSLIB.Message({
26 |     linear: {
27 |       x: linX,
28 |       y: 0,
29 |       z: 0
30 |     },
31 |     angular: {
32 |       x: 0,
33 |       y: 0,
34 |       z: angZ
35 |     }
36 |   });
37 | 
38 |   this.ros.pubTopic(
39 |     this.namespace + '/' + this.topic_cmdvel,
40 |     'geometry_msgs/Twist',
41 |     twist
42 |   );
43 | };
44 | 
45 | /**
46 |  * Subscribe to range sensors
47 |  * @method subRange
48 |  * @param {string} name
49 |  * @param {function} callback
50 |  */
51 | Robot.prototype.subRange = function(name, callback) {
52 |   //console.log('Robot_subRange', name);
53 |   this.ros.subTopic(
54 |     this.namespace + '/' + name,
55 |     'sensor_msgs/Range',
56 |     callback
57 |   );
58 | };
59 | 
60 | module.exports = Robot;
61 | 


--------------------------------------------------------------------------------
/src/ros.js:
--------------------------------------------------------------------------------
  1 | var ROSLIB = require('roslib');
  2 | 
  3 | /**
  4 |  * ROSLibJS abstractionwrapper.
  5 |  * @class Rat
  6 |  */
  7 | var Ros = function(uri) {
  8 |   this._subs = [];
  9 |   this._pubs = [];
 10 |   this.uri   = (uri)?url:'ws://localhost:9090';
 11 | 
 12 |   // FIXME: Recreate if URI changes. Fine for using construtor to set...
 13 |   this._ros = new ROSLIB.Ros({
 14 |     url: this.uri
 15 |   });
 16 | 
 17 |   this._ros.on('connection', function() {
 18 |     console.log('Connected to websocket server.');
 19 |   });
 20 |   // TODO: Throw errors.
 21 |   this._ros.on('error', function(error) {
 22 |     console.log('Error connecting to websocket server: ', error);
 23 |   });
 24 |   this._ros.on('close', function() {
 25 |     console.log('Connection to websocket server closed.');
 26 |   });
 27 | };
 28 | 
 29 | /**
 30 |  * Create topic for pub/sub
 31 |  * @method createTopic
 32 |  * @param {string} topic
 33 |  * @param {string} type
 34 |  * @param {integer} rate
 35 |  * @return {ROSLib.Topic}
 36 |  */
 37 | Ros.prototype.createTopic = function(topic, type, rate) {
 38 |   //console.log('Ros_createTopic', topic, type);
 39 |   if (!rate) rate = 0;
 40 |   if (!topic || !type) return;
 41 |   return new ROSLIB.Topic({
 42 |     ros:           this._ros,
 43 |     name:          topic,
 44 |     messageType:   type,
 45 |     throttle_rate: rate
 46 |   });
 47 | };
 48 | 
 49 | /**
 50 |  * Generate various `std_msgs`
 51 |  * @method createStdMsg
 52 |  * @param {string} type
 53 |  * @param {mixed} val
 54 |  * @return {ROSLIB.Message}
 55 |  */
 56 | Ros.prototype.createStdMsg = function(type, val) {
 57 |   //console.log('Ros_createMsg', type, val);
 58 |   switch (type) {
 59 |     case 'float':
 60 |       return new ROSLIB.Message({
 61 |         data: parseFloat(val)
 62 |       });
 63 | 
 64 |     default:
 65 |       return null;
 66 |   }
 67 | };
 68 | 
 69 | /**
 70 |  * Publish a ROS message
 71 |  * @method pubTopic
 72 |  * @param {string} topic
 73 |  * @param {string} type
 74 |  * @param {ROSLIB.Message} msg
 75 |  */
 76 | Ros.prototype.pubTopic = function(topic, type, msg) {
 77 |   //console.log('Ros_pubTopic');
 78 |   // Create topic if it doesn't exist.
 79 |   if (!this._pubs[topic]) {
 80 |     this._pubs[topic] = this.createTopic(
 81 |       topic,
 82 |       type
 83 |     );
 84 |   }
 85 |   this._pubs[topic].publish(msg);
 86 | };
 87 | 
 88 | /**
 89 |  * Subscribe to a ROS topic
 90 |  * @method subTopic
 91 |  * @param {string} topic
 92 |  * @param {string} type
 93 |  * @param {function} callback
 94 |  * @param {integer} rate
 95 |  */
 96 | Ros.prototype.subTopic = function(topic, type, callback, rate) {
 97 |   //console.log('Ros_subTopic');
 98 |   if (!rate) rate = 0;
 99 |   var sub = this.createTopic(topic, type, rate).subscribe(callback);
100 |   this._subs.push(sub);
101 | };
102 | 
103 | module.exports = Ros;
104 | 


--------------------------------------------------------------------------------
/src/utils.js:
--------------------------------------------------------------------------------
  1 | var fs = require('fs');
  2 | var path = require('path');
  3 | 
  4 | /**
  5 |  * Brain utils.
  6 |  * @class Utils
  7 |  * @param {Ros} ros
  8 |  * @param {string} namespace
  9 |  * @param {Agent} agent
 10 |  */
 11 | var Utils = function(ros, namespace, agent) {
 12 |   if (!ros) throw new Exception('ROS instance must be passed to Utils.');
 13 |   var _self = this;
 14 | 
 15 |   this.ros          = ros;
 16 |   this.namespace    = (namespace)?namespace:'/dqn';
 17 |   this.agent        = agent;
 18 | 
 19 |   // Subscribe to topic for pause/resume of DQN.
 20 |   // Allowing for restart of RatSLAM, which doesn't like movement during init.
 21 |   this.moving = true;
 22 | 
 23 |   /**
 24 |    * Control DQN settings.
 25 |    */
 26 |   this.ros.subTopic(
 27 |     this.namespace + '/status',
 28 |     'std_msgs/String', // TODO: Custom message type.
 29 |     function(message) {
 30 |       if (message.data) {
 31 |         var data = JSON.parse(message.data);
 32 | 
 33 |         if (typeof(data.learning) !== "undefined")_self.agent.brain.learning = data.learning;
 34 |         if (typeof(data.moving) !== "undefined")_self.moving = data.moving;
 35 | 
 36 |         // TODO: Less crude handling of inactive goals. Based on `sensors`?
 37 |         _self.agent.goals = [];
 38 | 
 39 |         console.log('DQN status set', (message.data));
 40 |       } else {
 41 |         console.log('Invalid message');
 42 |       }
 43 |     }
 44 |   );
 45 | 
 46 |   /**
 47 |    * Set DQN Network age.
 48 |    */
 49 |   // FIXME: Not a string.
 50 |   this.ros.subTopic(
 51 |     this.namespace + '/set_age',
 52 |     'std_msgs/String',
 53 |     function(message) {
 54 |       _self.agent.brain.age = parseInt(message.data);
 55 |       console.log('DQN age set '+ message.data);
 56 |     }
 57 |   );
 58 | 
 59 |   /**
 60 |    * Load DQN from JSON file.
 61 |    */
 62 |   // FIXME: We're still waiting before `avg_loss` drops.
 63 |   this.ros.subTopic(
 64 |     this.namespace + '/load',
 65 |     'std_msgs/String',
 66 |     function(message) {
 67 |       // Sanitise filename.
 68 |       var file = message.data.replace(/[^a-z0-9]/i, '_');
 69 | 
 70 |       // TODO: Configurable path to brains.
 71 |       fs.readFile(path.resolve(__dirname, '../brains/'+file+'.json'), 'UTF-8', function read(err, data) {
 72 |         if (err) {
 73 |           return console.log('Error', err);
 74 |         }
 75 | 
 76 |         // Load the JSON.
 77 |         _self.agent.brain.value_net.fromJSON(JSON.parse(data));
 78 | 
 79 |         // TODO: Configuration left up to the user.
 80 | 
 81 |         //_self.agent.brain.age = 2 * _self.agent.brain.learning_steps_total;
 82 | 
 83 |         // FIXME: Pause learning, or increase age?
 84 |         _self.agent.brain.learning = false;
 85 | 
 86 |         // Reset goal sensors.
 87 |         // TODO: Encapsulate, duplication.
 88 |         var num_sens = agent.sensors.length;
 89 |         for (var i=0; i<num_sens; i++) {
 90 |           var s = agent.sensors[i];
 91 |           s.sensed_value = s.max_value;
 92 |           s.active = false;
 93 |         }
 94 |         _self.agent.goals = [];
 95 | 
 96 |         console.log('DQN loaded from '+ file);
 97 |       });
 98 |     }
 99 |   );
100 | 
101 |   /**
102 |    * Save DQN to JSON file.
103 |    */
104 |   this.ros.subTopic(
105 |     this.namespace + '/save',
106 |     'std_msgs/String',
107 |     function(message) {
108 |       // Sanitise filename.
109 |       var file = message.data.replace(/[^a-z0-9]/i, '_');
110 |       var json = _self.agent.brain.value_net.toJSON();
111 |       fs.writeFile(path.resolve(__dirname, '../brains/'+file+'.json'), JSON.stringify(json, null, 1), {encoding: 'utf8'}, function(err) {
112 |         if (err) {
113 |           return console.log('Error', err);
114 |         }
115 |         console.log('DQN saved to '+ file);
116 |       });
117 |     }
118 |   );
119 | 
120 | };
121 | 
122 | module.exports = Utils;
123 | 


--------------------------------------------------------------------------------
/src/vendor/convnet.js:
--------------------------------------------------------------------------------
   1 | var convnetjs = convnetjs || { REVISION: 'ALPHA' };
   2 | (function(global) {
   3 |   "use strict";
   4 | 
   5 |   // Random number utilities
   6 |   var return_v = false;
   7 |   var v_val = 0.0;
   8 |   var gaussRandom = function() {
   9 |     if(return_v) { 
  10 |       return_v = false;
  11 |       return v_val; 
  12 |     }
  13 |     var u = 2*Math.random()-1;
  14 |     var v = 2*Math.random()-1;
  15 |     var r = u*u + v*v;
  16 |     if(r == 0 || r > 1) return gaussRandom();
  17 |     var c = Math.sqrt(-2*Math.log(r)/r);
  18 |     v_val = v*c; // cache this
  19 |     return_v = true;
  20 |     return u*c;
  21 |   }
  22 |   var randf = function(a, b) { return Math.random()*(b-a)+a; }
  23 |   var randi = function(a, b) { return Math.floor(Math.random()*(b-a)+a); }
  24 |   var randn = function(mu, std){ return mu+gaussRandom()*std; }
  25 | 
  26 |   // Array utilities
  27 |   var zeros = function(n) {
  28 |     if(typeof(n)==='undefined' || isNaN(n)) { return []; }
  29 |     if(typeof ArrayBuffer === 'undefined') {
  30 |       // lacking browser support
  31 |       var arr = new Array(n);
  32 |       for(var i=0;i<n;i++) { arr[i]= 0; }
  33 |       return arr;
  34 |     } else {
  35 |       return new Float64Array(n);
  36 |     }
  37 |   }
  38 | 
  39 |   var arrContains = function(arr, elt) {
  40 |     for(var i=0,n=arr.length;i<n;i++) {
  41 |       if(arr[i]===elt) return true;
  42 |     }
  43 |     return false;
  44 |   }
  45 | 
  46 |   var arrUnique = function(arr) {
  47 |     var b = [];
  48 |     for(var i=0,n=arr.length;i<n;i++) {
  49 |       if(!arrContains(b, arr[i])) {
  50 |         b.push(arr[i]);
  51 |       }
  52 |     }
  53 |     return b;
  54 |   }
  55 | 
  56 |   // return max and min of a given non-empty array.
  57 |   var maxmin = function(w) {
  58 |     if(w.length === 0) { return {}; } // ... ;s
  59 |     var maxv = w[0];
  60 |     var minv = w[0];
  61 |     var maxi = 0;
  62 |     var mini = 0;
  63 |     var n = w.length;
  64 |     for(var i=1;i<n;i++) {
  65 |       if(w[i] > maxv) { maxv = w[i]; maxi = i; } 
  66 |       if(w[i] < minv) { minv = w[i]; mini = i; } 
  67 |     }
  68 |     return {maxi: maxi, maxv: maxv, mini: mini, minv: minv, dv:maxv-minv};
  69 |   }
  70 | 
  71 |   // create random permutation of numbers, in range [0...n-1]
  72 |   var randperm = function(n) {
  73 |     var i = n,
  74 |         j = 0,
  75 |         temp;
  76 |     var array = [];
  77 |     for(var q=0;q<n;q++)array[q]=q;
  78 |     while (i--) {
  79 |         j = Math.floor(Math.random() * (i+1));
  80 |         temp = array[i];
  81 |         array[i] = array[j];
  82 |         array[j] = temp;
  83 |     }
  84 |     return array;
  85 |   }
  86 | 
  87 |   // sample from list lst according to probabilities in list probs
  88 |   // the two lists are of same size, and probs adds up to 1
  89 |   var weightedSample = function(lst, probs) {
  90 |     var p = randf(0, 1.0);
  91 |     var cumprob = 0.0;
  92 |     for(var k=0,n=lst.length;k<n;k++) {
  93 |       cumprob += probs[k];
  94 |       if(p < cumprob) { return lst[k]; }
  95 |     }
  96 |   }
  97 | 
  98 |   // syntactic sugar function for getting default parameter values
  99 |   var getopt = function(opt, field_name, default_value) {
 100 |     return typeof opt[field_name] !== 'undefined' ? opt[field_name] : default_value;
 101 |   }
 102 | 
 103 |   global.randf = randf;
 104 |   global.randi = randi;
 105 |   global.randn = randn;
 106 |   global.zeros = zeros;
 107 |   global.maxmin = maxmin;
 108 |   global.randperm = randperm;
 109 |   global.weightedSample = weightedSample;
 110 |   global.arrUnique = arrUnique;
 111 |   global.arrContains = arrContains;
 112 |   global.getopt = getopt;
 113 |   
 114 | })(convnetjs);
 115 | (function(global) {
 116 |   "use strict";
 117 | 
 118 |   // Vol is the basic building block of all data in a net.
 119 |   // it is essentially just a 3D volume of numbers, with a
 120 |   // width (sx), height (sy), and depth (depth).
 121 |   // it is used to hold data for all filters, all volumes,
 122 |   // all weights, and also stores all gradients w.r.t. 
 123 |   // the data. c is optionally a value to initialize the volume
 124 |   // with. If c is missing, fills the Vol with random numbers.
 125 |   var Vol = function(sx, sy, depth, c) {
 126 |     // this is how you check if a variable is an array. Oh, Javascript :)
 127 |     if(Object.prototype.toString.call(sx) === '[object Array]') {
 128 |       // we were given a list in sx, assume 1D volume and fill it up
 129 |       this.sx = 1;
 130 |       this.sy = 1;
 131 |       this.depth = sx.length;
 132 |       // we have to do the following copy because we want to use
 133 |       // fast typed arrays, not an ordinary javascript array
 134 |       this.w = global.zeros(this.depth);
 135 |       this.dw = global.zeros(this.depth);
 136 |       for(var i=0;i<this.depth;i++) {
 137 |         this.w[i] = sx[i];
 138 |       }
 139 |     } else {
 140 |       // we were given dimensions of the vol
 141 |       this.sx = sx;
 142 |       this.sy = sy;
 143 |       this.depth = depth;
 144 |       var n = sx*sy*depth;
 145 |       this.w = global.zeros(n);
 146 |       this.dw = global.zeros(n);
 147 |       if(typeof c === 'undefined') {
 148 |         // weight normalization is done to equalize the output
 149 |         // variance of every neuron, otherwise neurons with a lot
 150 |         // of incoming connections have outputs of larger variance
 151 |         var scale = Math.sqrt(1.0/(sx*sy*depth));
 152 |         for(var i=0;i<n;i++) { 
 153 |           this.w[i] = global.randn(0.0, scale);
 154 |         }
 155 |       } else {
 156 |         for(var i=0;i<n;i++) { 
 157 |           this.w[i] = c;
 158 |         }
 159 |       }
 160 |     }
 161 |   }
 162 | 
 163 |   Vol.prototype = {
 164 |     get: function(x, y, d) { 
 165 |       var ix=((this.sx * y)+x)*this.depth+d;
 166 |       return this.w[ix];
 167 |     },
 168 |     set: function(x, y, d, v) { 
 169 |       var ix=((this.sx * y)+x)*this.depth+d;
 170 |       this.w[ix] = v; 
 171 |     },
 172 |     add: function(x, y, d, v) { 
 173 |       var ix=((this.sx * y)+x)*this.depth+d;
 174 |       this.w[ix] += v; 
 175 |     },
 176 |     get_grad: function(x, y, d) { 
 177 |       var ix = ((this.sx * y)+x)*this.depth+d;
 178 |       return this.dw[ix]; 
 179 |     },
 180 |     set_grad: function(x, y, d, v) { 
 181 |       var ix = ((this.sx * y)+x)*this.depth+d;
 182 |       this.dw[ix] = v; 
 183 |     },
 184 |     add_grad: function(x, y, d, v) { 
 185 |       var ix = ((this.sx * y)+x)*this.depth+d;
 186 |       this.dw[ix] += v; 
 187 |     },
 188 |     cloneAndZero: function() { return new Vol(this.sx, this.sy, this.depth, 0.0)},
 189 |     clone: function() {
 190 |       var V = new Vol(this.sx, this.sy, this.depth, 0.0);
 191 |       var n = this.w.length;
 192 |       for(var i=0;i<n;i++) { V.w[i] = this.w[i]; }
 193 |       return V;
 194 |     },
 195 |     addFrom: function(V) { for(var k=0;k<this.w.length;k++) { this.w[k] += V.w[k]; }},
 196 |     addFromScaled: function(V, a) { for(var k=0;k<this.w.length;k++) { this.w[k] += a*V.w[k]; }},
 197 |     setConst: function(a) { for(var k=0;k<this.w.length;k++) { this.w[k] = a; }},
 198 | 
 199 |     toJSON: function() {
 200 |       // todo: we may want to only save d most significant digits to save space
 201 |       var json = {}
 202 |       json.sx = this.sx; 
 203 |       json.sy = this.sy;
 204 |       json.depth = this.depth;
 205 |       json.w = this.w;
 206 |       return json;
 207 |       // we wont back up gradients to save space
 208 |     },
 209 |     fromJSON: function(json) {
 210 |       this.sx = json.sx;
 211 |       this.sy = json.sy;
 212 |       this.depth = json.depth;
 213 | 
 214 |       var n = this.sx*this.sy*this.depth;
 215 |       this.w = global.zeros(n);
 216 |       this.dw = global.zeros(n);
 217 |       // copy over the elements.
 218 |       for(var i=0;i<n;i++) {
 219 |         this.w[i] = json.w[i];
 220 |       }
 221 |     }
 222 |   }
 223 | 
 224 |   global.Vol = Vol;
 225 | })(convnetjs);
 226 | (function(global) {
 227 |   "use strict";
 228 |   var Vol = global.Vol; // convenience
 229 | 
 230 |   // Volume utilities
 231 |   // intended for use with data augmentation
 232 |   // crop is the size of output
 233 |   // dx,dy are offset wrt incoming volume, of the shift
 234 |   // fliplr is boolean on whether we also want to flip left<->right
 235 |   var augment = function(V, crop, dx, dy, fliplr) {
 236 |     // note assumes square outputs of size crop x crop
 237 |     if(typeof(fliplr)==='undefined') var fliplr = false;
 238 |     if(typeof(dx)==='undefined') var dx = global.randi(0, V.sx - crop);
 239 |     if(typeof(dy)==='undefined') var dy = global.randi(0, V.sy - crop);
 240 |     
 241 |     // randomly sample a crop in the input volume
 242 |     var W;
 243 |     if(crop !== V.sx || dx!==0 || dy!==0) {
 244 |       W = new Vol(crop, crop, V.depth, 0.0);
 245 |       for(var x=0;x<crop;x++) {
 246 |         for(var y=0;y<crop;y++) {
 247 |           if(x+dx<0 || x+dx>=V.sx || y+dy<0 || y+dy>=V.sy) continue; // oob
 248 |           for(var d=0;d<V.depth;d++) {
 249 |            W.set(x,y,d,V.get(x+dx,y+dy,d)); // copy data over
 250 |           }
 251 |         }
 252 |       }
 253 |     } else {
 254 |       W = V;
 255 |     }
 256 | 
 257 |     if(fliplr) {
 258 |       // flip volume horziontally
 259 |       var W2 = W.cloneAndZero();
 260 |       for(var x=0;x<W.sx;x++) {
 261 |         for(var y=0;y<W.sy;y++) {
 262 |           for(var d=0;d<W.depth;d++) {
 263 |            W2.set(x,y,d,W.get(W.sx - x - 1,y,d)); // copy data over
 264 |           }
 265 |         }
 266 |       }
 267 |       W = W2; //swap
 268 |     }
 269 |     return W;
 270 |   }
 271 | 
 272 |   // img is a DOM element that contains a loaded image
 273 |   // returns a Vol of size (W, H, 4). 4 is for RGBA
 274 |   var img_to_vol = function(img, convert_grayscale) {
 275 | 
 276 |     if(typeof(convert_grayscale)==='undefined') var convert_grayscale = false;
 277 | 
 278 |     var canvas = document.createElement('canvas');
 279 |     canvas.width = img.width;
 280 |     canvas.height = img.height;
 281 |     var ctx = canvas.getContext("2d");
 282 | 
 283 |     // due to a Firefox bug
 284 |     try {
 285 |       ctx.drawImage(img, 0, 0);
 286 |     } catch (e) {
 287 |       if (e.name === "NS_ERROR_NOT_AVAILABLE") {
 288 |         // sometimes happens, lets just abort
 289 |         return false;
 290 |       } else {
 291 |         throw e;
 292 |       }
 293 |     }
 294 | 
 295 |     try {
 296 |       var img_data = ctx.getImageData(0, 0, canvas.width, canvas.height);
 297 |     } catch (e) {
 298 |       if(e.name === 'IndexSizeError') {
 299 |         return false; // not sure what causes this sometimes but okay abort
 300 |       } else {
 301 |         throw e;
 302 |       }
 303 |     }
 304 | 
 305 |     // prepare the input: get pixels and normalize them
 306 |     var p = img_data.data;
 307 |     var W = img.width;
 308 |     var H = img.height;
 309 |     var pv = []
 310 |     for(var i=0;i<p.length;i++) {
 311 |       pv.push(p[i]/255.0-0.5); // normalize image pixels to [-0.5, 0.5]
 312 |     }
 313 |     var x = new Vol(W, H, 4, 0.0); //input volume (image)
 314 |     x.w = pv;
 315 | 
 316 |     if(convert_grayscale) {
 317 |       // flatten into depth=1 array
 318 |       var x1 = new Vol(W, H, 1, 0.0);
 319 |       for(var i=0;i<W;i++) {
 320 |         for(var j=0;j<H;j++) {
 321 |           x1.set(i,j,0,x.get(i,j,0));
 322 |         }
 323 |       }
 324 |       x = x1;
 325 |     }
 326 | 
 327 |     return x;
 328 |   }
 329 |   
 330 |   global.augment = augment;
 331 |   global.img_to_vol = img_to_vol;
 332 | 
 333 | })(convnetjs);
 334 | (function(global) {
 335 |   "use strict";
 336 |   var Vol = global.Vol; // convenience
 337 | 
 338 |   // This file contains all layers that do dot products with input,
 339 |   // but usually in a different connectivity pattern and weight sharing
 340 |   // schemes: 
 341 |   // - FullyConn is fully connected dot products 
 342 |   // - ConvLayer does convolutions (so weight sharing spatially)
 343 |   // putting them together in one file because they are very similar
 344 |   var ConvLayer = function(opt) {
 345 |     var opt = opt || {};
 346 | 
 347 |     // required
 348 |     this.out_depth = opt.filters;
 349 |     this.sx = opt.sx; // filter size. Should be odd if possible, it's cleaner.
 350 |     this.in_depth = opt.in_depth;
 351 |     this.in_sx = opt.in_sx;
 352 |     this.in_sy = opt.in_sy;
 353 |     
 354 |     // optional
 355 |     this.sy = typeof opt.sy !== 'undefined' ? opt.sy : this.sx;
 356 |     this.stride = typeof opt.stride !== 'undefined' ? opt.stride : 1; // stride at which we apply filters to input volume
 357 |     this.pad = typeof opt.pad !== 'undefined' ? opt.pad : 0; // amount of 0 padding to add around borders of input volume
 358 |     this.l1_decay_mul = typeof opt.l1_decay_mul !== 'undefined' ? opt.l1_decay_mul : 0.0;
 359 |     this.l2_decay_mul = typeof opt.l2_decay_mul !== 'undefined' ? opt.l2_decay_mul : 1.0;
 360 | 
 361 |     // computed
 362 |     // note we are doing floor, so if the strided convolution of the filter doesnt fit into the input
 363 |     // volume exactly, the output volume will be trimmed and not contain the (incomplete) computed
 364 |     // final application.
 365 |     this.out_sx = Math.floor((this.in_sx + this.pad * 2 - this.sx) / this.stride + 1);
 366 |     this.out_sy = Math.floor((this.in_sy + this.pad * 2 - this.sy) / this.stride + 1);
 367 |     this.layer_type = 'conv';
 368 | 
 369 |     // initializations
 370 |     var bias = typeof opt.bias_pref !== 'undefined' ? opt.bias_pref : 0.0;
 371 |     this.filters = [];
 372 |     for(var i=0;i<this.out_depth;i++) { this.filters.push(new Vol(this.sx, this.sy, this.in_depth)); }
 373 |     this.biases = new Vol(1, 1, this.out_depth, bias);
 374 |   }
 375 |   ConvLayer.prototype = {
 376 |     forward: function(V, is_training) {
 377 |       // optimized code by @mdda that achieves 2x speedup over previous version
 378 | 
 379 |       this.in_act = V;
 380 |       var A = new Vol(this.out_sx |0, this.out_sy |0, this.out_depth |0, 0.0);
 381 |       
 382 |       var V_sx = V.sx |0;
 383 |       var V_sy = V.sy |0;
 384 |       var xy_stride = this.stride |0;
 385 | 
 386 |       for(var d=0;d<this.out_depth;d++) {
 387 |         var f = this.filters[d];
 388 |         var x = -this.pad |0;
 389 |         var y = -this.pad |0;
 390 |         for(var ay=0; ay<this.out_sy; y+=xy_stride,ay++) {  // xy_stride
 391 |           x = -this.pad |0;
 392 |           for(var ax=0; ax<this.out_sx; x+=xy_stride,ax++) {  // xy_stride
 393 | 
 394 |             // convolve centered at this particular location
 395 |             var a = 0.0;
 396 |             for(var fy=0;fy<f.sy;fy++) {
 397 |               var oy = y+fy; // coordinates in the original input array coordinates
 398 |               for(var fx=0;fx<f.sx;fx++) {
 399 |                 var ox = x+fx;
 400 |                 if(oy>=0 && oy<V_sy && ox>=0 && ox<V_sx) {
 401 |                   for(var fd=0;fd<f.depth;fd++) {
 402 |                     // avoid function call overhead (x2) for efficiency, compromise modularity :(
 403 |                     a += f.w[((f.sx * fy)+fx)*f.depth+fd] * V.w[((V_sx * oy)+ox)*V.depth+fd];
 404 |                   }
 405 |                 }
 406 |               }
 407 |             }
 408 |             a += this.biases.w[d];
 409 |             A.set(ax, ay, d, a);
 410 |           }
 411 |         }
 412 |       }
 413 |       this.out_act = A;
 414 |       return this.out_act;
 415 |     },
 416 |     backward: function() {
 417 | 
 418 |       var V = this.in_act;
 419 |       V.dw = global.zeros(V.w.length); // zero out gradient wrt bottom data, we're about to fill it
 420 | 
 421 |       var V_sx = V.sx |0;
 422 |       var V_sy = V.sy |0;
 423 |       var xy_stride = this.stride |0;
 424 | 
 425 |       for(var d=0;d<this.out_depth;d++) {
 426 |         var f = this.filters[d];
 427 |         var x = -this.pad |0;
 428 |         var y = -this.pad |0;
 429 |         for(var ay=0; ay<this.out_sy; y+=xy_stride,ay++) {  // xy_stride
 430 |           x = -this.pad |0;
 431 |           for(var ax=0; ax<this.out_sx; x+=xy_stride,ax++) {  // xy_stride
 432 | 
 433 |             // convolve centered at this particular location
 434 |             var chain_grad = this.out_act.get_grad(ax,ay,d); // gradient from above, from chain rule
 435 |             for(var fy=0;fy<f.sy;fy++) {
 436 |               var oy = y+fy; // coordinates in the original input array coordinates
 437 |               for(var fx=0;fx<f.sx;fx++) {
 438 |                 var ox = x+fx;
 439 |                 if(oy>=0 && oy<V_sy && ox>=0 && ox<V_sx) {
 440 |                   for(var fd=0;fd<f.depth;fd++) {
 441 |                     // avoid function call overhead (x2) for efficiency, compromise modularity :(
 442 |                     var ix1 = ((V_sx * oy)+ox)*V.depth+fd;
 443 |                     var ix2 = ((f.sx * fy)+fx)*f.depth+fd;
 444 |                     f.dw[ix2] += V.w[ix1]*chain_grad;
 445 |                     V.dw[ix1] += f.w[ix2]*chain_grad;
 446 |                   }
 447 |                 }
 448 |               }
 449 |             }
 450 |             this.biases.dw[d] += chain_grad;
 451 |           }
 452 |         }
 453 |       }
 454 |     },
 455 |     getParamsAndGrads: function() {
 456 |       var response = [];
 457 |       for(var i=0;i<this.out_depth;i++) {
 458 |         response.push({params: this.filters[i].w, grads: this.filters[i].dw, l2_decay_mul: this.l2_decay_mul, l1_decay_mul: this.l1_decay_mul});
 459 |       }
 460 |       response.push({params: this.biases.w, grads: this.biases.dw, l1_decay_mul: 0.0, l2_decay_mul: 0.0});
 461 |       return response;
 462 |     },
 463 |     toJSON: function() {
 464 |       var json = {};
 465 |       json.sx = this.sx; // filter size in x, y dims
 466 |       json.sy = this.sy;
 467 |       json.stride = this.stride;
 468 |       json.in_depth = this.in_depth;
 469 |       json.out_depth = this.out_depth;
 470 |       json.out_sx = this.out_sx;
 471 |       json.out_sy = this.out_sy;
 472 |       json.layer_type = this.layer_type;
 473 |       json.l1_decay_mul = this.l1_decay_mul;
 474 |       json.l2_decay_mul = this.l2_decay_mul;
 475 |       json.pad = this.pad;
 476 |       json.filters = [];
 477 |       for(var i=0;i<this.filters.length;i++) {
 478 |         json.filters.push(this.filters[i].toJSON());
 479 |       }
 480 |       json.biases = this.biases.toJSON();
 481 |       return json;
 482 |     },
 483 |     fromJSON: function(json) {
 484 |       this.out_depth = json.out_depth;
 485 |       this.out_sx = json.out_sx;
 486 |       this.out_sy = json.out_sy;
 487 |       this.layer_type = json.layer_type;
 488 |       this.sx = json.sx; // filter size in x, y dims
 489 |       this.sy = json.sy;
 490 |       this.stride = json.stride;
 491 |       this.in_depth = json.in_depth; // depth of input volume
 492 |       this.filters = [];
 493 |       this.l1_decay_mul = typeof json.l1_decay_mul !== 'undefined' ? json.l1_decay_mul : 1.0;
 494 |       this.l2_decay_mul = typeof json.l2_decay_mul !== 'undefined' ? json.l2_decay_mul : 1.0;
 495 |       this.pad = typeof json.pad !== 'undefined' ? json.pad : 0;
 496 |       for(var i=0;i<json.filters.length;i++) {
 497 |         var v = new Vol(0,0,0,0);
 498 |         v.fromJSON(json.filters[i]);
 499 |         this.filters.push(v);
 500 |       }
 501 |       this.biases = new Vol(0,0,0,0);
 502 |       this.biases.fromJSON(json.biases);
 503 |     }
 504 |   }
 505 | 
 506 |   var FullyConnLayer = function(opt) {
 507 |     var opt = opt || {};
 508 | 
 509 |     // required
 510 |     // ok fine we will allow 'filters' as the word as well
 511 |     this.out_depth = typeof opt.num_neurons !== 'undefined' ? opt.num_neurons : opt.filters;
 512 | 
 513 |     // optional 
 514 |     this.l1_decay_mul = typeof opt.l1_decay_mul !== 'undefined' ? opt.l1_decay_mul : 0.0;
 515 |     this.l2_decay_mul = typeof opt.l2_decay_mul !== 'undefined' ? opt.l2_decay_mul : 1.0;
 516 | 
 517 |     // computed
 518 |     this.num_inputs = opt.in_sx * opt.in_sy * opt.in_depth;
 519 |     this.out_sx = 1;
 520 |     this.out_sy = 1;
 521 |     this.layer_type = 'fc';
 522 | 
 523 |     // initializations
 524 |     var bias = typeof opt.bias_pref !== 'undefined' ? opt.bias_pref : 0.0;
 525 |     this.filters = [];
 526 |     for(var i=0;i<this.out_depth ;i++) { this.filters.push(new Vol(1, 1, this.num_inputs)); }
 527 |     this.biases = new Vol(1, 1, this.out_depth, bias);
 528 |   }
 529 | 
 530 |   FullyConnLayer.prototype = {
 531 |     forward: function(V, is_training) {
 532 |       this.in_act = V;
 533 |       var A = new Vol(1, 1, this.out_depth, 0.0);
 534 |       var Vw = V.w;
 535 |       for(var i=0;i<this.out_depth;i++) {
 536 |         var a = 0.0;
 537 |         var wi = this.filters[i].w;
 538 |         for(var d=0;d<this.num_inputs;d++) {
 539 |           a += Vw[d] * wi[d]; // for efficiency use Vols directly for now
 540 |         }
 541 |         a += this.biases.w[i];
 542 |         A.w[i] = a;
 543 |       }
 544 |       this.out_act = A;
 545 |       return this.out_act;
 546 |     },
 547 |     backward: function() {
 548 |       var V = this.in_act;
 549 |       V.dw = global.zeros(V.w.length); // zero out the gradient in input Vol
 550 |       
 551 |       // compute gradient wrt weights and data
 552 |       for(var i=0;i<this.out_depth;i++) {
 553 |         var tfi = this.filters[i];
 554 |         var chain_grad = this.out_act.dw[i];
 555 |         for(var d=0;d<this.num_inputs;d++) {
 556 |           V.dw[d] += tfi.w[d]*chain_grad; // grad wrt input data
 557 |           tfi.dw[d] += V.w[d]*chain_grad; // grad wrt params
 558 |         }
 559 |         this.biases.dw[i] += chain_grad;
 560 |       }
 561 |     },
 562 |     getParamsAndGrads: function() {
 563 |       var response = [];
 564 |       for(var i=0;i<this.out_depth;i++) {
 565 |         response.push({params: this.filters[i].w, grads: this.filters[i].dw, l1_decay_mul: this.l1_decay_mul, l2_decay_mul: this.l2_decay_mul});
 566 |       }
 567 |       response.push({params: this.biases.w, grads: this.biases.dw, l1_decay_mul: 0.0, l2_decay_mul: 0.0});
 568 |       return response;
 569 |     },
 570 |     toJSON: function() {
 571 |       var json = {};
 572 |       json.out_depth = this.out_depth;
 573 |       json.out_sx = this.out_sx;
 574 |       json.out_sy = this.out_sy;
 575 |       json.layer_type = this.layer_type;
 576 |       json.num_inputs = this.num_inputs;
 577 |       json.l1_decay_mul = this.l1_decay_mul;
 578 |       json.l2_decay_mul = this.l2_decay_mul;
 579 |       json.filters = [];
 580 |       for(var i=0;i<this.filters.length;i++) {
 581 |         json.filters.push(this.filters[i].toJSON());
 582 |       }
 583 |       json.biases = this.biases.toJSON();
 584 |       return json;
 585 |     },
 586 |     fromJSON: function(json) {
 587 |       this.out_depth = json.out_depth;
 588 |       this.out_sx = json.out_sx;
 589 |       this.out_sy = json.out_sy;
 590 |       this.layer_type = json.layer_type;
 591 |       this.num_inputs = json.num_inputs;
 592 |       this.l1_decay_mul = typeof json.l1_decay_mul !== 'undefined' ? json.l1_decay_mul : 1.0;
 593 |       this.l2_decay_mul = typeof json.l2_decay_mul !== 'undefined' ? json.l2_decay_mul : 1.0;
 594 |       this.filters = [];
 595 |       for(var i=0;i<json.filters.length;i++) {
 596 |         var v = new Vol(0,0,0,0);
 597 |         v.fromJSON(json.filters[i]);
 598 |         this.filters.push(v);
 599 |       }
 600 |       this.biases = new Vol(0,0,0,0);
 601 |       this.biases.fromJSON(json.biases);
 602 |     }
 603 |   }
 604 | 
 605 |   global.ConvLayer = ConvLayer;
 606 |   global.FullyConnLayer = FullyConnLayer;
 607 |   
 608 | })(convnetjs);
 609 | (function(global) {
 610 |   "use strict";
 611 |   var Vol = global.Vol; // convenience
 612 |   
 613 |   var PoolLayer = function(opt) {
 614 | 
 615 |     var opt = opt || {};
 616 | 
 617 |     // required
 618 |     this.sx = opt.sx; // filter size
 619 |     this.in_depth = opt.in_depth;
 620 |     this.in_sx = opt.in_sx;
 621 |     this.in_sy = opt.in_sy;
 622 | 
 623 |     // optional
 624 |     this.sy = typeof opt.sy !== 'undefined' ? opt.sy : this.sx;
 625 |     this.stride = typeof opt.stride !== 'undefined' ? opt.stride : 2;
 626 |     this.pad = typeof opt.pad !== 'undefined' ? opt.pad : 0; // amount of 0 padding to add around borders of input volume
 627 | 
 628 |     // computed
 629 |     this.out_depth = this.in_depth;
 630 |     this.out_sx = Math.floor((this.in_sx + this.pad * 2 - this.sx) / this.stride + 1);
 631 |     this.out_sy = Math.floor((this.in_sy + this.pad * 2 - this.sy) / this.stride + 1);
 632 |     this.layer_type = 'pool';
 633 |     // store switches for x,y coordinates for where the max comes from, for each output neuron
 634 |     this.switchx = global.zeros(this.out_sx*this.out_sy*this.out_depth);
 635 |     this.switchy = global.zeros(this.out_sx*this.out_sy*this.out_depth);
 636 |   }
 637 | 
 638 |   PoolLayer.prototype = {
 639 |     forward: function(V, is_training) {
 640 |       this.in_act = V;
 641 | 
 642 |       var A = new Vol(this.out_sx, this.out_sy, this.out_depth, 0.0);
 643 |       
 644 |       var n=0; // a counter for switches
 645 |       for(var d=0;d<this.out_depth;d++) {
 646 |         var x = -this.pad;
 647 |         var y = -this.pad;
 648 |         for(var ax=0; ax<this.out_sx; x+=this.stride,ax++) {
 649 |           y = -this.pad;
 650 |           for(var ay=0; ay<this.out_sy; y+=this.stride,ay++) {
 651 | 
 652 |             // convolve centered at this particular location
 653 |             var a = -99999; // hopefully small enough ;\
 654 |             var winx=-1,winy=-1;
 655 |             for(var fx=0;fx<this.sx;fx++) {
 656 |               for(var fy=0;fy<this.sy;fy++) {
 657 |                 var oy = y+fy;
 658 |                 var ox = x+fx;
 659 |                 if(oy>=0 && oy<V.sy && ox>=0 && ox<V.sx) {
 660 |                   var v = V.get(ox, oy, d);
 661 |                   // perform max pooling and store pointers to where
 662 |                   // the max came from. This will speed up backprop 
 663 |                   // and can help make nice visualizations in future
 664 |                   if(v > a) { a = v; winx=ox; winy=oy;}
 665 |                 }
 666 |               }
 667 |             }
 668 |             this.switchx[n] = winx;
 669 |             this.switchy[n] = winy;
 670 |             n++;
 671 |             A.set(ax, ay, d, a);
 672 |           }
 673 |         }
 674 |       }
 675 |       this.out_act = A;
 676 |       return this.out_act;
 677 |     },
 678 |     backward: function() { 
 679 |       // pooling layers have no parameters, so simply compute 
 680 |       // gradient wrt data here
 681 |       var V = this.in_act;
 682 |       V.dw = global.zeros(V.w.length); // zero out gradient wrt data
 683 |       var A = this.out_act; // computed in forward pass 
 684 | 
 685 |       var n = 0;
 686 |       for(var d=0;d<this.out_depth;d++) {
 687 |         var x = -this.pad;
 688 |         var y = -this.pad;
 689 |         for(var ax=0; ax<this.out_sx; x+=this.stride,ax++) {
 690 |           y = -this.pad;
 691 |           for(var ay=0; ay<this.out_sy; y+=this.stride,ay++) {
 692 | 
 693 |             var chain_grad = this.out_act.get_grad(ax,ay,d);
 694 |             V.add_grad(this.switchx[n], this.switchy[n], d, chain_grad);
 695 |             n++;
 696 | 
 697 |           }
 698 |         }
 699 |       }
 700 |     },
 701 |     getParamsAndGrads: function() {
 702 |       return [];
 703 |     },
 704 |     toJSON: function() {
 705 |       var json = {};
 706 |       json.sx = this.sx;
 707 |       json.sy = this.sy;
 708 |       json.stride = this.stride;
 709 |       json.in_depth = this.in_depth;
 710 |       json.out_depth = this.out_depth;
 711 |       json.out_sx = this.out_sx;
 712 |       json.out_sy = this.out_sy;
 713 |       json.layer_type = this.layer_type;
 714 |       json.pad = this.pad;
 715 |       return json;
 716 |     },
 717 |     fromJSON: function(json) {
 718 |       this.out_depth = json.out_depth;
 719 |       this.out_sx = json.out_sx;
 720 |       this.out_sy = json.out_sy;
 721 |       this.layer_type = json.layer_type;
 722 |       this.sx = json.sx;
 723 |       this.sy = json.sy;
 724 |       this.stride = json.stride;
 725 |       this.in_depth = json.in_depth;
 726 |       this.pad = typeof json.pad !== 'undefined' ? json.pad : 0; // backwards compatibility
 727 |       this.switchx = global.zeros(this.out_sx*this.out_sy*this.out_depth); // need to re-init these appropriately
 728 |       this.switchy = global.zeros(this.out_sx*this.out_sy*this.out_depth);
 729 |     }
 730 |   }
 731 | 
 732 |   global.PoolLayer = PoolLayer;
 733 | 
 734 | })(convnetjs);
 735 | 
 736 | (function(global) {
 737 |   "use strict";
 738 |   var Vol = global.Vol; // convenience
 739 |   
 740 |   var InputLayer = function(opt) {
 741 |     var opt = opt || {};
 742 | 
 743 |     // this is a bit silly but lets allow people to specify either ins or outs
 744 |     this.out_sx = typeof opt.out_sx !== 'undefined' ? opt.out_sx : opt.in_sx;
 745 |     this.out_sy = typeof opt.out_sy !== 'undefined' ? opt.out_sy : opt.in_sy;
 746 |     this.out_depth = typeof opt.out_depth !== 'undefined' ? opt.out_depth : opt.in_depth;
 747 |     this.layer_type = 'input';
 748 |   }
 749 |   InputLayer.prototype = {
 750 |     forward: function(V, is_training) {
 751 |       this.in_act = V;
 752 |       this.out_act = V;
 753 |       return this.out_act; // dummy identity function for now
 754 |     },
 755 |     backward: function() { },
 756 |     getParamsAndGrads: function() {
 757 |       return [];
 758 |     },
 759 |     toJSON: function() {
 760 |       var json = {};
 761 |       json.out_depth = this.out_depth;
 762 |       json.out_sx = this.out_sx;
 763 |       json.out_sy = this.out_sy;
 764 |       json.layer_type = this.layer_type;
 765 |       return json;
 766 |     },
 767 |     fromJSON: function(json) {
 768 |       this.out_depth = json.out_depth;
 769 |       this.out_sx = json.out_sx;
 770 |       this.out_sy = json.out_sy;
 771 |       this.layer_type = json.layer_type; 
 772 |     }
 773 |   }
 774 | 
 775 |   global.InputLayer = InputLayer;
 776 | })(convnetjs);
 777 | (function(global) {
 778 |   "use strict";
 779 |   var Vol = global.Vol; // convenience
 780 |   
 781 |   // Layers that implement a loss. Currently these are the layers that 
 782 |   // can initiate a backward() pass. In future we probably want a more 
 783 |   // flexible system that can accomodate multiple losses to do multi-task
 784 |   // learning, and stuff like that. But for now, one of the layers in this
 785 |   // file must be the final layer in a Net.
 786 | 
 787 |   // This is a classifier, with N discrete classes from 0 to N-1
 788 |   // it gets a stream of N incoming numbers and computes the softmax
 789 |   // function (exponentiate and normalize to sum to 1 as probabilities should)
 790 |   var SoftmaxLayer = function(opt) {
 791 |     var opt = opt || {};
 792 | 
 793 |     // computed
 794 |     this.num_inputs = opt.in_sx * opt.in_sy * opt.in_depth;
 795 |     this.out_depth = this.num_inputs;
 796 |     this.out_sx = 1;
 797 |     this.out_sy = 1;
 798 |     this.layer_type = 'softmax';
 799 |   }
 800 | 
 801 |   SoftmaxLayer.prototype = {
 802 |     forward: function(V, is_training) {
 803 |       this.in_act = V;
 804 | 
 805 |       var A = new Vol(1, 1, this.out_depth, 0.0);
 806 | 
 807 |       // compute max activation
 808 |       var as = V.w;
 809 |       var amax = V.w[0];
 810 |       for(var i=1;i<this.out_depth;i++) {
 811 |         if(as[i] > amax) amax = as[i];
 812 |       }
 813 | 
 814 |       // compute exponentials (carefully to not blow up)
 815 |       var es = global.zeros(this.out_depth);
 816 |       var esum = 0.0;
 817 |       for(var i=0;i<this.out_depth;i++) {
 818 |         var e = Math.exp(as[i] - amax);
 819 |         esum += e;
 820 |         es[i] = e;
 821 |       }
 822 | 
 823 |       // normalize and output to sum to one
 824 |       for(var i=0;i<this.out_depth;i++) {
 825 |         es[i] /= esum;
 826 |         A.w[i] = es[i];
 827 |       }
 828 | 
 829 |       this.es = es; // save these for backprop
 830 |       this.out_act = A;
 831 |       return this.out_act;
 832 |     },
 833 |     backward: function(y) {
 834 | 
 835 |       // compute and accumulate gradient wrt weights and bias of this layer
 836 |       var x = this.in_act;
 837 |       x.dw = global.zeros(x.w.length); // zero out the gradient of input Vol
 838 | 
 839 |       for(var i=0;i<this.out_depth;i++) {
 840 |         var indicator = i === y ? 1.0 : 0.0;
 841 |         var mul = -(indicator - this.es[i]);
 842 |         x.dw[i] = mul;
 843 |       }
 844 | 
 845 |       // loss is the class negative log likelihood
 846 |       return -Math.log(this.es[y]);
 847 |     },
 848 |     getParamsAndGrads: function() { 
 849 |       return [];
 850 |     },
 851 |     toJSON: function() {
 852 |       var json = {};
 853 |       json.out_depth = this.out_depth;
 854 |       json.out_sx = this.out_sx;
 855 |       json.out_sy = this.out_sy;
 856 |       json.layer_type = this.layer_type;
 857 |       json.num_inputs = this.num_inputs;
 858 |       return json;
 859 |     },
 860 |     fromJSON: function(json) {
 861 |       this.out_depth = json.out_depth;
 862 |       this.out_sx = json.out_sx;
 863 |       this.out_sy = json.out_sy;
 864 |       this.layer_type = json.layer_type;
 865 |       this.num_inputs = json.num_inputs;
 866 |     }
 867 |   }
 868 | 
 869 |   // implements an L2 regression cost layer,
 870 |   // so penalizes \sum_i(||x_i - y_i||^2), where x is its input
 871 |   // and y is the user-provided array of "correct" values.
 872 |   var RegressionLayer = function(opt) {
 873 |     var opt = opt || {};
 874 | 
 875 |     // computed
 876 |     this.num_inputs = opt.in_sx * opt.in_sy * opt.in_depth;
 877 |     this.out_depth = this.num_inputs;
 878 |     this.out_sx = 1;
 879 |     this.out_sy = 1;
 880 |     this.layer_type = 'regression';
 881 |   }
 882 | 
 883 |   RegressionLayer.prototype = {
 884 |     forward: function(V, is_training) {
 885 |       this.in_act = V;
 886 |       this.out_act = V;
 887 |       return V; // identity function
 888 |     },
 889 |     // y is a list here of size num_inputs
 890 |     backward: function(y) { 
 891 | 
 892 |       // compute and accumulate gradient wrt weights and bias of this layer
 893 |       var x = this.in_act;
 894 |       x.dw = global.zeros(x.w.length); // zero out the gradient of input Vol
 895 |       var loss = 0.0;
 896 |       if(y instanceof Array || y instanceof Float64Array) {
 897 |         for(var i=0;i<this.out_depth;i++) {
 898 |           var dy = x.w[i] - y[i];
 899 |           x.dw[i] = dy;
 900 |           loss += 2*dy*dy;
 901 |         }
 902 |       } else {
 903 |         // assume it is a struct with entries .dim and .val
 904 |         // and we pass gradient only along dimension dim to be equal to val
 905 |         var i = y.dim;
 906 |         var yi = y.val;
 907 |         var dy = x.w[i] - yi;
 908 |         x.dw[i] = dy;
 909 |         loss += 2*dy*dy;
 910 |       }
 911 |       return loss;
 912 |     },
 913 |     getParamsAndGrads: function() { 
 914 |       return [];
 915 |     },
 916 |     toJSON: function() {
 917 |       var json = {};
 918 |       json.out_depth = this.out_depth;
 919 |       json.out_sx = this.out_sx;
 920 |       json.out_sy = this.out_sy;
 921 |       json.layer_type = this.layer_type;
 922 |       json.num_inputs = this.num_inputs;
 923 |       return json;
 924 |     },
 925 |     fromJSON: function(json) {
 926 |       this.out_depth = json.out_depth;
 927 |       this.out_sx = json.out_sx;
 928 |       this.out_sy = json.out_sy;
 929 |       this.layer_type = json.layer_type;
 930 |       this.num_inputs = json.num_inputs;
 931 |     }
 932 |   }
 933 | 
 934 |   var SVMLayer = function(opt) {
 935 |     var opt = opt || {};
 936 | 
 937 |     // computed
 938 |     this.num_inputs = opt.in_sx * opt.in_sy * opt.in_depth;
 939 |     this.out_depth = this.num_inputs;
 940 |     this.out_sx = 1;
 941 |     this.out_sy = 1;
 942 |     this.layer_type = 'svm';
 943 |   }
 944 | 
 945 |   SVMLayer.prototype = {
 946 |     forward: function(V, is_training) {
 947 |       this.in_act = V;
 948 |       this.out_act = V; // nothing to do, output raw scores
 949 |       return V;
 950 |     },
 951 |     backward: function(y) {
 952 | 
 953 |       // compute and accumulate gradient wrt weights and bias of this layer
 954 |       var x = this.in_act;
 955 |       x.dw = global.zeros(x.w.length); // zero out the gradient of input Vol
 956 | 
 957 |       var yscore = x.w[y]; // score of ground truth
 958 |       var margin = 1.0;
 959 |       var loss = 0.0;
 960 |       for(var i=0;i<this.out_depth;i++) {
 961 |         if(-yscore + x.w[i] + margin > 0) {
 962 |           // violating example, apply loss
 963 |           // I love hinge loss, by the way. Truly.
 964 |           // Seriously, compare this SVM code with Softmax forward AND backprop code above
 965 |           // it's clear which one is superior, not only in code, simplicity
 966 |           // and beauty, but also in practice.
 967 |           x.dw[i] += 1;
 968 |           x.dw[y] -= 1;
 969 |           loss += -yscore + x.w[i] + margin;
 970 |         }
 971 |       }
 972 | 
 973 |       return loss;
 974 |     },
 975 |     getParamsAndGrads: function() { 
 976 |       return [];
 977 |     },
 978 |     toJSON: function() {
 979 |       var json = {};
 980 |       json.out_depth = this.out_depth;
 981 |       json.out_sx = this.out_sx;
 982 |       json.out_sy = this.out_sy;
 983 |       json.layer_type = this.layer_type;
 984 |       json.num_inputs = this.num_inputs;
 985 |       return json;
 986 |     },
 987 |     fromJSON: function(json) {
 988 |       this.out_depth = json.out_depth;
 989 |       this.out_sx = json.out_sx;
 990 |       this.out_sy = json.out_sy;
 991 |       this.layer_type = json.layer_type;
 992 |       this.num_inputs = json.num_inputs;
 993 |     }
 994 |   }
 995 |   
 996 |   global.RegressionLayer = RegressionLayer;
 997 |   global.SoftmaxLayer = SoftmaxLayer;
 998 |   global.SVMLayer = SVMLayer;
 999 | 
1000 | })(convnetjs);
1001 | 
1002 | (function(global) {
1003 |   "use strict";
1004 |   var Vol = global.Vol; // convenience
1005 |   
1006 |   // Implements ReLU nonlinearity elementwise
1007 |   // x -> max(0, x)
1008 |   // the output is in [0, inf)
1009 |   var ReluLayer = function(opt) {
1010 |     var opt = opt || {};
1011 | 
1012 |     // computed
1013 |     this.out_sx = opt.in_sx;
1014 |     this.out_sy = opt.in_sy;
1015 |     this.out_depth = opt.in_depth;
1016 |     this.layer_type = 'relu';
1017 |   }
1018 |   ReluLayer.prototype = {
1019 |     forward: function(V, is_training) {
1020 |       this.in_act = V;
1021 |       var V2 = V.clone();
1022 |       var N = V.w.length;
1023 |       var V2w = V2.w;
1024 |       for(var i=0;i<N;i++) { 
1025 |         if(V2w[i] < 0) V2w[i] = 0; // threshold at 0
1026 |       }
1027 |       this.out_act = V2;
1028 |       return this.out_act;
1029 |     },
1030 |     backward: function() {
1031 |       var V = this.in_act; // we need to set dw of this
1032 |       var V2 = this.out_act;
1033 |       var N = V.w.length;
1034 |       V.dw = global.zeros(N); // zero out gradient wrt data
1035 |       for(var i=0;i<N;i++) {
1036 |         if(V2.w[i] <= 0) V.dw[i] = 0; // threshold
1037 |         else V.dw[i] = V2.dw[i];
1038 |       }
1039 |     },
1040 |     getParamsAndGrads: function() {
1041 |       return [];
1042 |     },
1043 |     toJSON: function() {
1044 |       var json = {};
1045 |       json.out_depth = this.out_depth;
1046 |       json.out_sx = this.out_sx;
1047 |       json.out_sy = this.out_sy;
1048 |       json.layer_type = this.layer_type;
1049 |       return json;
1050 |     },
1051 |     fromJSON: function(json) {
1052 |       this.out_depth = json.out_depth;
1053 |       this.out_sx = json.out_sx;
1054 |       this.out_sy = json.out_sy;
1055 |       this.layer_type = json.layer_type; 
1056 |     }
1057 |   }
1058 | 
1059 |   // Implements Sigmoid nnonlinearity elementwise
1060 |   // x -> 1/(1+e^(-x))
1061 |   // so the output is between 0 and 1.
1062 |   var SigmoidLayer = function(opt) {
1063 |     var opt = opt || {};
1064 | 
1065 |     // computed
1066 |     this.out_sx = opt.in_sx;
1067 |     this.out_sy = opt.in_sy;
1068 |     this.out_depth = opt.in_depth;
1069 |     this.layer_type = 'sigmoid';
1070 |   }
1071 |   SigmoidLayer.prototype = {
1072 |     forward: function(V, is_training) {
1073 |       this.in_act = V;
1074 |       var V2 = V.cloneAndZero();
1075 |       var N = V.w.length;
1076 |       var V2w = V2.w;
1077 |       var Vw = V.w;
1078 |       for(var i=0;i<N;i++) { 
1079 |         V2w[i] = 1.0/(1.0+Math.exp(-Vw[i]));
1080 |       }
1081 |       this.out_act = V2;
1082 |       return this.out_act;
1083 |     },
1084 |     backward: function() {
1085 |       var V = this.in_act; // we need to set dw of this
1086 |       var V2 = this.out_act;
1087 |       var N = V.w.length;
1088 |       V.dw = global.zeros(N); // zero out gradient wrt data
1089 |       for(var i=0;i<N;i++) {
1090 |         var v2wi = V2.w[i];
1091 |         V.dw[i] =  v2wi * (1.0 - v2wi) * V2.dw[i];
1092 |       }
1093 |     },
1094 |     getParamsAndGrads: function() {
1095 |       return [];
1096 |     },
1097 |     toJSON: function() {
1098 |       var json = {};
1099 |       json.out_depth = this.out_depth;
1100 |       json.out_sx = this.out_sx;
1101 |       json.out_sy = this.out_sy;
1102 |       json.layer_type = this.layer_type;
1103 |       return json;
1104 |     },
1105 |     fromJSON: function(json) {
1106 |       this.out_depth = json.out_depth;
1107 |       this.out_sx = json.out_sx;
1108 |       this.out_sy = json.out_sy;
1109 |       this.layer_type = json.layer_type; 
1110 |     }
1111 |   }
1112 | 
1113 |   // Implements Maxout nnonlinearity that computes
1114 |   // x -> max(x)
1115 |   // where x is a vector of size group_size. Ideally of course,
1116 |   // the input size should be exactly divisible by group_size
1117 |   var MaxoutLayer = function(opt) {
1118 |     var opt = opt || {};
1119 | 
1120 |     // required
1121 |     this.group_size = typeof opt.group_size !== 'undefined' ? opt.group_size : 2;
1122 | 
1123 |     // computed
1124 |     this.out_sx = opt.in_sx;
1125 |     this.out_sy = opt.in_sy;
1126 |     this.out_depth = Math.floor(opt.in_depth / this.group_size);
1127 |     this.layer_type = 'maxout';
1128 | 
1129 |     this.switches = global.zeros(this.out_sx*this.out_sy*this.out_depth); // useful for backprop
1130 |   }
1131 |   MaxoutLayer.prototype = {
1132 |     forward: function(V, is_training) {
1133 |       this.in_act = V;
1134 |       var N = this.out_depth; 
1135 |       var V2 = new Vol(this.out_sx, this.out_sy, this.out_depth, 0.0);
1136 | 
1137 |       // optimization branch. If we're operating on 1D arrays we dont have
1138 |       // to worry about keeping track of x,y,d coordinates inside
1139 |       // input volumes. In convnets we do :(
1140 |       if(this.out_sx === 1 && this.out_sy === 1) {
1141 |         for(var i=0;i<N;i++) {
1142 |           var ix = i * this.group_size; // base index offset
1143 |           var a = V.w[ix];
1144 |           var ai = 0;
1145 |           for(var j=1;j<this.group_size;j++) {
1146 |             var a2 = V.w[ix+j];
1147 |             if(a2 > a) {
1148 |               a = a2;
1149 |               ai = j;
1150 |             }
1151 |           }
1152 |           V2.w[i] = a;
1153 |           this.switches[i] = ix + ai;
1154 |         }
1155 |       } else {
1156 |         var n=0; // counter for switches
1157 |         for(var x=0;x<V.sx;x++) {
1158 |           for(var y=0;y<V.sy;y++) {
1159 |             for(var i=0;i<N;i++) {
1160 |               var ix = i * this.group_size;
1161 |               var a = V.get(x, y, ix);
1162 |               var ai = 0;
1163 |               for(var j=1;j<this.group_size;j++) {
1164 |                 var a2 = V.get(x, y, ix+j);
1165 |                 if(a2 > a) {
1166 |                   a = a2;
1167 |                   ai = j;
1168 |                 }
1169 |               }
1170 |               V2.set(x,y,i,a);
1171 |               this.switches[n] = ix + ai;
1172 |               n++;
1173 |             }
1174 |           }
1175 |         }
1176 | 
1177 |       }
1178 |       this.out_act = V2;
1179 |       return this.out_act;
1180 |     },
1181 |     backward: function() {
1182 |       var V = this.in_act; // we need to set dw of this
1183 |       var V2 = this.out_act;
1184 |       var N = this.out_depth;
1185 |       V.dw = global.zeros(V.w.length); // zero out gradient wrt data
1186 | 
1187 |       // pass the gradient through the appropriate switch
1188 |       if(this.out_sx === 1 && this.out_sy === 1) {
1189 |         for(var i=0;i<N;i++) {
1190 |           var chain_grad = V2.dw[i];
1191 |           V.dw[this.switches[i]] = chain_grad;
1192 |         }
1193 |       } else {
1194 |         // bleh okay, lets do this the hard way
1195 |         var n=0; // counter for switches
1196 |         for(var x=0;x<V2.sx;x++) {
1197 |           for(var y=0;y<V2.sy;y++) {
1198 |             for(var i=0;i<N;i++) {
1199 |               var chain_grad = V2.get_grad(x,y,i);
1200 |               V.set_grad(x,y,this.switches[n],chain_grad);
1201 |               n++;
1202 |             }
1203 |           }
1204 |         }
1205 |       }
1206 |     },
1207 |     getParamsAndGrads: function() {
1208 |       return [];
1209 |     },
1210 |     toJSON: function() {
1211 |       var json = {};
1212 |       json.out_depth = this.out_depth;
1213 |       json.out_sx = this.out_sx;
1214 |       json.out_sy = this.out_sy;
1215 |       json.layer_type = this.layer_type;
1216 |       json.group_size = this.group_size;
1217 |       return json;
1218 |     },
1219 |     fromJSON: function(json) {
1220 |       this.out_depth = json.out_depth;
1221 |       this.out_sx = json.out_sx;
1222 |       this.out_sy = json.out_sy;
1223 |       this.layer_type = json.layer_type; 
1224 |       this.group_size = json.group_size;
1225 |       this.switches = global.zeros(this.group_size);
1226 |     }
1227 |   }
1228 | 
1229 |   // a helper function, since tanh is not yet part of ECMAScript. Will be in v6.
1230 |   function tanh(x) {
1231 |     var y = Math.exp(2 * x);
1232 |     return (y - 1) / (y + 1);
1233 |   }
1234 |   // Implements Tanh nnonlinearity elementwise
1235 |   // x -> tanh(x) 
1236 |   // so the output is between -1 and 1.
1237 |   var TanhLayer = function(opt) {
1238 |     var opt = opt || {};
1239 | 
1240 |     // computed
1241 |     this.out_sx = opt.in_sx;
1242 |     this.out_sy = opt.in_sy;
1243 |     this.out_depth = opt.in_depth;
1244 |     this.layer_type = 'tanh';
1245 |   }
1246 |   TanhLayer.prototype = {
1247 |     forward: function(V, is_training) {
1248 |       this.in_act = V;
1249 |       var V2 = V.cloneAndZero();
1250 |       var N = V.w.length;
1251 |       for(var i=0;i<N;i++) { 
1252 |         V2.w[i] = tanh(V.w[i]);
1253 |       }
1254 |       this.out_act = V2;
1255 |       return this.out_act;
1256 |     },
1257 |     backward: function() {
1258 |       var V = this.in_act; // we need to set dw of this
1259 |       var V2 = this.out_act;
1260 |       var N = V.w.length;
1261 |       V.dw = global.zeros(N); // zero out gradient wrt data
1262 |       for(var i=0;i<N;i++) {
1263 |         var v2wi = V2.w[i];
1264 |         V.dw[i] = (1.0 - v2wi * v2wi) * V2.dw[i];
1265 |       }
1266 |     },
1267 |     getParamsAndGrads: function() {
1268 |       return [];
1269 |     },
1270 |     toJSON: function() {
1271 |       var json = {};
1272 |       json.out_depth = this.out_depth;
1273 |       json.out_sx = this.out_sx;
1274 |       json.out_sy = this.out_sy;
1275 |       json.layer_type = this.layer_type;
1276 |       return json;
1277 |     },
1278 |     fromJSON: function(json) {
1279 |       this.out_depth = json.out_depth;
1280 |       this.out_sx = json.out_sx;
1281 |       this.out_sy = json.out_sy;
1282 |       this.layer_type = json.layer_type; 
1283 |     }
1284 |   }
1285 |   
1286 |   global.TanhLayer = TanhLayer;
1287 |   global.MaxoutLayer = MaxoutLayer;
1288 |   global.ReluLayer = ReluLayer;
1289 |   global.SigmoidLayer = SigmoidLayer;
1290 | 
1291 | })(convnetjs);
1292 | 
1293 | (function(global) {
1294 |   "use strict";
1295 |   var Vol = global.Vol; // convenience
1296 | 
1297 |   // An inefficient dropout layer
1298 |   // Note this is not most efficient implementation since the layer before
1299 |   // computed all these activations and now we're just going to drop them :(
1300 |   // same goes for backward pass. Also, if we wanted to be efficient at test time
1301 |   // we could equivalently be clever and upscale during train and copy pointers during test
1302 |   // todo: make more efficient.
1303 |   var DropoutLayer = function(opt) {
1304 |     var opt = opt || {};
1305 | 
1306 |     // computed
1307 |     this.out_sx = opt.in_sx;
1308 |     this.out_sy = opt.in_sy;
1309 |     this.out_depth = opt.in_depth;
1310 |     this.layer_type = 'dropout';
1311 |     this.drop_prob = typeof opt.drop_prob !== 'undefined' ? opt.drop_prob : 0.5;
1312 |     this.dropped = global.zeros(this.out_sx*this.out_sy*this.out_depth);
1313 |   }
1314 |   DropoutLayer.prototype = {
1315 |     forward: function(V, is_training) {
1316 |       this.in_act = V;
1317 |       if(typeof(is_training)==='undefined') { is_training = false; } // default is prediction mode
1318 |       var V2 = V.clone();
1319 |       var N = V.w.length;
1320 |       if(is_training) {
1321 |         // do dropout
1322 |         for(var i=0;i<N;i++) {
1323 |           if(Math.random()<this.drop_prob) { V2.w[i]=0; this.dropped[i] = true; } // drop!
1324 |           else {this.dropped[i] = false;}
1325 |         }
1326 |       } else {
1327 |         // scale the activations during prediction
1328 |         for(var i=0;i<N;i++) { V2.w[i]*=this.drop_prob; }
1329 |       }
1330 |       this.out_act = V2;
1331 |       return this.out_act; // dummy identity function for now
1332 |     },
1333 |     backward: function() {
1334 |       var V = this.in_act; // we need to set dw of this
1335 |       var chain_grad = this.out_act;
1336 |       var N = V.w.length;
1337 |       V.dw = global.zeros(N); // zero out gradient wrt data
1338 |       for(var i=0;i<N;i++) {
1339 |         if(!(this.dropped[i])) { 
1340 |           V.dw[i] = chain_grad.dw[i]; // copy over the gradient
1341 |         }
1342 |       }
1343 |     },
1344 |     getParamsAndGrads: function() {
1345 |       return [];
1346 |     },
1347 |     toJSON: function() {
1348 |       var json = {};
1349 |       json.out_depth = this.out_depth;
1350 |       json.out_sx = this.out_sx;
1351 |       json.out_sy = this.out_sy;
1352 |       json.layer_type = this.layer_type;
1353 |       json.drop_prob = this.drop_prob;
1354 |       return json;
1355 |     },
1356 |     fromJSON: function(json) {
1357 |       this.out_depth = json.out_depth;
1358 |       this.out_sx = json.out_sx;
1359 |       this.out_sy = json.out_sy;
1360 |       this.layer_type = json.layer_type; 
1361 |       this.drop_prob = json.drop_prob;
1362 |     }
1363 |   }
1364 |   
1365 | 
1366 |   global.DropoutLayer = DropoutLayer;
1367 | })(convnetjs);
1368 | (function(global) {
1369 |   "use strict";
1370 |   var Vol = global.Vol; // convenience
1371 |   
1372 |   // a bit experimental layer for now. I think it works but I'm not 100%
1373 |   // the gradient check is a bit funky. I'll look into this a bit later.
1374 |   // Local Response Normalization in window, along depths of volumes
1375 |   var LocalResponseNormalizationLayer = function(opt) {
1376 |     var opt = opt || {};
1377 | 
1378 |     // required
1379 |     this.k = opt.k;
1380 |     this.n = opt.n;
1381 |     this.alpha = opt.alpha;
1382 |     this.beta = opt.beta;
1383 | 
1384 |     // computed
1385 |     this.out_sx = opt.in_sx;
1386 |     this.out_sy = opt.in_sy;
1387 |     this.out_depth = opt.in_depth;
1388 |     this.layer_type = 'lrn';
1389 | 
1390 |     // checks
1391 |     if(this.n%2 === 0) { console.log('WARNING n should be odd for LRN layer'); }
1392 |   }
1393 |   LocalResponseNormalizationLayer.prototype = {
1394 |     forward: function(V, is_training) {
1395 |       this.in_act = V;
1396 | 
1397 |       var A = V.cloneAndZero();
1398 |       this.S_cache_ = V.cloneAndZero();
1399 |       var n2 = Math.floor(this.n/2);
1400 |       for(var x=0;x<V.sx;x++) {
1401 |         for(var y=0;y<V.sy;y++) {
1402 |           for(var i=0;i<V.depth;i++) {
1403 | 
1404 |             var ai = V.get(x,y,i);
1405 | 
1406 |             // normalize in a window of size n
1407 |             var den = 0.0;
1408 |             for(var j=Math.max(0,i-n2);j<=Math.min(i+n2,V.depth-1);j++) {
1409 |               var aa = V.get(x,y,j);
1410 |               den += aa*aa;
1411 |             }
1412 |             den *= this.alpha / this.n;
1413 |             den += this.k;
1414 |             this.S_cache_.set(x,y,i,den); // will be useful for backprop
1415 |             den = Math.pow(den, this.beta);
1416 |             A.set(x,y,i,ai/den);
1417 |           }
1418 |         }
1419 |       }
1420 | 
1421 |       this.out_act = A;
1422 |       return this.out_act; // dummy identity function for now
1423 |     },
1424 |     backward: function() { 
1425 |       // evaluate gradient wrt data
1426 |       var V = this.in_act; // we need to set dw of this
1427 |       V.dw = global.zeros(V.w.length); // zero out gradient wrt data
1428 |       var A = this.out_act; // computed in forward pass 
1429 | 
1430 |       var n2 = Math.floor(this.n/2);
1431 |       for(var x=0;x<V.sx;x++) {
1432 |         for(var y=0;y<V.sy;y++) {
1433 |           for(var i=0;i<V.depth;i++) {
1434 | 
1435 |             var chain_grad = this.out_act.get_grad(x,y,i);
1436 |             var S = this.S_cache_.get(x,y,i);
1437 |             var SB = Math.pow(S, this.beta);
1438 |             var SB2 = SB*SB;
1439 | 
1440 |             // normalize in a window of size n
1441 |             for(var j=Math.max(0,i-n2);j<=Math.min(i+n2,V.depth-1);j++) {              
1442 |               var aj = V.get(x,y,j); 
1443 |               var g = -aj*this.beta*Math.pow(S,this.beta-1)*this.alpha/this.n*2*aj;
1444 |               if(j===i) g+= SB;
1445 |               g /= SB2;
1446 |               g *= chain_grad;
1447 |               V.add_grad(x,y,j,g);
1448 |             }
1449 | 
1450 |           }
1451 |         }
1452 |       }
1453 |     },
1454 |     getParamsAndGrads: function() { return []; },
1455 |     toJSON: function() {
1456 |       var json = {};
1457 |       json.k = this.k;
1458 |       json.n = this.n;
1459 |       json.alpha = this.alpha; // normalize by size
1460 |       json.beta = this.beta;
1461 |       json.out_sx = this.out_sx; 
1462 |       json.out_sy = this.out_sy;
1463 |       json.out_depth = this.out_depth;
1464 |       json.layer_type = this.layer_type;
1465 |       return json;
1466 |     },
1467 |     fromJSON: function(json) {
1468 |       this.k = json.k;
1469 |       this.n = json.n;
1470 |       this.alpha = json.alpha; // normalize by size
1471 |       this.beta = json.beta;
1472 |       this.out_sx = json.out_sx; 
1473 |       this.out_sy = json.out_sy;
1474 |       this.out_depth = json.out_depth;
1475 |       this.layer_type = json.layer_type;
1476 |     }
1477 |   }
1478 |   
1479 | 
1480 |   global.LocalResponseNormalizationLayer = LocalResponseNormalizationLayer;
1481 | })(convnetjs);
1482 | (function(global) {
1483 |   "use strict";
1484 |   var Vol = global.Vol; // convenience
1485 |   
1486 |   // Net manages a set of layers
1487 |   // For now constraints: Simple linear order of layers, first layer input last layer a cost layer
1488 |   var Net = function(options) {
1489 |     this.layers = [];
1490 |   }
1491 | 
1492 |   Net.prototype = {
1493 |     
1494 |     // takes a list of layer definitions and creates the network layer objects
1495 |     makeLayers: function(defs) {
1496 | 
1497 |       // few checks for now
1498 |       if(defs.length<2) {console.log('ERROR! For now at least have input and softmax layers.');}
1499 |       if(defs[0].type !== 'input') {console.log('ERROR! For now first layer should be input.');}
1500 | 
1501 |       // desugar syntactic for adding activations and dropouts
1502 |       var desugar = function() {
1503 |         var new_defs = [];
1504 |         for(var i=0;i<defs.length;i++) {
1505 |           var def = defs[i];
1506 |           
1507 |           if(def.type==='softmax' || def.type==='svm') {
1508 |             // add an fc layer here, there is no reason the user should
1509 |             // have to worry about this and we almost always want to
1510 |             new_defs.push({type:'fc', num_neurons: def.num_classes});
1511 |           }
1512 | 
1513 |           if(def.type==='regression') {
1514 |             // add an fc layer here, there is no reason the user should
1515 |             // have to worry about this and we almost always want to
1516 |             new_defs.push({type:'fc', num_neurons: def.num_neurons});
1517 |           }
1518 | 
1519 |           if((def.type==='fc' || def.type==='conv') 
1520 |               && typeof(def.bias_pref) === 'undefined'){
1521 |             def.bias_pref = 0.0;
1522 |             if(typeof def.activation !== 'undefined' && def.activation === 'relu') {
1523 |               def.bias_pref = 0.1; // relus like a bit of positive bias to get gradients early
1524 |               // otherwise it's technically possible that a relu unit will never turn on (by chance)
1525 |               // and will never get any gradient and never contribute any computation. Dead relu.
1526 |             }
1527 |           }
1528 |           
1529 |           if(typeof def.tensor !== 'undefined') {
1530 |             // apply quadratic transform so that the upcoming multiply will include
1531 |             // quadratic terms, equivalent to doing a tensor product
1532 |             if(def.tensor) {
1533 |               new_defs.push({type: 'quadtransform'});
1534 |             }
1535 |           }
1536 | 
1537 |           new_defs.push(def);
1538 | 
1539 |           if(typeof def.activation !== 'undefined') {
1540 |             if(def.activation==='relu') { new_defs.push({type:'relu'}); }
1541 |             else if (def.activation==='sigmoid') { new_defs.push({type:'sigmoid'}); }
1542 |             else if (def.activation==='tanh') { new_defs.push({type:'tanh'}); }
1543 |             else if (def.activation==='maxout') {
1544 |               // create maxout activation, and pass along group size, if provided
1545 |               var gs = def.group_size !== 'undefined' ? def.group_size : 2;
1546 |               new_defs.push({type:'maxout', group_size:gs});
1547 |             }
1548 |             else { console.log('ERROR unsupported activation ' + def.activation); }
1549 |           }
1550 |           if(typeof def.drop_prob !== 'undefined' && def.type !== 'dropout') {
1551 |             new_defs.push({type:'dropout', drop_prob: def.drop_prob});
1552 |           }
1553 | 
1554 |         }
1555 |         return new_defs;
1556 |       }
1557 |       defs = desugar(defs);
1558 | 
1559 |       // create the layers
1560 |       this.layers = [];
1561 |       for(var i=0;i<defs.length;i++) {
1562 |         var def = defs[i];
1563 |         if(i>0) {
1564 |           var prev = this.layers[i-1];
1565 |           def.in_sx = prev.out_sx;
1566 |           def.in_sy = prev.out_sy;
1567 |           def.in_depth = prev.out_depth;
1568 |         }
1569 | 
1570 |         switch(def.type) {
1571 |           case 'fc': this.layers.push(new global.FullyConnLayer(def)); break;
1572 |           case 'lrn': this.layers.push(new global.LocalResponseNormalizationLayer(def)); break;
1573 |           case 'dropout': this.layers.push(new global.DropoutLayer(def)); break;
1574 |           case 'input': this.layers.push(new global.InputLayer(def)); break;
1575 |           case 'softmax': this.layers.push(new global.SoftmaxLayer(def)); break;
1576 |           case 'regression': this.layers.push(new global.RegressionLayer(def)); break;
1577 |           case 'conv': this.layers.push(new global.ConvLayer(def)); break;
1578 |           case 'pool': this.layers.push(new global.PoolLayer(def)); break;
1579 |           case 'relu': this.layers.push(new global.ReluLayer(def)); break;
1580 |           case 'sigmoid': this.layers.push(new global.SigmoidLayer(def)); break;
1581 |           case 'tanh': this.layers.push(new global.TanhLayer(def)); break;
1582 |           case 'maxout': this.layers.push(new global.MaxoutLayer(def)); break;
1583 |           case 'quadtransform': this.layers.push(new global.QuadTransformLayer(def)); break;
1584 |           case 'svm': this.layers.push(new global.SVMLayer(def)); break;
1585 |           default: console.log('ERROR: UNRECOGNIZED LAYER TYPE!');
1586 |         }
1587 |       }
1588 |     },
1589 | 
1590 |     // forward prop the network. A trainer will pass in is_training = true
1591 |     forward: function(V, is_training) {
1592 |       if(typeof(is_training)==='undefined') is_training = false;
1593 |       var act = this.layers[0].forward(V, is_training);
1594 |       for(var i=1;i<this.layers.length;i++) {
1595 |         act = this.layers[i].forward(act, is_training);
1596 |       }
1597 |       return act;
1598 |     },
1599 | 
1600 |     getCostLoss: function(V, y) {
1601 |       this.forward(V, false);
1602 |       var N = this.layers.length;
1603 |       var loss = this.layers[N-1].backward(y);
1604 |       return loss;
1605 |     },
1606 |     
1607 |     // backprop: compute gradients wrt all parameters
1608 |     backward: function(y) {
1609 |       var N = this.layers.length;
1610 |       var loss = this.layers[N-1].backward(y); // last layer assumed softmax
1611 |       for(var i=N-2;i>=0;i--) { // first layer assumed input
1612 |         this.layers[i].backward();
1613 |       }
1614 |       return loss;
1615 |     },
1616 |     getParamsAndGrads: function() {
1617 |       // accumulate parameters and gradients for the entire network
1618 |       var response = [];
1619 |       for(var i=0;i<this.layers.length;i++) {
1620 |         var layer_reponse = this.layers[i].getParamsAndGrads();
1621 |         for(var j=0;j<layer_reponse.length;j++) {
1622 |           response.push(layer_reponse[j]);
1623 |         }
1624 |       }
1625 |       return response;
1626 |     },
1627 |     getPrediction: function() {
1628 |       var S = this.layers[this.layers.length-1]; // softmax layer
1629 |       var p = S.out_act.w;
1630 |       var maxv = p[0];
1631 |       var maxi = 0;
1632 |       for(var i=1;i<p.length;i++) {
1633 |         if(p[i] > maxv) { maxv = p[i]; maxi = i;}
1634 |       }
1635 |       return maxi;
1636 |     },
1637 |     toJSON: function() {
1638 |       var json = {};
1639 |       json.layers = [];
1640 |       for(var i=0;i<this.layers.length;i++) {
1641 |         json.layers.push(this.layers[i].toJSON());
1642 |       }
1643 |       return json;
1644 |     },
1645 |     fromJSON: function(json) {
1646 |       this.layers = [];
1647 |       for(var i=0;i<json.layers.length;i++) {
1648 |         var Lj = json.layers[i]
1649 |         var t = Lj.layer_type;
1650 |         var L;
1651 |         if(t==='input') { L = new global.InputLayer(); }
1652 |         if(t==='relu') { L = new global.ReluLayer(); }
1653 |         if(t==='sigmoid') { L = new global.SigmoidLayer(); }
1654 |         if(t==='tanh') { L = new global.TanhLayer(); }
1655 |         if(t==='dropout') { L = new global.DropoutLayer(); }
1656 |         if(t==='conv') { L = new global.ConvLayer(); }
1657 |         if(t==='pool') { L = new global.PoolLayer(); }
1658 |         if(t==='lrn') { L = new global.LocalResponseNormalizationLayer(); }
1659 |         if(t==='softmax') { L = new global.SoftmaxLayer(); }
1660 |         if(t==='regression') { L = new global.RegressionLayer(); }
1661 |         if(t==='fc') { L = new global.FullyConnLayer(); }
1662 |         if(t==='maxout') { L = new global.MaxoutLayer(); }
1663 |         if(t==='quadtransform') { L = new global.QuadTransformLayer(); }
1664 |         if(t==='svm') { L = new global.SVMLayer(); }
1665 |         L.fromJSON(Lj);
1666 |         this.layers.push(L);
1667 |       }
1668 |     }
1669 |   }
1670 |   
1671 | 
1672 |   global.Net = Net;
1673 | })(convnetjs);
1674 | (function(global) {
1675 |   "use strict";
1676 |   var Vol = global.Vol; // convenience
1677 | 
1678 |   var Trainer = function(net, options) {
1679 | 
1680 |     this.net = net;
1681 | 
1682 |     var options = options || {};
1683 |     this.learning_rate = typeof options.learning_rate !== 'undefined' ? options.learning_rate : 0.01;
1684 |     this.l1_decay = typeof options.l1_decay !== 'undefined' ? options.l1_decay : 0.0;
1685 |     this.l2_decay = typeof options.l2_decay !== 'undefined' ? options.l2_decay : 0.0;
1686 |     this.batch_size = typeof options.batch_size !== 'undefined' ? options.batch_size : 1;
1687 |     this.method = typeof options.method !== 'undefined' ? options.method : 'sgd'; // sgd/adagrad/adadelta/windowgrad
1688 | 
1689 |     this.momentum = typeof options.momentum !== 'undefined' ? options.momentum : 0.9;
1690 |     this.ro = typeof options.ro !== 'undefined' ? options.ro : 0.95; // used in adadelta
1691 |     this.eps = typeof options.eps !== 'undefined' ? options.eps : 1e-6; // used in adadelta
1692 | 
1693 |     this.k = 0; // iteration counter
1694 |     this.gsum = []; // last iteration gradients (used for momentum calculations)
1695 |     this.xsum = []; // used in adadelta
1696 |   }
1697 | 
1698 |   Trainer.prototype = {
1699 |     train: function(x, y) {
1700 | 
1701 |       var start = new Date().getTime();
1702 |       this.net.forward(x, true); // also set the flag that lets the net know we're just training
1703 |       var end = new Date().getTime();
1704 |       var fwd_time = end - start;
1705 | 
1706 |       var start = new Date().getTime();
1707 |       var cost_loss = this.net.backward(y);
1708 |       var l2_decay_loss = 0.0;
1709 |       var l1_decay_loss = 0.0;
1710 |       var end = new Date().getTime();
1711 |       var bwd_time = end - start;
1712 |       
1713 |       this.k++;
1714 |       if(this.k % this.batch_size === 0) {
1715 | 
1716 |         var pglist = this.net.getParamsAndGrads();
1717 | 
1718 |         // initialize lists for accumulators. Will only be done once on first iteration
1719 |         if(this.gsum.length === 0 && (this.method !== 'sgd' || this.momentum > 0.0)) {
1720 |           // only vanilla sgd doesnt need either lists
1721 |           // momentum needs gsum
1722 |           // adagrad needs gsum
1723 |           // adadelta needs gsum and xsum
1724 |           for(var i=0;i<pglist.length;i++) {
1725 |             this.gsum.push(global.zeros(pglist[i].params.length));
1726 |             if(this.method === 'adadelta') {
1727 |               this.xsum.push(global.zeros(pglist[i].params.length));
1728 |             } else {
1729 |               this.xsum.push([]); // conserve memory
1730 |             }
1731 |           }
1732 |         }
1733 | 
1734 |         // perform an update for all sets of weights
1735 |         for(var i=0;i<pglist.length;i++) {
1736 |           var pg = pglist[i]; // param, gradient, other options in future (custom learning rate etc)
1737 |           var p = pg.params;
1738 |           var g = pg.grads;
1739 | 
1740 |           // learning rate for some parameters.
1741 |           var l2_decay_mul = typeof pg.l2_decay_mul !== 'undefined' ? pg.l2_decay_mul : 1.0;
1742 |           var l1_decay_mul = typeof pg.l1_decay_mul !== 'undefined' ? pg.l1_decay_mul : 1.0;
1743 |           var l2_decay = this.l2_decay * l2_decay_mul;
1744 |           var l1_decay = this.l1_decay * l1_decay_mul;
1745 | 
1746 |           var plen = p.length;
1747 |           for(var j=0;j<plen;j++) {
1748 |             l2_decay_loss += l2_decay*p[j]*p[j]/2; // accumulate weight decay loss
1749 |             l1_decay_loss += l1_decay*Math.abs(p[j]);
1750 |             var l1grad = l1_decay * (p[j] > 0 ? 1 : -1);
1751 |             var l2grad = l2_decay * (p[j]);
1752 | 
1753 |             var gij = (l2grad + l1grad + g[j]) / this.batch_size; // raw batch gradient
1754 | 
1755 |             var gsumi = this.gsum[i];
1756 |             var xsumi = this.xsum[i];
1757 |             if(this.method === 'adagrad') {
1758 |               // adagrad update
1759 |               gsumi[j] = gsumi[j] + gij * gij;
1760 |               var dx = - this.learning_rate / Math.sqrt(gsumi[j] + this.eps) * gij;
1761 |               p[j] += dx;
1762 |             } else if(this.method === 'windowgrad') {
1763 |               // this is adagrad but with a moving window weighted average
1764 |               // so the gradient is not accumulated over the entire history of the run. 
1765 |               // it's also referred to as Idea #1 in Zeiler paper on Adadelta. Seems reasonable to me!
1766 |               gsumi[j] = this.ro * gsumi[j] + (1-this.ro) * gij * gij;
1767 |               var dx = - this.learning_rate / Math.sqrt(gsumi[j] + this.eps) * gij; // eps added for better conditioning
1768 |               p[j] += dx;
1769 |             } else if(this.method === 'adadelta') {
1770 |               // assume adadelta if not sgd or adagrad
1771 |               gsumi[j] = this.ro * gsumi[j] + (1-this.ro) * gij * gij;
1772 |               var dx = - Math.sqrt((xsumi[j] + this.eps)/(gsumi[j] + this.eps)) * gij;
1773 |               xsumi[j] = this.ro * xsumi[j] + (1-this.ro) * dx * dx; // yes, xsum lags behind gsum by 1.
1774 |               p[j] += dx;
1775 |             } else {
1776 |               // assume SGD
1777 |               if(this.momentum > 0.0) {
1778 |                 // momentum update
1779 |                 var dx = this.momentum * gsumi[j] - this.learning_rate * gij; // step
1780 |                 gsumi[j] = dx; // back this up for next iteration of momentum
1781 |                 p[j] += dx; // apply corrected gradient
1782 |               } else {
1783 |                 // vanilla sgd
1784 |                 p[j] +=  - this.learning_rate * gij;
1785 |               }
1786 |             }
1787 |             g[j] = 0.0; // zero out gradient so that we can begin accumulating anew
1788 |           }
1789 |         }
1790 |       }
1791 | 
1792 |       // appending softmax_loss for backwards compatibility, but from now on we will always use cost_loss
1793 |       // in future, TODO: have to completely redo the way loss is done around the network as currently 
1794 |       // loss is a bit of a hack. Ideally, user should specify arbitrary number of loss functions on any layer
1795 |       // and it should all be computed correctly and automatically. 
1796 |       return {fwd_time: fwd_time, bwd_time: bwd_time, 
1797 |               l2_decay_loss: l2_decay_loss, l1_decay_loss: l1_decay_loss,
1798 |               cost_loss: cost_loss, softmax_loss: cost_loss, 
1799 |               loss: cost_loss + l1_decay_loss + l2_decay_loss}
1800 |     }
1801 |   }
1802 |   
1803 |   global.Trainer = Trainer;
1804 |   global.SGDTrainer = Trainer; // backwards compatibility
1805 | })(convnetjs);
1806 | 
1807 | (function(global) {
1808 |   "use strict";
1809 | 
1810 |   // used utilities, make explicit local references
1811 |   var randf = global.randf;
1812 |   var randi = global.randi;
1813 |   var Net = global.Net;
1814 |   var Trainer = global.Trainer;
1815 |   var maxmin = global.maxmin;
1816 |   var randperm = global.randperm;
1817 |   var weightedSample = global.weightedSample;
1818 |   var getopt = global.getopt;
1819 |   var arrUnique = global.arrUnique;
1820 | 
1821 |   /*
1822 |   A MagicNet takes data: a list of convnetjs.Vol(), and labels
1823 |   which for now are assumed to be class indeces 0..K. MagicNet then:
1824 |   - creates data folds for cross-validation
1825 |   - samples candidate networks
1826 |   - evaluates candidate networks on all data folds
1827 |   - produces predictions by model-averaging the best networks
1828 |   */
1829 |   var MagicNet = function(data, labels, opt) {
1830 |     var opt = opt || {};
1831 |     if(typeof data === 'undefined') { data = []; }
1832 |     if(typeof labels === 'undefined') { labels = []; }
1833 | 
1834 |     // required inputs
1835 |     this.data = data; // store these pointers to data
1836 |     this.labels = labels;
1837 | 
1838 |     // optional inputs
1839 |     this.train_ratio = getopt(opt, 'train_ratio', 0.7);
1840 |     this.num_folds = getopt(opt, 'num_folds', 10);
1841 |     this.num_candidates = getopt(opt, 'num_candidates', 50); // we evaluate several in parallel
1842 |     // how many epochs of data to train every network? for every fold?
1843 |     // higher values mean higher accuracy in final results, but more expensive
1844 |     this.num_epochs = getopt(opt, 'num_epochs', 50); 
1845 |     // number of best models to average during prediction. Usually higher = better
1846 |     this.ensemble_size = getopt(opt, 'ensemble_size', 10);
1847 | 
1848 |     // candidate parameters
1849 |     this.batch_size_min = getopt(opt, 'batch_size_min', 10);
1850 |     this.batch_size_max = getopt(opt, 'batch_size_max', 300);
1851 |     this.l2_decay_min = getopt(opt, 'l2_decay_min', -4);
1852 |     this.l2_decay_max = getopt(opt, 'l2_decay_max', 2);
1853 |     this.learning_rate_min = getopt(opt, 'learning_rate_min', -4);
1854 |     this.learning_rate_max = getopt(opt, 'learning_rate_max', 0);
1855 |     this.momentum_min = getopt(opt, 'momentum_min', 0.9);
1856 |     this.momentum_max = getopt(opt, 'momentum_max', 0.9);
1857 |     this.neurons_min = getopt(opt, 'neurons_min', 5);
1858 |     this.neurons_max = getopt(opt, 'neurons_max', 30);
1859 | 
1860 |     // computed
1861 |     this.folds = []; // data fold indices, gets filled by sampleFolds()
1862 |     this.candidates = []; // candidate networks that are being currently evaluated
1863 |     this.evaluated_candidates = []; // history of all candidates that were fully evaluated on all folds
1864 |     this.unique_labels = arrUnique(labels);
1865 |     this.iter = 0; // iteration counter, goes from 0 -> num_epochs * num_training_data
1866 |     this.foldix = 0; // index of active fold
1867 | 
1868 |     // callbacks
1869 |     this.finish_fold_callback = null;
1870 |     this.finish_batch_callback = null;
1871 | 
1872 |     // initializations
1873 |     if(this.data.length > 0) {
1874 |       this.sampleFolds();
1875 |       this.sampleCandidates();
1876 |     }
1877 |   };
1878 | 
1879 |   MagicNet.prototype = {
1880 | 
1881 |     // sets this.folds to a sampling of this.num_folds folds
1882 |     sampleFolds: function() {
1883 |       var N = this.data.length;
1884 |       var num_train = Math.floor(this.train_ratio * N);
1885 |       this.folds = []; // flush folds, if any
1886 |       for(var i=0;i<this.num_folds;i++) {
1887 |         var p = randperm(N);
1888 |         this.folds.push({train_ix: p.slice(0, num_train), test_ix: p.slice(num_train, N)});
1889 |       }
1890 |     },
1891 | 
1892 |     // returns a random candidate network
1893 |     sampleCandidate: function() {
1894 |       var input_depth = this.data[0].w.length;
1895 |       var num_classes = this.unique_labels.length;
1896 | 
1897 |       // sample network topology and hyperparameters
1898 |       var layer_defs = [];
1899 |       layer_defs.push({type:'input', out_sx:1, out_sy:1, out_depth: input_depth});
1900 |       var nl = weightedSample([0,1,2,3], [0.2, 0.3, 0.3, 0.2]); // prefer nets with 1,2 hidden layers
1901 |       for(var q=0;q<nl;q++) {
1902 |         var ni = randi(this.neurons_min, this.neurons_max);
1903 |         var act = ['tanh','maxout','relu'][randi(0,3)];
1904 |         if(randf(0,1)<0.5) {
1905 |           var dp = Math.random();
1906 |           layer_defs.push({type:'fc', num_neurons: ni, activation: act, drop_prob: dp});
1907 |         } else {
1908 |           layer_defs.push({type:'fc', num_neurons: ni, activation: act});
1909 |         }
1910 |       }
1911 |       layer_defs.push({type:'softmax', num_classes: num_classes});
1912 |       var net = new Net();
1913 |       net.makeLayers(layer_defs);
1914 | 
1915 |       // sample training hyperparameters
1916 |       var bs = randi(this.batch_size_min, this.batch_size_max); // batch size
1917 |       var l2 = Math.pow(10, randf(this.l2_decay_min, this.l2_decay_max)); // l2 weight decay
1918 |       var lr = Math.pow(10, randf(this.learning_rate_min, this.learning_rate_max)); // learning rate
1919 |       var mom = randf(this.momentum_min, this.momentum_max); // momentum. Lets just use 0.9, works okay usually ;p
1920 |       var tp = randf(0,1); // trainer type
1921 |       var trainer_def;
1922 |       if(tp<0.33) {
1923 |         trainer_def = {method:'adadelta', batch_size:bs, l2_decay:l2};
1924 |       } else if(tp<0.66) {
1925 |         trainer_def = {method:'adagrad', learning_rate: lr, batch_size:bs, l2_decay:l2};
1926 |       } else {
1927 |         trainer_def = {method:'sgd', learning_rate: lr, momentum: mom, batch_size:bs, l2_decay:l2};
1928 |       }
1929 |       
1930 |       var trainer = new Trainer(net, trainer_def);
1931 | 
1932 |       var cand = {};
1933 |       cand.acc = [];
1934 |       cand.accv = 0; // this will maintained as sum(acc) for convenience
1935 |       cand.layer_defs = layer_defs;
1936 |       cand.trainer_def = trainer_def;
1937 |       cand.net = net;
1938 |       cand.trainer = trainer;
1939 |       return cand;
1940 |     },
1941 | 
1942 |     // sets this.candidates with this.num_candidates candidate nets
1943 |     sampleCandidates: function() {
1944 |       this.candidates = []; // flush, if any
1945 |       for(var i=0;i<this.num_candidates;i++) {
1946 |         var cand = this.sampleCandidate();
1947 |         this.candidates.push(cand);
1948 |       }
1949 |     },
1950 | 
1951 |     step: function() {
1952 |       
1953 |       // run an example through current candidate
1954 |       this.iter++;
1955 | 
1956 |       // step all candidates on a random data point
1957 |       var fold = this.folds[this.foldix]; // active fold
1958 |       var dataix = fold.train_ix[randi(0, fold.train_ix.length)];
1959 |       for(var k=0;k<this.candidates.length;k++) {
1960 |         var x = this.data[dataix];
1961 |         var l = this.labels[dataix];
1962 |         this.candidates[k].trainer.train(x, l);
1963 |       }
1964 | 
1965 |       // process consequences: sample new folds, or candidates
1966 |       var lastiter = this.num_epochs * fold.train_ix.length;
1967 |       if(this.iter >= lastiter) {
1968 |         // finished evaluation of this fold. Get final validation
1969 |         // accuracies, record them, and go on to next fold.
1970 |         var val_acc = this.evalValErrors();
1971 |         for(var k=0;k<this.candidates.length;k++) {
1972 |           var c = this.candidates[k];
1973 |           c.acc.push(val_acc[k]);
1974 |           c.accv += val_acc[k];
1975 |         }
1976 |         this.iter = 0; // reset step number
1977 |         this.foldix++; // increment fold
1978 | 
1979 |         if(this.finish_fold_callback !== null) {
1980 |           this.finish_fold_callback();
1981 |         }
1982 | 
1983 |         if(this.foldix >= this.folds.length) {
1984 |           // we finished all folds as well! Record these candidates
1985 |           // and sample new ones to evaluate.
1986 |           for(var k=0;k<this.candidates.length;k++) {
1987 |             this.evaluated_candidates.push(this.candidates[k]);
1988 |           }
1989 |           // sort evaluated candidates according to accuracy achieved
1990 |           this.evaluated_candidates.sort(function(a, b) { 
1991 |             return (a.accv / a.acc.length) 
1992 |                  > (b.accv / b.acc.length) 
1993 |                  ? -1 : 1;
1994 |           });
1995 |           // and clip only to the top few ones (lets place limit at 3*ensemble_size)
1996 |           // otherwise there are concerns with keeping these all in memory 
1997 |           // if MagicNet is being evaluated for a very long time
1998 |           if(this.evaluated_candidates.length > 3 * this.ensemble_size) {
1999 |             this.evaluated_candidates = this.evaluated_candidates.slice(0, 3 * this.ensemble_size);
2000 |           }
2001 |           if(this.finish_batch_callback !== null) {
2002 |             this.finish_batch_callback();
2003 |           }
2004 |           this.sampleCandidates(); // begin with new candidates
2005 |           this.foldix = 0; // reset this
2006 |         } else {
2007 |           // we will go on to another fold. reset all candidates nets
2008 |           for(var k=0;k<this.candidates.length;k++) {
2009 |             var c = this.candidates[k];
2010 |             var net = new Net();
2011 |             net.makeLayers(c.layer_defs);
2012 |             var trainer = new Trainer(net, c.trainer_def);
2013 |             c.net = net;
2014 |             c.trainer = trainer;
2015 |           }
2016 |         }
2017 |       }
2018 |     },
2019 | 
2020 |     evalValErrors: function() {
2021 |       // evaluate candidates on validation data and return performance of current networks
2022 |       // as simple list
2023 |       var vals = [];
2024 |       var fold = this.folds[this.foldix]; // active fold
2025 |       for(var k=0;k<this.candidates.length;k++) {
2026 |         var net = this.candidates[k].net;
2027 |         var v = 0.0;
2028 |         for(var q=0;q<fold.test_ix.length;q++) {
2029 |           var x = this.data[fold.test_ix[q]];
2030 |           var l = this.labels[fold.test_ix[q]];
2031 |           net.forward(x);
2032 |           var yhat = net.getPrediction();
2033 |           v += (yhat === l ? 1.0 : 0.0); // 0 1 loss
2034 |         }
2035 |         v /= fold.test_ix.length; // normalize
2036 |         vals.push(v);
2037 |       }
2038 |       return vals;
2039 |     },
2040 | 
2041 |     // returns prediction scores for given test data point, as Vol
2042 |     // uses an averaged prediction from the best ensemble_size models
2043 |     // x is a Vol.
2044 |     predict_soft: function(data) {
2045 |       // forward prop the best networks
2046 |       // and accumulate probabilities at last layer into a an output Vol
2047 |       var nv = Math.min(this.ensemble_size, this.evaluated_candidates.length);
2048 |       if(nv === 0) { return new convnetjs.Vol(0,0,0); } // not sure what to do here? we're not ready yet
2049 |       var xout, n;
2050 |       for(var j=0;j<nv;j++) {
2051 |         var net = this.evaluated_candidates[j].net;
2052 |         var x = net.forward(data);
2053 |         if(j===0) { 
2054 |           xout = x; 
2055 |           n = x.w.length; 
2056 |         } else {
2057 |           // add it on
2058 |           for(var d=0;d<n;d++) {
2059 |             xout.w[d] += x.w[d];
2060 |           }
2061 |         }
2062 |       }
2063 |       // produce average
2064 |       for(var d=0;d<n;d++) {
2065 |         xout.w[d] /= n;
2066 |       }
2067 |       return xout;
2068 |     },
2069 | 
2070 |     predict: function(data) {
2071 |       var xout = this.predict_soft(data);
2072 |       if(xout.w.length !== 0) {
2073 |         var stats = maxmin(xout.w);
2074 |         var predicted_label = stats.maxi; 
2075 |       } else {
2076 |         var predicted_label = -1; // error out
2077 |       }
2078 |       return predicted_label;
2079 | 
2080 |     },
2081 | 
2082 |     toJSON: function() {
2083 |       // dump the top ensemble_size networks as a list
2084 |       var nv = Math.min(this.ensemble_size, this.evaluated_candidates.length);
2085 |       var json = {};
2086 |       json.nets = [];
2087 |       for(var i=0;i<nv;i++) {
2088 |         json.nets.push(this.evaluated_candidates[i].net.toJSON());
2089 |       }
2090 |       return json;
2091 |     },
2092 | 
2093 |     fromJSON: function(json) {
2094 |       this.ensemble_size = json.nets.length;
2095 |       this.evaluated_candidates = [];
2096 |       for(var i=0;i<this.ensemble_size;i++) {
2097 |         var net = new Net();
2098 |         net.fromJSON(json.nets[i]);
2099 |         var dummy_candidate = {};
2100 |         dummy_candidate.net = net;
2101 |         this.evaluated_candidates.push(dummy_candidate);
2102 |       }
2103 |     },
2104 | 
2105 |     // callback functions
2106 |     // called when a fold is finished, while evaluating a batch
2107 |     onFinishFold: function(f) { this.finish_fold_callback = f; },
2108 |     // called when a batch of candidates has finished evaluating
2109 |     onFinishBatch: function(f) { this.finish_batch_callback = f; }
2110 |     
2111 |   };
2112 | 
2113 |   global.MagicNet = MagicNet;
2114 | })(convnetjs);
2115 | (function(lib) {
2116 |   "use strict";
2117 |   if (typeof module === "undefined" || typeof module.exports === "undefined") {
2118 |     window.jsfeat = lib; // in ordinary browser attach library to window
2119 |   } else {
2120 |     module.exports = lib; // in nodejs
2121 |   }
2122 | })(convnetjs);
2123 | 


--------------------------------------------------------------------------------
/src/vendor/uncertain/convnet.js:
--------------------------------------------------------------------------------
   1 | var convnetjs = convnetjs || { REVISION: 'ALPHA' };
   2 | (function(global) {
   3 |   "use strict";
   4 | 
   5 |   // Random number utilities
   6 |   var return_v = false;
   7 |   var v_val = 0.0;
   8 |   var gaussRandom = function() {
   9 |     if(return_v) {
  10 |       return_v = false;
  11 |       return v_val;
  12 |     }
  13 |     var u = 2*Math.random()-1;
  14 |     var v = 2*Math.random()-1;
  15 |     var r = u*u + v*v;
  16 |     if(r == 0 || r > 1) return gaussRandom();
  17 |     var c = Math.sqrt(-2*Math.log(r)/r);
  18 |     v_val = v*c; // cache this
  19 |     return_v = true;
  20 |     return u*c;
  21 |   }
  22 |   var randf = function(a, b) { return Math.random()*(b-a)+a; }
  23 |   var randi = function(a, b) { return Math.floor(Math.random()*(b-a)+a); }
  24 |   var randn = function(mu, std){ return mu+gaussRandom()*std; }
  25 | 
  26 |   // Array utilities
  27 |   var zeros = function(n) {
  28 |     if(typeof(n)==='undefined' || isNaN(n)) { return []; }
  29 |     if(typeof ArrayBuffer === 'undefined') {
  30 |       // lacking browser support
  31 |       var arr = new Array(n);
  32 |       for(var i=0;i<n;i++) { arr[i]= 0; }
  33 |       return arr;
  34 |     } else {
  35 |       return new Float64Array(n);
  36 |     }
  37 |   }
  38 | 
  39 |   var arrContains = function(arr, elt) {
  40 |     for(var i=0,n=arr.length;i<n;i++) {
  41 |       if(arr[i]===elt) return true;
  42 |     }
  43 |     return false;
  44 |   }
  45 | 
  46 |   var arrUnique = function(arr) {
  47 |     var b = [];
  48 |     for(var i=0,n=arr.length;i<n;i++) {
  49 |       if(!arrContains(b, arr[i])) {
  50 |         b.push(arr[i]);
  51 |       }
  52 |     }
  53 |     return b;
  54 |   }
  55 | 
  56 |   // return max and min of a given non-empty array.
  57 |   var maxmin = function(w) {
  58 |     if(w.length === 0) { return {}; } // ... ;s
  59 |     var maxv = w[0];
  60 |     var minv = w[0];
  61 |     var maxi = 0;
  62 |     var mini = 0;
  63 |     var n = w.length;
  64 |     for(var i=1;i<n;i++) {
  65 |       if(w[i] > maxv) { maxv = w[i]; maxi = i; }
  66 |       if(w[i] < minv) { minv = w[i]; mini = i; }
  67 |     }
  68 |     return {maxi: maxi, maxv: maxv, mini: mini, minv: minv, dv:maxv-minv};
  69 |   }
  70 | 
  71 |   // create random permutation of numbers, in range [0...n-1]
  72 |   var randperm = function(n) {
  73 |     var i = n,
  74 |         j = 0,
  75 |         temp;
  76 |     var array = [];
  77 |     for(var q=0;q<n;q++)array[q]=q;
  78 |     while (i--) {
  79 |         j = Math.floor(Math.random() * (i+1));
  80 |         temp = array[i];
  81 |         array[i] = array[j];
  82 |         array[j] = temp;
  83 |     }
  84 |     return array;
  85 |   }
  86 | 
  87 |   // sample from list lst according to probabilities in list probs
  88 |   // the two lists are of same size, and probs adds up to 1
  89 |   var weightedSample = function(lst, probs) {
  90 |     var p = randf(0, 1.0);
  91 |     var cumprob = 0.0;
  92 |     for(var k=0,n=lst.length;k<n;k++) {
  93 |       cumprob += probs[k];
  94 |       if(p < cumprob) { return lst[k]; }
  95 |     }
  96 |   }
  97 | 
  98 |   // syntactic sugar function for getting default parameter values
  99 |   var getopt = function(opt, field_name, default_value) {
 100 |     if(typeof field_name === 'string') {
 101 |       // case of single string
 102 |       return (typeof opt[field_name] !== 'undefined') ? opt[field_name] : default_value;
 103 |     } else {
 104 |       // assume we are given a list of string instead
 105 |       var ret = default_value;
 106 |       for(var i=0;i<field_name.length;i++) {
 107 |         var f = field_name[i];
 108 |         if (typeof opt[f] !== 'undefined') {
 109 |           ret = opt[f]; // overwrite return value
 110 |         }
 111 |       }
 112 |       return ret;
 113 |     }
 114 |   }
 115 | 
 116 |   function assert(condition, message) {
 117 |     if (!condition) {
 118 |       message = message || "Assertion failed";
 119 |       if (typeof Error !== "undefined") {
 120 |         throw new Error(message);
 121 |       }
 122 |       throw message; // Fallback
 123 |     }
 124 |   }
 125 | 
 126 |   global.randf = randf;
 127 |   global.randi = randi;
 128 |   global.randn = randn;
 129 |   global.zeros = zeros;
 130 |   global.maxmin = maxmin;
 131 |   global.randperm = randperm;
 132 |   global.weightedSample = weightedSample;
 133 |   global.arrUnique = arrUnique;
 134 |   global.arrContains = arrContains;
 135 |   global.getopt = getopt;
 136 |   global.assert = assert;
 137 | 
 138 | })(convnetjs);
 139 | (function(global) {
 140 |   "use strict";
 141 | 
 142 |   // Vol is the basic building block of all data in a net.
 143 |   // it is essentially just a 3D volume of numbers, with a
 144 |   // width (sx), height (sy), and depth (depth).
 145 |   // it is used to hold data for all filters, all volumes,
 146 |   // all weights, and also stores all gradients w.r.t.
 147 |   // the data. c is optionally a value to initialize the volume
 148 |   // with. If c is missing, fills the Vol with random numbers.
 149 |   var Vol = function(sx, sy, depth, c) {
 150 |     // this is how you check if a variable is an array. Oh, Javascript :)
 151 |     if(Object.prototype.toString.call(sx) === '[object Array]') {
 152 |       // we were given a list in sx, assume 1D volume and fill it up
 153 |       this.sx = 1;
 154 |       this.sy = 1;
 155 |       this.depth = sx.length;
 156 |       // we have to do the following copy because we want to use
 157 |       // fast typed arrays, not an ordinary javascript array
 158 |       this.w = global.zeros(this.depth);
 159 |       this.dw = global.zeros(this.depth);
 160 |       for(var i=0;i<this.depth;i++) {
 161 |         this.w[i] = sx[i];
 162 |       }
 163 |     } else {
 164 |       // we were given dimensions of the vol
 165 |       this.sx = sx;
 166 |       this.sy = sy;
 167 |       this.depth = depth;
 168 |       var n = sx*sy*depth;
 169 |       this.w = global.zeros(n);
 170 |       this.dw = global.zeros(n);
 171 |       if(typeof c === 'undefined') {
 172 |         // weight normalization is done to equalize the output
 173 |         // variance of every neuron, otherwise neurons with a lot
 174 |         // of incoming connections have outputs of larger variance
 175 |         var scale = Math.sqrt(1.0/(sx*sy*depth));
 176 |         for(var i=0;i<n;i++) {
 177 |           this.w[i] = global.randn(0.0, scale);
 178 |         }
 179 |       } else {
 180 |         for(var i=0;i<n;i++) {
 181 |           this.w[i] = c;
 182 |         }
 183 |       }
 184 |     }
 185 |   }
 186 | 
 187 |   Vol.prototype = {
 188 |     get: function(x, y, d) {
 189 |       var ix=((this.sx * y)+x)*this.depth+d;
 190 |       return this.w[ix];
 191 |     },
 192 |     set: function(x, y, d, v) {
 193 |       var ix=((this.sx * y)+x)*this.depth+d;
 194 |       this.w[ix] = v;
 195 |     },
 196 |     add: function(x, y, d, v) {
 197 |       var ix=((this.sx * y)+x)*this.depth+d;
 198 |       this.w[ix] += v;
 199 |     },
 200 |     get_grad: function(x, y, d) {
 201 |       var ix = ((this.sx * y)+x)*this.depth+d;
 202 |       return this.dw[ix];
 203 |     },
 204 |     set_grad: function(x, y, d, v) {
 205 |       var ix = ((this.sx * y)+x)*this.depth+d;
 206 |       this.dw[ix] = v;
 207 |     },
 208 |     add_grad: function(x, y, d, v) {
 209 |       var ix = ((this.sx * y)+x)*this.depth+d;
 210 |       this.dw[ix] += v;
 211 |     },
 212 |     cloneAndZero: function() { return new Vol(this.sx, this.sy, this.depth, 0.0)},
 213 |     clone: function() {
 214 |       var V = new Vol(this.sx, this.sy, this.depth, 0.0);
 215 |       var n = this.w.length;
 216 |       for(var i=0;i<n;i++) { V.w[i] = this.w[i]; }
 217 |       return V;
 218 |     },
 219 |     addFrom: function(V) { for(var k=0;k<this.w.length;k++) { this.w[k] += V.w[k]; }},
 220 |     addFromScaled: function(V, a) { for(var k=0;k<this.w.length;k++) { this.w[k] += a*V.w[k]; }},
 221 |     setConst: function(a) { for(var k=0;k<this.w.length;k++) { this.w[k] = a; }},
 222 | 
 223 |     toJSON: function() {
 224 |       // todo: we may want to only save d most significant digits to save space
 225 |       var json = {}
 226 |       json.sx = this.sx;
 227 |       json.sy = this.sy;
 228 |       json.depth = this.depth;
 229 |       json.w = this.w;
 230 |       return json;
 231 |       // we wont back up gradients to save space
 232 |     },
 233 |     fromJSON: function(json) {
 234 |       this.sx = json.sx;
 235 |       this.sy = json.sy;
 236 |       this.depth = json.depth;
 237 | 
 238 |       var n = this.sx*this.sy*this.depth;
 239 |       this.w = global.zeros(n);
 240 |       this.dw = global.zeros(n);
 241 |       // copy over the elements.
 242 |       for(var i=0;i<n;i++) {
 243 |         this.w[i] = json.w[i];
 244 |       }
 245 |     }
 246 |   }
 247 | 
 248 |   global.Vol = Vol;
 249 | })(convnetjs);
 250 | (function(global) {
 251 |   "use strict";
 252 |   var Vol = global.Vol; // convenience
 253 | 
 254 |   // Volume utilities
 255 |   // intended for use with data augmentation
 256 |   // crop is the size of output
 257 |   // dx,dy are offset wrt incoming volume, of the shift
 258 |   // fliplr is boolean on whether we also want to flip left<->right
 259 |   var augment = function(V, crop, dx, dy, fliplr) {
 260 |     // note assumes square outputs of size crop x crop
 261 |     if(typeof(fliplr)==='undefined') var fliplr = false;
 262 |     if(typeof(dx)==='undefined') var dx = global.randi(0, V.sx - crop);
 263 |     if(typeof(dy)==='undefined') var dy = global.randi(0, V.sy - crop);
 264 | 
 265 |     // randomly sample a crop in the input volume
 266 |     var W;
 267 |     if(crop !== V.sx || dx!==0 || dy!==0) {
 268 |       W = new Vol(crop, crop, V.depth, 0.0);
 269 |       for(var x=0;x<crop;x++) {
 270 |         for(var y=0;y<crop;y++) {
 271 |           if(x+dx<0 || x+dx>=V.sx || y+dy<0 || y+dy>=V.sy) continue; // oob
 272 |           for(var d=0;d<V.depth;d++) {
 273 |            W.set(x,y,d,V.get(x+dx,y+dy,d)); // copy data over
 274 |           }
 275 |         }
 276 |       }
 277 |     } else {
 278 |       W = V;
 279 |     }
 280 | 
 281 |     if(fliplr) {
 282 |       // flip volume horziontally
 283 |       var W2 = W.cloneAndZero();
 284 |       for(var x=0;x<W.sx;x++) {
 285 |         for(var y=0;y<W.sy;y++) {
 286 |           for(var d=0;d<W.depth;d++) {
 287 |            W2.set(x,y,d,W.get(W.sx - x - 1,y,d)); // copy data over
 288 |           }
 289 |         }
 290 |       }
 291 |       W = W2; //swap
 292 |     }
 293 |     return W;
 294 |   }
 295 | 
 296 |   // img is a DOM element that contains a loaded image
 297 |   // returns a Vol of size (W, H, 4). 4 is for RGBA
 298 |   var img_to_vol = function(img, convert_grayscale) {
 299 | 
 300 |     if(typeof(convert_grayscale)==='undefined') var convert_grayscale = false;
 301 | 
 302 |     var canvas = document.createElement('canvas');
 303 |     canvas.width = img.width;
 304 |     canvas.height = img.height;
 305 |     var ctx = canvas.getContext("2d");
 306 | 
 307 |     // due to a Firefox bug
 308 |     try {
 309 |       ctx.drawImage(img, 0, 0);
 310 |     } catch (e) {
 311 |       if (e.name === "NS_ERROR_NOT_AVAILABLE") {
 312 |         // sometimes happens, lets just abort
 313 |         return false;
 314 |       } else {
 315 |         throw e;
 316 |       }
 317 |     }
 318 | 
 319 |     try {
 320 |       var img_data = ctx.getImageData(0, 0, canvas.width, canvas.height);
 321 |     } catch (e) {
 322 |       if(e.name === 'IndexSizeError') {
 323 |         return false; // not sure what causes this sometimes but okay abort
 324 |       } else {
 325 |         throw e;
 326 |       }
 327 |     }
 328 | 
 329 |     // prepare the input: get pixels and normalize them
 330 |     var p = img_data.data;
 331 |     var W = img.width;
 332 |     var H = img.height;
 333 |     var pv = []
 334 |     for(var i=0;i<p.length;i++) {
 335 |       pv.push(p[i]/255.0-0.5); // normalize image pixels to [-0.5, 0.5]
 336 |     }
 337 |     var x = new Vol(W, H, 4, 0.0); //input volume (image)
 338 |     x.w = pv;
 339 | 
 340 |     if(convert_grayscale) {
 341 |       // flatten into depth=1 array
 342 |       var x1 = new Vol(W, H, 1, 0.0);
 343 |       for(var i=0;i<W;i++) {
 344 |         for(var j=0;j<H;j++) {
 345 |           x1.set(i,j,0,x.get(i,j,0));
 346 |         }
 347 |       }
 348 |       x = x1;
 349 |     }
 350 | 
 351 |     return x;
 352 |   }
 353 | 
 354 |   global.augment = augment;
 355 |   global.img_to_vol = img_to_vol;
 356 | 
 357 | })(convnetjs);
 358 | (function(global) {
 359 |   "use strict";
 360 |   var Vol = global.Vol; // convenience
 361 | 
 362 |   // This file contains all layers that do dot products with input,
 363 |   // but usually in a different connectivity pattern and weight sharing
 364 |   // schemes:
 365 |   // - FullyConn is fully connected dot products
 366 |   // - ConvLayer does convolutions (so weight sharing spatially)
 367 |   // putting them together in one file because they are very similar
 368 |   var ConvLayer = function(opt) {
 369 |     var opt = opt || {};
 370 | 
 371 |     // required
 372 |     this.out_depth = opt.filters;
 373 |     this.sx = opt.sx; // filter size. Should be odd if possible, it's cleaner.
 374 |     this.in_depth = opt.in_depth;
 375 |     this.in_sx = opt.in_sx;
 376 |     this.in_sy = opt.in_sy;
 377 | 
 378 |     // optional
 379 |     this.sy = typeof opt.sy !== 'undefined' ? opt.sy : this.sx;
 380 |     this.stride = typeof opt.stride !== 'undefined' ? opt.stride : 1; // stride at which we apply filters to input volume
 381 |     this.pad = typeof opt.pad !== 'undefined' ? opt.pad : 0; // amount of 0 padding to add around borders of input volume
 382 |     this.l1_decay_mul = typeof opt.l1_decay_mul !== 'undefined' ? opt.l1_decay_mul : 0.0;
 383 |     this.l2_decay_mul = typeof opt.l2_decay_mul !== 'undefined' ? opt.l2_decay_mul : 1.0;
 384 | 
 385 |     // computed
 386 |     // note we are doing floor, so if the strided convolution of the filter doesnt fit into the input
 387 |     // volume exactly, the output volume will be trimmed and not contain the (incomplete) computed
 388 |     // final application.
 389 |     this.out_sx = Math.floor((this.in_sx + this.pad * 2 - this.sx) / this.stride + 1);
 390 |     this.out_sy = Math.floor((this.in_sy + this.pad * 2 - this.sy) / this.stride + 1);
 391 |     this.layer_type = 'conv';
 392 | 
 393 |     // initializations
 394 |     var bias = typeof opt.bias_pref !== 'undefined' ? opt.bias_pref : 0.0;
 395 |     this.filters = [];
 396 |     for(var i=0;i<this.out_depth;i++) { this.filters.push(new Vol(this.sx, this.sy, this.in_depth)); }
 397 |     this.biases = new Vol(1, 1, this.out_depth, bias);
 398 |   }
 399 |   ConvLayer.prototype = {
 400 |     forward: function(V, is_training) {
 401 |       // optimized code by @mdda that achieves 2x speedup over previous version
 402 | 
 403 |       this.in_act = V;
 404 |       var A = new Vol(this.out_sx |0, this.out_sy |0, this.out_depth |0, 0.0);
 405 | 
 406 |       var V_sx = V.sx |0;
 407 |       var V_sy = V.sy |0;
 408 |       var xy_stride = this.stride |0;
 409 | 
 410 |       for(var d=0;d<this.out_depth;d++) {
 411 |         var f = this.filters[d];
 412 |         var x = -this.pad |0;
 413 |         var y = -this.pad |0;
 414 |         for(var ay=0; ay<this.out_sy; y+=xy_stride,ay++) {  // xy_stride
 415 |           x = -this.pad |0;
 416 |           for(var ax=0; ax<this.out_sx; x+=xy_stride,ax++) {  // xy_stride
 417 | 
 418 |             // convolve centered at this particular location
 419 |             var a = 0.0;
 420 |             for(var fy=0;fy<f.sy;fy++) {
 421 |               var oy = y+fy; // coordinates in the original input array coordinates
 422 |               for(var fx=0;fx<f.sx;fx++) {
 423 |                 var ox = x+fx;
 424 |                 if(oy>=0 && oy<V_sy && ox>=0 && ox<V_sx) {
 425 |                   for(var fd=0;fd<f.depth;fd++) {
 426 |                     // avoid function call overhead (x2) for efficiency, compromise modularity :(
 427 |                     a += f.w[((f.sx * fy)+fx)*f.depth+fd] * V.w[((V_sx * oy)+ox)*V.depth+fd];
 428 |                   }
 429 |                 }
 430 |               }
 431 |             }
 432 |             a += this.biases.w[d];
 433 |             A.set(ax, ay, d, a);
 434 |           }
 435 |         }
 436 |       }
 437 |       this.out_act = A;
 438 |       return this.out_act;
 439 |     },
 440 |     backward: function() {
 441 | 
 442 |       var V = this.in_act;
 443 |       V.dw = global.zeros(V.w.length); // zero out gradient wrt bottom data, we're about to fill it
 444 | 
 445 |       var V_sx = V.sx |0;
 446 |       var V_sy = V.sy |0;
 447 |       var xy_stride = this.stride |0;
 448 | 
 449 |       for(var d=0;d<this.out_depth;d++) {
 450 |         var f = this.filters[d];
 451 |         var x = -this.pad |0;
 452 |         var y = -this.pad |0;
 453 |         for(var ay=0; ay<this.out_sy; y+=xy_stride,ay++) {  // xy_stride
 454 |           x = -this.pad |0;
 455 |           for(var ax=0; ax<this.out_sx; x+=xy_stride,ax++) {  // xy_stride
 456 | 
 457 |             // convolve centered at this particular location
 458 |             var chain_grad = this.out_act.get_grad(ax,ay,d); // gradient from above, from chain rule
 459 |             for(var fy=0;fy<f.sy;fy++) {
 460 |               var oy = y+fy; // coordinates in the original input array coordinates
 461 |               for(var fx=0;fx<f.sx;fx++) {
 462 |                 var ox = x+fx;
 463 |                 if(oy>=0 && oy<V_sy && ox>=0 && ox<V_sx) {
 464 |                   for(var fd=0;fd<f.depth;fd++) {
 465 |                     // avoid function call overhead (x2) for efficiency, compromise modularity :(
 466 |                     var ix1 = ((V_sx * oy)+ox)*V.depth+fd;
 467 |                     var ix2 = ((f.sx * fy)+fx)*f.depth+fd;
 468 |                     f.dw[ix2] += V.w[ix1]*chain_grad;
 469 |                     V.dw[ix1] += f.w[ix2]*chain_grad;
 470 |                   }
 471 |                 }
 472 |               }
 473 |             }
 474 |             this.biases.dw[d] += chain_grad;
 475 |           }
 476 |         }
 477 |       }
 478 |     },
 479 |     getParamsAndGrads: function() {
 480 |       var response = [];
 481 |       for(var i=0;i<this.out_depth;i++) {
 482 |         response.push({params: this.filters[i].w, grads: this.filters[i].dw, l2_decay_mul: this.l2_decay_mul, l1_decay_mul: this.l1_decay_mul});
 483 |       }
 484 |       response.push({params: this.biases.w, grads: this.biases.dw, l1_decay_mul: 0.0, l2_decay_mul: 0.0});
 485 |       return response;
 486 |     },
 487 |     toJSON: function() {
 488 |       var json = {};
 489 |       json.sx = this.sx; // filter size in x, y dims
 490 |       json.sy = this.sy;
 491 |       json.stride = this.stride;
 492 |       json.in_depth = this.in_depth;
 493 |       json.out_depth = this.out_depth;
 494 |       json.out_sx = this.out_sx;
 495 |       json.out_sy = this.out_sy;
 496 |       json.layer_type = this.layer_type;
 497 |       json.l1_decay_mul = this.l1_decay_mul;
 498 |       json.l2_decay_mul = this.l2_decay_mul;
 499 |       json.pad = this.pad;
 500 |       json.filters = [];
 501 |       for(var i=0;i<this.filters.length;i++) {
 502 |         json.filters.push(this.filters[i].toJSON());
 503 |       }
 504 |       json.biases = this.biases.toJSON();
 505 |       return json;
 506 |     },
 507 |     fromJSON: function(json) {
 508 |       this.out_depth = json.out_depth;
 509 |       this.out_sx = json.out_sx;
 510 |       this.out_sy = json.out_sy;
 511 |       this.layer_type = json.layer_type;
 512 |       this.sx = json.sx; // filter size in x, y dims
 513 |       this.sy = json.sy;
 514 |       this.stride = json.stride;
 515 |       this.in_depth = json.in_depth; // depth of input volume
 516 |       this.filters = [];
 517 |       this.l1_decay_mul = typeof json.l1_decay_mul !== 'undefined' ? json.l1_decay_mul : 1.0;
 518 |       this.l2_decay_mul = typeof json.l2_decay_mul !== 'undefined' ? json.l2_decay_mul : 1.0;
 519 |       this.pad = typeof json.pad !== 'undefined' ? json.pad : 0;
 520 |       for(var i=0;i<json.filters.length;i++) {
 521 |         var v = new Vol(0,0,0,0);
 522 |         v.fromJSON(json.filters[i]);
 523 |         this.filters.push(v);
 524 |       }
 525 |       this.biases = new Vol(0,0,0,0);
 526 |       this.biases.fromJSON(json.biases);
 527 |     }
 528 |   }
 529 | 
 530 |   var FullyConnLayer = function(opt) {
 531 |     var opt = opt || {};
 532 | 
 533 |     // required
 534 |     // ok fine we will allow 'filters' as the word as well
 535 |     this.out_depth = typeof opt.num_neurons !== 'undefined' ? opt.num_neurons : opt.filters;
 536 | 
 537 |     // optional
 538 |     this.l1_decay_mul = typeof opt.l1_decay_mul !== 'undefined' ? opt.l1_decay_mul : 0.0;
 539 |     this.l2_decay_mul = typeof opt.l2_decay_mul !== 'undefined' ? opt.l2_decay_mul : 1.0;
 540 | 
 541 |     // computed
 542 |     this.num_inputs = opt.in_sx * opt.in_sy * opt.in_depth;
 543 |     this.out_sx = 1;
 544 |     this.out_sy = 1;
 545 |     this.layer_type = 'fc';
 546 | 
 547 |     // initializations
 548 |     var bias = typeof opt.bias_pref !== 'undefined' ? opt.bias_pref : 0.0;
 549 |     this.filters = [];
 550 |     for(var i=0;i<this.out_depth ;i++) { this.filters.push(new Vol(1, 1, this.num_inputs)); }
 551 |     this.biases = new Vol(1, 1, this.out_depth, bias);
 552 |   }
 553 | 
 554 |   FullyConnLayer.prototype = {
 555 |     forward: function(V, is_training) {
 556 |       this.in_act = V;
 557 |       var A = new Vol(1, 1, this.out_depth, 0.0);
 558 |       var Vw = V.w;
 559 |       for(var i=0;i<this.out_depth;i++) {
 560 |         var a = 0.0;
 561 |         var wi = this.filters[i].w;
 562 |         for(var d=0;d<this.num_inputs;d++) {
 563 |           a += Vw[d] * wi[d]; // for efficiency use Vols directly for now
 564 |         }
 565 |         a += this.biases.w[i];
 566 |         A.w[i] = a;
 567 |       }
 568 |       this.out_act = A;
 569 |       return this.out_act;
 570 |     },
 571 |     backward: function() {
 572 |       var V = this.in_act;
 573 |       V.dw = global.zeros(V.w.length); // zero out the gradient in input Vol
 574 | 
 575 |       // compute gradient wrt weights and data
 576 |       for(var i=0;i<this.out_depth;i++) {
 577 |         var tfi = this.filters[i];
 578 |         var chain_grad = this.out_act.dw[i];
 579 |         for(var d=0;d<this.num_inputs;d++) {
 580 |           V.dw[d] += tfi.w[d]*chain_grad; // grad wrt input data
 581 |           tfi.dw[d] += V.w[d]*chain_grad; // grad wrt params
 582 |         }
 583 |         this.biases.dw[i] += chain_grad;
 584 |       }
 585 |     },
 586 |     getParamsAndGrads: function() {
 587 |       var response = [];
 588 |       for(var i=0;i<this.out_depth;i++) {
 589 |         response.push({params: this.filters[i].w, grads: this.filters[i].dw, l1_decay_mul: this.l1_decay_mul, l2_decay_mul: this.l2_decay_mul});
 590 |       }
 591 |       response.push({params: this.biases.w, grads: this.biases.dw, l1_decay_mul: 0.0, l2_decay_mul: 0.0});
 592 |       return response;
 593 |     },
 594 |     toJSON: function() {
 595 |       var json = {};
 596 |       json.out_depth = this.out_depth;
 597 |       json.out_sx = this.out_sx;
 598 |       json.out_sy = this.out_sy;
 599 |       json.layer_type = this.layer_type;
 600 |       json.num_inputs = this.num_inputs;
 601 |       json.l1_decay_mul = this.l1_decay_mul;
 602 |       json.l2_decay_mul = this.l2_decay_mul;
 603 |       json.filters = [];
 604 |       for(var i=0;i<this.filters.length;i++) {
 605 |         json.filters.push(this.filters[i].toJSON());
 606 |       }
 607 |       json.biases = this.biases.toJSON();
 608 |       return json;
 609 |     },
 610 |     fromJSON: function(json) {
 611 |       this.out_depth = json.out_depth;
 612 |       this.out_sx = json.out_sx;
 613 |       this.out_sy = json.out_sy;
 614 |       this.layer_type = json.layer_type;
 615 |       this.num_inputs = json.num_inputs;
 616 |       this.l1_decay_mul = typeof json.l1_decay_mul !== 'undefined' ? json.l1_decay_mul : 1.0;
 617 |       this.l2_decay_mul = typeof json.l2_decay_mul !== 'undefined' ? json.l2_decay_mul : 1.0;
 618 |       this.filters = [];
 619 |       for(var i=0;i<json.filters.length;i++) {
 620 |         var v = new Vol(0,0,0,0);
 621 |         v.fromJSON(json.filters[i]);
 622 |         this.filters.push(v);
 623 |       }
 624 |       this.biases = new Vol(0,0,0,0);
 625 |       this.biases.fromJSON(json.biases);
 626 |     }
 627 |   }
 628 | 
 629 |   global.ConvLayer = ConvLayer;
 630 |   global.FullyConnLayer = FullyConnLayer;
 631 | 
 632 | })(convnetjs);
 633 | (function(global) {
 634 |   "use strict";
 635 |   var Vol = global.Vol; // convenience
 636 | 
 637 |   var PoolLayer = function(opt) {
 638 | 
 639 |     var opt = opt || {};
 640 | 
 641 |     // required
 642 |     this.sx = opt.sx; // filter size
 643 |     this.in_depth = opt.in_depth;
 644 |     this.in_sx = opt.in_sx;
 645 |     this.in_sy = opt.in_sy;
 646 | 
 647 |     // optional
 648 |     this.sy = typeof opt.sy !== 'undefined' ? opt.sy : this.sx;
 649 |     this.stride = typeof opt.stride !== 'undefined' ? opt.stride : 2;
 650 |     this.pad = typeof opt.pad !== 'undefined' ? opt.pad : 0; // amount of 0 padding to add around borders of input volume
 651 | 
 652 |     // computed
 653 |     this.out_depth = this.in_depth;
 654 |     this.out_sx = Math.floor((this.in_sx + this.pad * 2 - this.sx) / this.stride + 1);
 655 |     this.out_sy = Math.floor((this.in_sy + this.pad * 2 - this.sy) / this.stride + 1);
 656 |     this.layer_type = 'pool';
 657 |     // store switches for x,y coordinates for where the max comes from, for each output neuron
 658 |     this.switchx = global.zeros(this.out_sx*this.out_sy*this.out_depth);
 659 |     this.switchy = global.zeros(this.out_sx*this.out_sy*this.out_depth);
 660 |   }
 661 | 
 662 |   PoolLayer.prototype = {
 663 |     forward: function(V, is_training) {
 664 |       this.in_act = V;
 665 | 
 666 |       var A = new Vol(this.out_sx, this.out_sy, this.out_depth, 0.0);
 667 | 
 668 |       var n=0; // a counter for switches
 669 |       for(var d=0;d<this.out_depth;d++) {
 670 |         var x = -this.pad;
 671 |         var y = -this.pad;
 672 |         for(var ax=0; ax<this.out_sx; x+=this.stride,ax++) {
 673 |           y = -this.pad;
 674 |           for(var ay=0; ay<this.out_sy; y+=this.stride,ay++) {
 675 | 
 676 |             // convolve centered at this particular location
 677 |             var a = -99999; // hopefully small enough ;\
 678 |             var winx=-1,winy=-1;
 679 |             for(var fx=0;fx<this.sx;fx++) {
 680 |               for(var fy=0;fy<this.sy;fy++) {
 681 |                 var oy = y+fy;
 682 |                 var ox = x+fx;
 683 |                 if(oy>=0 && oy<V.sy && ox>=0 && ox<V.sx) {
 684 |                   var v = V.get(ox, oy, d);
 685 |                   // perform max pooling and store pointers to where
 686 |                   // the max came from. This will speed up backprop
 687 |                   // and can help make nice visualizations in future
 688 |                   if(v > a) { a = v; winx=ox; winy=oy;}
 689 |                 }
 690 |               }
 691 |             }
 692 |             this.switchx[n] = winx;
 693 |             this.switchy[n] = winy;
 694 |             n++;
 695 |             A.set(ax, ay, d, a);
 696 |           }
 697 |         }
 698 |       }
 699 |       this.out_act = A;
 700 |       return this.out_act;
 701 |     },
 702 |     backward: function() {
 703 |       // pooling layers have no parameters, so simply compute
 704 |       // gradient wrt data here
 705 |       var V = this.in_act;
 706 |       V.dw = global.zeros(V.w.length); // zero out gradient wrt data
 707 |       var A = this.out_act; // computed in forward pass
 708 | 
 709 |       var n = 0;
 710 |       for(var d=0;d<this.out_depth;d++) {
 711 |         var x = -this.pad;
 712 |         var y = -this.pad;
 713 |         for(var ax=0; ax<this.out_sx; x+=this.stride,ax++) {
 714 |           y = -this.pad;
 715 |           for(var ay=0; ay<this.out_sy; y+=this.stride,ay++) {
 716 | 
 717 |             var chain_grad = this.out_act.get_grad(ax,ay,d);
 718 |             V.add_grad(this.switchx[n], this.switchy[n], d, chain_grad);
 719 |             n++;
 720 | 
 721 |           }
 722 |         }
 723 |       }
 724 |     },
 725 |     getParamsAndGrads: function() {
 726 |       return [];
 727 |     },
 728 |     toJSON: function() {
 729 |       var json = {};
 730 |       json.sx = this.sx;
 731 |       json.sy = this.sy;
 732 |       json.stride = this.stride;
 733 |       json.in_depth = this.in_depth;
 734 |       json.out_depth = this.out_depth;
 735 |       json.out_sx = this.out_sx;
 736 |       json.out_sy = this.out_sy;
 737 |       json.layer_type = this.layer_type;
 738 |       json.pad = this.pad;
 739 |       return json;
 740 |     },
 741 |     fromJSON: function(json) {
 742 |       this.out_depth = json.out_depth;
 743 |       this.out_sx = json.out_sx;
 744 |       this.out_sy = json.out_sy;
 745 |       this.layer_type = json.layer_type;
 746 |       this.sx = json.sx;
 747 |       this.sy = json.sy;
 748 |       this.stride = json.stride;
 749 |       this.in_depth = json.in_depth;
 750 |       this.pad = typeof json.pad !== 'undefined' ? json.pad : 0; // backwards compatibility
 751 |       this.switchx = global.zeros(this.out_sx*this.out_sy*this.out_depth); // need to re-init these appropriately
 752 |       this.switchy = global.zeros(this.out_sx*this.out_sy*this.out_depth);
 753 |     }
 754 |   }
 755 | 
 756 |   global.PoolLayer = PoolLayer;
 757 | 
 758 | })(convnetjs);
 759 | 
 760 | (function(global) {
 761 |   "use strict";
 762 |   var Vol = global.Vol; // convenience
 763 |   var getopt = global.getopt;
 764 | 
 765 |   var InputLayer = function(opt) {
 766 |     var opt = opt || {};
 767 | 
 768 |     // required: depth
 769 |     this.out_depth = getopt(opt, ['out_depth', 'depth'], 0);
 770 | 
 771 |     // optional: default these dimensions to 1
 772 |     this.out_sx = getopt(opt, ['out_sx', 'sx', 'width'], 1);
 773 |     this.out_sy = getopt(opt, ['out_sy', 'sy', 'height'], 1);
 774 | 
 775 |     // computed
 776 |     this.layer_type = 'input';
 777 |   }
 778 |   InputLayer.prototype = {
 779 |     forward: function(V, is_training) {
 780 |       this.in_act = V;
 781 |       this.out_act = V;
 782 |       return this.out_act; // simply identity function for now
 783 |     },
 784 |     backward: function() { },
 785 |     getParamsAndGrads: function() {
 786 |       return [];
 787 |     },
 788 |     toJSON: function() {
 789 |       var json = {};
 790 |       json.out_depth = this.out_depth;
 791 |       json.out_sx = this.out_sx;
 792 |       json.out_sy = this.out_sy;
 793 |       json.layer_type = this.layer_type;
 794 |       return json;
 795 |     },
 796 |     fromJSON: function(json) {
 797 |       this.out_depth = json.out_depth;
 798 |       this.out_sx = json.out_sx;
 799 |       this.out_sy = json.out_sy;
 800 |       this.layer_type = json.layer_type;
 801 |     }
 802 |   }
 803 | 
 804 |   global.InputLayer = InputLayer;
 805 | })(convnetjs);
 806 | (function(global) {
 807 |   "use strict";
 808 |   var Vol = global.Vol; // convenience
 809 | 
 810 |   // Layers that implement a loss. Currently these are the layers that
 811 |   // can initiate a backward() pass. In future we probably want a more
 812 |   // flexible system that can accomodate multiple losses to do multi-task
 813 |   // learning, and stuff like that. But for now, one of the layers in this
 814 |   // file must be the final layer in a Net.
 815 | 
 816 |   // This is a classifier, with N discrete classes from 0 to N-1
 817 |   // it gets a stream of N incoming numbers and computes the softmax
 818 |   // function (exponentiate and normalize to sum to 1 as probabilities should)
 819 |   var SoftmaxLayer = function(opt) {
 820 |     var opt = opt || {};
 821 | 
 822 |     // computed
 823 |     this.num_inputs = opt.in_sx * opt.in_sy * opt.in_depth;
 824 |     this.out_depth = this.num_inputs;
 825 |     this.out_sx = 1;
 826 |     this.out_sy = 1;
 827 |     this.layer_type = 'softmax';
 828 |   }
 829 | 
 830 |   SoftmaxLayer.prototype = {
 831 |     forward: function(V, is_training) {
 832 |       this.in_act = V;
 833 | 
 834 |       var A = new Vol(1, 1, this.out_depth, 0.0);
 835 | 
 836 |       // compute max activation
 837 |       var as = V.w;
 838 |       var amax = V.w[0];
 839 |       for(var i=1;i<this.out_depth;i++) {
 840 |         if(as[i] > amax) amax = as[i];
 841 |       }
 842 | 
 843 |       // compute exponentials (carefully to not blow up)
 844 |       var es = global.zeros(this.out_depth);
 845 |       var esum = 0.0;
 846 |       for(var i=0;i<this.out_depth;i++) {
 847 |         var e = Math.exp(as[i] - amax);
 848 |         esum += e;
 849 |         es[i] = e;
 850 |       }
 851 | 
 852 |       // normalize and output to sum to one
 853 |       for(var i=0;i<this.out_depth;i++) {
 854 |         es[i] /= esum;
 855 |         A.w[i] = es[i];
 856 |       }
 857 | 
 858 |       this.es = es; // save these for backprop
 859 |       this.out_act = A;
 860 |       return this.out_act;
 861 |     },
 862 |     backward: function(y) {
 863 | 
 864 |       // compute and accumulate gradient wrt weights and bias of this layer
 865 |       var x = this.in_act;
 866 |       x.dw = global.zeros(x.w.length); // zero out the gradient of input Vol
 867 | 
 868 |       for(var i=0;i<this.out_depth;i++) {
 869 |         var indicator = i === y ? 1.0 : 0.0;
 870 |         var mul = -(indicator - this.es[i]);
 871 |         x.dw[i] = mul;
 872 |       }
 873 | 
 874 |       // loss is the class negative log likelihood
 875 |       return -Math.log(this.es[y]);
 876 |     },
 877 |     getParamsAndGrads: function() {
 878 |       return [];
 879 |     },
 880 |     toJSON: function() {
 881 |       var json = {};
 882 |       json.out_depth = this.out_depth;
 883 |       json.out_sx = this.out_sx;
 884 |       json.out_sy = this.out_sy;
 885 |       json.layer_type = this.layer_type;
 886 |       json.num_inputs = this.num_inputs;
 887 |       return json;
 888 |     },
 889 |     fromJSON: function(json) {
 890 |       this.out_depth = json.out_depth;
 891 |       this.out_sx = json.out_sx;
 892 |       this.out_sy = json.out_sy;
 893 |       this.layer_type = json.layer_type;
 894 |       this.num_inputs = json.num_inputs;
 895 |     }
 896 |   }
 897 | 
 898 |   // implements an L2 regression cost layer,
 899 |   // so penalizes \sum_i(||x_i - y_i||^2), where x is its input
 900 |   // and y is the user-provided array of "correct" values.
 901 |   var RegressionLayer = function(opt) {
 902 |     var opt = opt || {};
 903 | 
 904 |     // computed
 905 |     this.num_inputs = opt.in_sx * opt.in_sy * opt.in_depth;
 906 |     this.out_depth = this.num_inputs;
 907 |     this.out_sx = 1;
 908 |     this.out_sy = 1;
 909 |     this.layer_type = 'regression';
 910 |   }
 911 | 
 912 |   RegressionLayer.prototype = {
 913 |     forward: function(V, is_training) {
 914 |       this.in_act = V;
 915 |       this.out_act = V;
 916 |       return V; // identity function
 917 |     },
 918 |     // y is a list here of size num_inputs
 919 |     // or it can be a number if only one value is regressed
 920 |     // or it can be a struct {dim: i, val: x} where we only want to
 921 |     // regress on dimension i and asking it to have value x
 922 |     backward: function(y) {
 923 | 
 924 |       // compute and accumulate gradient wrt weights and bias of this layer
 925 |       var x = this.in_act;
 926 |       x.dw = global.zeros(x.w.length); // zero out the gradient of input Vol
 927 |       var loss = 0.0;
 928 |       if(y instanceof Array || y instanceof Float64Array) {
 929 |         for(var i=0;i<this.out_depth;i++) {
 930 |           var dy = x.w[i] - y[i];
 931 |           x.dw[i] = dy;
 932 |           loss += 0.5*dy*dy;
 933 |         }
 934 |       } else if(typeof y === 'number') {
 935 |         // lets hope that only one number is being regressed
 936 |         var dy = x.w[0] - y;
 937 |         x.dw[0] = dy;
 938 |         loss += 0.5*dy*dy;
 939 |       } else {
 940 |         // assume it is a struct with entries .dim and .val
 941 |         // and we pass gradient only along dimension dim to be equal to val
 942 |         var i = y.dim;
 943 |         var yi = y.val;
 944 |         var dy = x.w[i] - yi;
 945 |         x.dw[i] = dy;
 946 |         loss += 0.5*dy*dy;
 947 |       }
 948 |       return loss;
 949 |     },
 950 |     getParamsAndGrads: function() {
 951 |       return [];
 952 |     },
 953 |     toJSON: function() {
 954 |       var json = {};
 955 |       json.out_depth = this.out_depth;
 956 |       json.out_sx = this.out_sx;
 957 |       json.out_sy = this.out_sy;
 958 |       json.layer_type = this.layer_type;
 959 |       json.num_inputs = this.num_inputs;
 960 |       return json;
 961 |     },
 962 |     fromJSON: function(json) {
 963 |       this.out_depth = json.out_depth;
 964 |       this.out_sx = json.out_sx;
 965 |       this.out_sy = json.out_sy;
 966 |       this.layer_type = json.layer_type;
 967 |       this.num_inputs = json.num_inputs;
 968 |     }
 969 |   }
 970 | 
 971 |   var SVMLayer = function(opt) {
 972 |     var opt = opt || {};
 973 | 
 974 |     // computed
 975 |     this.num_inputs = opt.in_sx * opt.in_sy * opt.in_depth;
 976 |     this.out_depth = this.num_inputs;
 977 |     this.out_sx = 1;
 978 |     this.out_sy = 1;
 979 |     this.layer_type = 'svm';
 980 |   }
 981 | 
 982 |   SVMLayer.prototype = {
 983 |     forward: function(V, is_training) {
 984 |       this.in_act = V;
 985 |       this.out_act = V; // nothing to do, output raw scores
 986 |       return V;
 987 |     },
 988 |     backward: function(y) {
 989 | 
 990 |       // compute and accumulate gradient wrt weights and bias of this layer
 991 |       var x = this.in_act;
 992 |       x.dw = global.zeros(x.w.length); // zero out the gradient of input Vol
 993 | 
 994 |       // we're using structured loss here, which means that the score
 995 |       // of the ground truth should be higher than the score of any other
 996 |       // class, by a margin
 997 |       var yscore = x.w[y]; // score of ground truth
 998 |       var margin = 1.0;
 999 |       var loss = 0.0;
1000 |       for(var i=0;i<this.out_depth;i++) {
1001 |         if(y === i) { continue; }
1002 |         var ydiff = -yscore + x.w[i] + margin;
1003 |         if(ydiff > 0) {
1004 |           // violating dimension, apply loss
1005 |           x.dw[i] += 1;
1006 |           x.dw[y] -= 1;
1007 |           loss += ydiff;
1008 |         }
1009 |       }
1010 | 
1011 |       return loss;
1012 |     },
1013 |     getParamsAndGrads: function() {
1014 |       return [];
1015 |     },
1016 |     toJSON: function() {
1017 |       var json = {};
1018 |       json.out_depth = this.out_depth;
1019 |       json.out_sx = this.out_sx;
1020 |       json.out_sy = this.out_sy;
1021 |       json.layer_type = this.layer_type;
1022 |       json.num_inputs = this.num_inputs;
1023 |       return json;
1024 |     },
1025 |     fromJSON: function(json) {
1026 |       this.out_depth = json.out_depth;
1027 |       this.out_sx = json.out_sx;
1028 |       this.out_sy = json.out_sy;
1029 |       this.layer_type = json.layer_type;
1030 |       this.num_inputs = json.num_inputs;
1031 |     }
1032 |   }
1033 | 
1034 |   global.RegressionLayer = RegressionLayer;
1035 |   global.SoftmaxLayer = SoftmaxLayer;
1036 |   global.SVMLayer = SVMLayer;
1037 | 
1038 | })(convnetjs);
1039 | 
1040 | (function(global) {
1041 |   "use strict";
1042 |   var Vol = global.Vol; // convenience
1043 | 
1044 |   // Implements ReLU nonlinearity elementwise
1045 |   // x -> max(0, x)
1046 |   // the output is in [0, inf)
1047 |   var ReluLayer = function(opt) {
1048 |     var opt = opt || {};
1049 | 
1050 |     // computed
1051 |     this.out_sx = opt.in_sx;
1052 |     this.out_sy = opt.in_sy;
1053 |     this.out_depth = opt.in_depth;
1054 |     this.layer_type = 'relu';
1055 |   }
1056 |   ReluLayer.prototype = {
1057 |     forward: function(V, is_training) {
1058 |       this.in_act = V;
1059 |       var V2 = V.clone();
1060 |       var N = V.w.length;
1061 |       var V2w = V2.w;
1062 |       for(var i=0;i<N;i++) {
1063 |         if(V2w[i] < 0) V2w[i] = 0; // threshold at 0
1064 |       }
1065 |       this.out_act = V2;
1066 |       return this.out_act;
1067 |     },
1068 |     backward: function() {
1069 |       var V = this.in_act; // we need to set dw of this
1070 |       var V2 = this.out_act;
1071 |       var N = V.w.length;
1072 |       V.dw = global.zeros(N); // zero out gradient wrt data
1073 |       for(var i=0;i<N;i++) {
1074 |         if(V2.w[i] <= 0) V.dw[i] = 0; // threshold
1075 |         else V.dw[i] = V2.dw[i];
1076 |       }
1077 |     },
1078 |     getParamsAndGrads: function() {
1079 |       return [];
1080 |     },
1081 |     toJSON: function() {
1082 |       var json = {};
1083 |       json.out_depth = this.out_depth;
1084 |       json.out_sx = this.out_sx;
1085 |       json.out_sy = this.out_sy;
1086 |       json.layer_type = this.layer_type;
1087 |       return json;
1088 |     },
1089 |     fromJSON: function(json) {
1090 |       this.out_depth = json.out_depth;
1091 |       this.out_sx = json.out_sx;
1092 |       this.out_sy = json.out_sy;
1093 |       this.layer_type = json.layer_type;
1094 |     }
1095 |   }
1096 | 
1097 |   // Implements Sigmoid nnonlinearity elementwise
1098 |   // x -> 1/(1+e^(-x))
1099 |   // so the output is between 0 and 1.
1100 |   var SigmoidLayer = function(opt) {
1101 |     var opt = opt || {};
1102 | 
1103 |     // computed
1104 |     this.out_sx = opt.in_sx;
1105 |     this.out_sy = opt.in_sy;
1106 |     this.out_depth = opt.in_depth;
1107 |     this.layer_type = 'sigmoid';
1108 |   }
1109 |   SigmoidLayer.prototype = {
1110 |     forward: function(V, is_training) {
1111 |       this.in_act = V;
1112 |       var V2 = V.cloneAndZero();
1113 |       var N = V.w.length;
1114 |       var V2w = V2.w;
1115 |       var Vw = V.w;
1116 |       for(var i=0;i<N;i++) {
1117 |         V2w[i] = 1.0/(1.0+Math.exp(-Vw[i]));
1118 |       }
1119 |       this.out_act = V2;
1120 |       return this.out_act;
1121 |     },
1122 |     backward: function() {
1123 |       var V = this.in_act; // we need to set dw of this
1124 |       var V2 = this.out_act;
1125 |       var N = V.w.length;
1126 |       V.dw = global.zeros(N); // zero out gradient wrt data
1127 |       for(var i=0;i<N;i++) {
1128 |         var v2wi = V2.w[i];
1129 |         V.dw[i] =  v2wi * (1.0 - v2wi) * V2.dw[i];
1130 |       }
1131 |     },
1132 |     getParamsAndGrads: function() {
1133 |       return [];
1134 |     },
1135 |     toJSON: function() {
1136 |       var json = {};
1137 |       json.out_depth = this.out_depth;
1138 |       json.out_sx = this.out_sx;
1139 |       json.out_sy = this.out_sy;
1140 |       json.layer_type = this.layer_type;
1141 |       return json;
1142 |     },
1143 |     fromJSON: function(json) {
1144 |       this.out_depth = json.out_depth;
1145 |       this.out_sx = json.out_sx;
1146 |       this.out_sy = json.out_sy;
1147 |       this.layer_type = json.layer_type;
1148 |     }
1149 |   }
1150 | 
1151 |   // Implements Maxout nnonlinearity that computes
1152 |   // x -> max(x)
1153 |   // where x is a vector of size group_size. Ideally of course,
1154 |   // the input size should be exactly divisible by group_size
1155 |   var MaxoutLayer = function(opt) {
1156 |     var opt = opt || {};
1157 | 
1158 |     // required
1159 |     this.group_size = typeof opt.group_size !== 'undefined' ? opt.group_size : 2;
1160 | 
1161 |     // computed
1162 |     this.out_sx = opt.in_sx;
1163 |     this.out_sy = opt.in_sy;
1164 |     this.out_depth = Math.floor(opt.in_depth / this.group_size);
1165 |     this.layer_type = 'maxout';
1166 | 
1167 |     this.switches = global.zeros(this.out_sx*this.out_sy*this.out_depth); // useful for backprop
1168 |   }
1169 |   MaxoutLayer.prototype = {
1170 |     forward: function(V, is_training) {
1171 |       this.in_act = V;
1172 |       var N = this.out_depth;
1173 |       var V2 = new Vol(this.out_sx, this.out_sy, this.out_depth, 0.0);
1174 | 
1175 |       // optimization branch. If we're operating on 1D arrays we dont have
1176 |       // to worry about keeping track of x,y,d coordinates inside
1177 |       // input volumes. In convnets we do :(
1178 |       if(this.out_sx === 1 && this.out_sy === 1) {
1179 |         for(var i=0;i<N;i++) {
1180 |           var ix = i * this.group_size; // base index offset
1181 |           var a = V.w[ix];
1182 |           var ai = 0;
1183 |           for(var j=1;j<this.group_size;j++) {
1184 |             var a2 = V.w[ix+j];
1185 |             if(a2 > a) {
1186 |               a = a2;
1187 |               ai = j;
1188 |             }
1189 |           }
1190 |           V2.w[i] = a;
1191 |           this.switches[i] = ix + ai;
1192 |         }
1193 |       } else {
1194 |         var n=0; // counter for switches
1195 |         for(var x=0;x<V.sx;x++) {
1196 |           for(var y=0;y<V.sy;y++) {
1197 |             for(var i=0;i<N;i++) {
1198 |               var ix = i * this.group_size;
1199 |               var a = V.get(x, y, ix);
1200 |               var ai = 0;
1201 |               for(var j=1;j<this.group_size;j++) {
1202 |                 var a2 = V.get(x, y, ix+j);
1203 |                 if(a2 > a) {
1204 |                   a = a2;
1205 |                   ai = j;
1206 |                 }
1207 |               }
1208 |               V2.set(x,y,i,a);
1209 |               this.switches[n] = ix + ai;
1210 |               n++;
1211 |             }
1212 |           }
1213 |         }
1214 | 
1215 |       }
1216 |       this.out_act = V2;
1217 |       return this.out_act;
1218 |     },
1219 |     backward: function() {
1220 |       var V = this.in_act; // we need to set dw of this
1221 |       var V2 = this.out_act;
1222 |       var N = this.out_depth;
1223 |       V.dw = global.zeros(V.w.length); // zero out gradient wrt data
1224 | 
1225 |       // pass the gradient through the appropriate switch
1226 |       if(this.out_sx === 1 && this.out_sy === 1) {
1227 |         for(var i=0;i<N;i++) {
1228 |           var chain_grad = V2.dw[i];
1229 |           V.dw[this.switches[i]] = chain_grad;
1230 |         }
1231 |       } else {
1232 |         // bleh okay, lets do this the hard way
1233 |         var n=0; // counter for switches
1234 |         for(var x=0;x<V2.sx;x++) {
1235 |           for(var y=0;y<V2.sy;y++) {
1236 |             for(var i=0;i<N;i++) {
1237 |               var chain_grad = V2.get_grad(x,y,i);
1238 |               V.set_grad(x,y,this.switches[n],chain_grad);
1239 |               n++;
1240 |             }
1241 |           }
1242 |         }
1243 |       }
1244 |     },
1245 |     getParamsAndGrads: function() {
1246 |       return [];
1247 |     },
1248 |     toJSON: function() {
1249 |       var json = {};
1250 |       json.out_depth = this.out_depth;
1251 |       json.out_sx = this.out_sx;
1252 |       json.out_sy = this.out_sy;
1253 |       json.layer_type = this.layer_type;
1254 |       json.group_size = this.group_size;
1255 |       return json;
1256 |     },
1257 |     fromJSON: function(json) {
1258 |       this.out_depth = json.out_depth;
1259 |       this.out_sx = json.out_sx;
1260 |       this.out_sy = json.out_sy;
1261 |       this.layer_type = json.layer_type;
1262 |       this.group_size = json.group_size;
1263 |       this.switches = global.zeros(this.group_size);
1264 |     }
1265 |   }
1266 | 
1267 |   // a helper function, since tanh is not yet part of ECMAScript. Will be in v6.
1268 |   function tanh(x) {
1269 |     var y = Math.exp(2 * x);
1270 |     return (y - 1) / (y + 1);
1271 |   }
1272 |   // Implements Tanh nnonlinearity elementwise
1273 |   // x -> tanh(x)
1274 |   // so the output is between -1 and 1.
1275 |   var TanhLayer = function(opt) {
1276 |     var opt = opt || {};
1277 | 
1278 |     // computed
1279 |     this.out_sx = opt.in_sx;
1280 |     this.out_sy = opt.in_sy;
1281 |     this.out_depth = opt.in_depth;
1282 |     this.layer_type = 'tanh';
1283 |   }
1284 |   TanhLayer.prototype = {
1285 |     forward: function(V, is_training) {
1286 |       this.in_act = V;
1287 |       var V2 = V.cloneAndZero();
1288 |       var N = V.w.length;
1289 |       for(var i=0;i<N;i++) {
1290 |         V2.w[i] = tanh(V.w[i]);
1291 |       }
1292 |       this.out_act = V2;
1293 |       return this.out_act;
1294 |     },
1295 |     backward: function() {
1296 |       var V = this.in_act; // we need to set dw of this
1297 |       var V2 = this.out_act;
1298 |       var N = V.w.length;
1299 |       V.dw = global.zeros(N); // zero out gradient wrt data
1300 |       for(var i=0;i<N;i++) {
1301 |         var v2wi = V2.w[i];
1302 |         V.dw[i] = (1.0 - v2wi * v2wi) * V2.dw[i];
1303 |       }
1304 |     },
1305 |     getParamsAndGrads: function() {
1306 |       return [];
1307 |     },
1308 |     toJSON: function() {
1309 |       var json = {};
1310 |       json.out_depth = this.out_depth;
1311 |       json.out_sx = this.out_sx;
1312 |       json.out_sy = this.out_sy;
1313 |       json.layer_type = this.layer_type;
1314 |       return json;
1315 |     },
1316 |     fromJSON: function(json) {
1317 |       this.out_depth = json.out_depth;
1318 |       this.out_sx = json.out_sx;
1319 |       this.out_sy = json.out_sy;
1320 |       this.layer_type = json.layer_type;
1321 |     }
1322 |   }
1323 | 
1324 |   global.TanhLayer = TanhLayer;
1325 |   global.MaxoutLayer = MaxoutLayer;
1326 |   global.ReluLayer = ReluLayer;
1327 |   global.SigmoidLayer = SigmoidLayer;
1328 | 
1329 | })(convnetjs);
1330 | 
1331 | (function(global) {
1332 |   "use strict";
1333 |   var Vol = global.Vol; // convenience
1334 | 
1335 |   // An inefficient dropout layer
1336 |   // Note this is not most efficient implementation since the layer before
1337 |   // computed all these activations and now we're just going to drop them :(
1338 |   // same goes for backward pass. Also, if we wanted to be efficient at test time
1339 |   // we could equivalently be clever and upscale during train and copy pointers during test
1340 |   // todo: make more efficient.
1341 |   var DropoutLayer = function(opt) {
1342 |     var opt = opt || {};
1343 | 
1344 |     // computed
1345 |     this.out_sx = opt.in_sx;
1346 |     this.out_sy = opt.in_sy;
1347 |     this.out_depth = opt.in_depth;
1348 |     this.layer_type = 'dropout';
1349 |     this.drop_prob = typeof opt.drop_prob !== 'undefined' ? opt.drop_prob : 0.5;
1350 |     this.dropped = global.zeros(this.out_sx*this.out_sy*this.out_depth);
1351 |   }
1352 |   DropoutLayer.prototype = {
1353 |     forward: function(V, is_training) {
1354 |       this.in_act = V;
1355 |       //if(typeof(is_training)==='undefined') { is_training = false; } // default is prediction mode
1356 |       var V2 = V.clone();
1357 |       var N = V.w.length;
1358 |       //if(is_training) {
1359 |         // do dropout
1360 |         for(var i=0;i<N;i++) {
1361 |           if(Math.random()<this.drop_prob) { V2.w[i]=0; this.dropped[i] = true; } // drop!
1362 |           else {V2.w[i]/=(1-this.drop_prob); this.dropped[i] = false;}
1363 |         }
1364 |       //}
1365 |       this.out_act = V2;
1366 |       return this.out_act; // dummy identity function for now
1367 |     },
1368 |     backward: function() {
1369 |       var V = this.in_act; // we need to set dw of this
1370 |       var chain_grad = this.out_act;
1371 |       var N = V.w.length;
1372 |       V.dw = global.zeros(N); // zero out gradient wrt data
1373 |       for(var i=0;i<N;i++) {
1374 |         if(!(this.dropped[i])) {
1375 |           V.dw[i] = chain_grad.dw[i]/(1-this.drop_prob); // copy over the gradient
1376 |         }
1377 |       }
1378 |     },
1379 |     getParamsAndGrads: function() {
1380 |       return [];
1381 |     },
1382 |     toJSON: function() {
1383 |       var json = {};
1384 |       json.out_depth = this.out_depth;
1385 |       json.out_sx = this.out_sx;
1386 |       json.out_sy = this.out_sy;
1387 |       json.layer_type = this.layer_type;
1388 |       json.drop_prob = this.drop_prob;
1389 |       return json;
1390 |     },
1391 |     fromJSON: function(json) {
1392 |       this.out_depth = json.out_depth;
1393 |       this.out_sx = json.out_sx;
1394 |       this.out_sy = json.out_sy;
1395 |       this.layer_type = json.layer_type;
1396 |       this.drop_prob = json.drop_prob;
1397 |     }
1398 |   }
1399 | 
1400 | 
1401 |   global.DropoutLayer = DropoutLayer;
1402 | })(convnetjs);
1403 | (function(global) {
1404 |   "use strict";
1405 |   var Vol = global.Vol; // convenience
1406 | 
1407 |   // a bit experimental layer for now. I think it works but I'm not 100%
1408 |   // the gradient check is a bit funky. I'll look into this a bit later.
1409 |   // Local Response Normalization in window, along depths of volumes
1410 |   var LocalResponseNormalizationLayer = function(opt) {
1411 |     var opt = opt || {};
1412 | 
1413 |     // required
1414 |     this.k = opt.k;
1415 |     this.n = opt.n;
1416 |     this.alpha = opt.alpha;
1417 |     this.beta = opt.beta;
1418 | 
1419 |     // computed
1420 |     this.out_sx = opt.in_sx;
1421 |     this.out_sy = opt.in_sy;
1422 |     this.out_depth = opt.in_depth;
1423 |     this.layer_type = 'lrn';
1424 | 
1425 |     // checks
1426 |     if(this.n%2 === 0) { console.log('WARNING n should be odd for LRN layer'); }
1427 |   }
1428 |   LocalResponseNormalizationLayer.prototype = {
1429 |     forward: function(V, is_training) {
1430 |       this.in_act = V;
1431 | 
1432 |       var A = V.cloneAndZero();
1433 |       this.S_cache_ = V.cloneAndZero();
1434 |       var n2 = Math.floor(this.n/2);
1435 |       for(var x=0;x<V.sx;x++) {
1436 |         for(var y=0;y<V.sy;y++) {
1437 |           for(var i=0;i<V.depth;i++) {
1438 | 
1439 |             var ai = V.get(x,y,i);
1440 | 
1441 |             // normalize in a window of size n
1442 |             var den = 0.0;
1443 |             for(var j=Math.max(0,i-n2);j<=Math.min(i+n2,V.depth-1);j++) {
1444 |               var aa = V.get(x,y,j);
1445 |               den += aa*aa;
1446 |             }
1447 |             den *= this.alpha / this.n;
1448 |             den += this.k;
1449 |             this.S_cache_.set(x,y,i,den); // will be useful for backprop
1450 |             den = Math.pow(den, this.beta);
1451 |             A.set(x,y,i,ai/den);
1452 |           }
1453 |         }
1454 |       }
1455 | 
1456 |       this.out_act = A;
1457 |       return this.out_act; // dummy identity function for now
1458 |     },
1459 |     backward: function() {
1460 |       // evaluate gradient wrt data
1461 |       var V = this.in_act; // we need to set dw of this
1462 |       V.dw = global.zeros(V.w.length); // zero out gradient wrt data
1463 |       var A = this.out_act; // computed in forward pass
1464 | 
1465 |       var n2 = Math.floor(this.n/2);
1466 |       for(var x=0;x<V.sx;x++) {
1467 |         for(var y=0;y<V.sy;y++) {
1468 |           for(var i=0;i<V.depth;i++) {
1469 | 
1470 |             var chain_grad = this.out_act.get_grad(x,y,i);
1471 |             var S = this.S_cache_.get(x,y,i);
1472 |             var SB = Math.pow(S, this.beta);
1473 |             var SB2 = SB*SB;
1474 | 
1475 |             // normalize in a window of size n
1476 |             for(var j=Math.max(0,i-n2);j<=Math.min(i+n2,V.depth-1);j++) {
1477 |               var aj = V.get(x,y,j);
1478 |               var g = -aj*this.beta*Math.pow(S,this.beta-1)*this.alpha/this.n*2*aj;
1479 |               if(j===i) g+= SB;
1480 |               g /= SB2;
1481 |               g *= chain_grad;
1482 |               V.add_grad(x,y,j,g);
1483 |             }
1484 | 
1485 |           }
1486 |         }
1487 |       }
1488 |     },
1489 |     getParamsAndGrads: function() { return []; },
1490 |     toJSON: function() {
1491 |       var json = {};
1492 |       json.k = this.k;
1493 |       json.n = this.n;
1494 |       json.alpha = this.alpha; // normalize by size
1495 |       json.beta = this.beta;
1496 |       json.out_sx = this.out_sx;
1497 |       json.out_sy = this.out_sy;
1498 |       json.out_depth = this.out_depth;
1499 |       json.layer_type = this.layer_type;
1500 |       return json;
1501 |     },
1502 |     fromJSON: function(json) {
1503 |       this.k = json.k;
1504 |       this.n = json.n;
1505 |       this.alpha = json.alpha; // normalize by size
1506 |       this.beta = json.beta;
1507 |       this.out_sx = json.out_sx;
1508 |       this.out_sy = json.out_sy;
1509 |       this.out_depth = json.out_depth;
1510 |       this.layer_type = json.layer_type;
1511 |     }
1512 |   }
1513 | 
1514 | 
1515 |   global.LocalResponseNormalizationLayer = LocalResponseNormalizationLayer;
1516 | })(convnetjs);
1517 | (function(global) {
1518 |   "use strict";
1519 |   var Vol = global.Vol; // convenience
1520 |   var assert = global.assert;
1521 | 
1522 |   // Net manages a set of layers
1523 |   // For now constraints: Simple linear order of layers, first layer input last layer a cost layer
1524 |   var Net = function(options) {
1525 |     this.layers = [];
1526 |   }
1527 | 
1528 |   Net.prototype = {
1529 | 
1530 |     // takes a list of layer definitions and creates the network layer objects
1531 |     makeLayers: function(defs) {
1532 | 
1533 |       // few checks
1534 |       assert(defs.length >= 2, 'Error! At least one input layer and one loss layer are required.');
1535 |       assert(defs[0].type === 'input', 'Error! First layer must be the input layer, to declare size of inputs');
1536 | 
1537 |       // desugar layer_defs for adding activation, dropout layers etc
1538 |       var desugar = function() {
1539 |         var new_defs = [];
1540 |         for(var i=0;i<defs.length;i++) {
1541 |           var def = defs[i];
1542 | 
1543 |           if(def.type==='softmax' || def.type==='svm') {
1544 |             // add an fc layer here, there is no reason the user should
1545 |             // have to worry about this and we almost always want to
1546 |             new_defs.push({type:'fc', num_neurons: def.num_classes});
1547 |           }
1548 | 
1549 |           if(def.type==='regression') {
1550 |             // add an fc layer here, there is no reason the user should
1551 |             // have to worry about this and we almost always want to
1552 |             new_defs.push({type:'fc', num_neurons: def.num_neurons});
1553 |           }
1554 | 
1555 |           if((def.type==='fc' || def.type==='conv')
1556 |               && typeof(def.bias_pref) === 'undefined'){
1557 |             def.bias_pref = 0.0;
1558 |             if(typeof def.activation !== 'undefined' && def.activation === 'relu') {
1559 |               def.bias_pref = 0.1; // relus like a bit of positive bias to get gradients early
1560 |               // otherwise it's technically possible that a relu unit will never turn on (by chance)
1561 |               // and will never get any gradient and never contribute any computation. Dead relu.
1562 |             }
1563 |           }
1564 | 
1565 |           new_defs.push(def);
1566 | 
1567 |           if(typeof def.activation !== 'undefined') {
1568 |             if(def.activation==='relu') { new_defs.push({type:'relu'}); }
1569 |             else if (def.activation==='sigmoid') { new_defs.push({type:'sigmoid'}); }
1570 |             else if (def.activation==='tanh') { new_defs.push({type:'tanh'}); }
1571 |             else if (def.activation==='maxout') {
1572 |               // create maxout activation, and pass along group size, if provided
1573 |               var gs = def.group_size !== 'undefined' ? def.group_size : 2;
1574 |               new_defs.push({type:'maxout', group_size:gs});
1575 |             }
1576 |             else { console.log('ERROR unsupported activation ' + def.activation); }
1577 |           }
1578 |           if(typeof def.drop_prob !== 'undefined' && def.type !== 'dropout') {
1579 |             new_defs.push({type:'dropout', drop_prob: def.drop_prob});
1580 |           }
1581 | 
1582 |         }
1583 |         return new_defs;
1584 |       }
1585 |       defs = desugar(defs);
1586 | 
1587 |       // create the layers
1588 |       this.layers = [];
1589 |       for(var i=0;i<defs.length;i++) {
1590 |         var def = defs[i];
1591 |         if(i>0) {
1592 |           var prev = this.layers[i-1];
1593 |           def.in_sx = prev.out_sx;
1594 |           def.in_sy = prev.out_sy;
1595 |           def.in_depth = prev.out_depth;
1596 |         }
1597 | 
1598 |         switch(def.type) {
1599 |           case 'fc': this.layers.push(new global.FullyConnLayer(def)); break;
1600 |           case 'lrn': this.layers.push(new global.LocalResponseNormalizationLayer(def)); break;
1601 |           case 'dropout': this.layers.push(new global.DropoutLayer(def)); break;
1602 |           case 'input': this.layers.push(new global.InputLayer(def)); break;
1603 |           case 'softmax': this.layers.push(new global.SoftmaxLayer(def)); break;
1604 |           case 'regression': this.layers.push(new global.RegressionLayer(def)); break;
1605 |           case 'conv': this.layers.push(new global.ConvLayer(def)); break;
1606 |           case 'pool': this.layers.push(new global.PoolLayer(def)); break;
1607 |           case 'relu': this.layers.push(new global.ReluLayer(def)); break;
1608 |           case 'sigmoid': this.layers.push(new global.SigmoidLayer(def)); break;
1609 |           case 'tanh': this.layers.push(new global.TanhLayer(def)); break;
1610 |           case 'maxout': this.layers.push(new global.MaxoutLayer(def)); break;
1611 |           case 'svm': this.layers.push(new global.SVMLayer(def)); break;
1612 |           default: console.log('ERROR: UNRECOGNIZED LAYER TYPE: ' + def.type);
1613 |         }
1614 |       }
1615 |     },
1616 | 
1617 |     // forward prop the network.
1618 |     // The trainer class passes is_training = true, but when this function is
1619 |     // called from outside (not from the trainer), it defaults to prediction mode
1620 |     forward: function(V, is_training) {
1621 |       if(typeof(is_training) === 'undefined') is_training = false;
1622 |       var act = this.layers[0].forward(V, is_training);
1623 |       for(var i=1;i<this.layers.length;i++) {
1624 |         act = this.layers[i].forward(act, is_training);
1625 |       }
1626 |       return act;
1627 |     },
1628 | 
1629 |     getCostLoss: function(V, y) {
1630 |       this.forward(V, false);
1631 |       var N = this.layers.length;
1632 |       var loss = this.layers[N-1].backward(y);
1633 |       return loss;
1634 |     },
1635 | 
1636 |     // backprop: compute gradients wrt all parameters
1637 |     backward: function(y) {
1638 |       var N = this.layers.length;
1639 |       var loss = this.layers[N-1].backward(y); // last layer assumed to be loss layer
1640 |       for(var i=N-2;i>=0;i--) { // first layer assumed input
1641 |         this.layers[i].backward();
1642 |       }
1643 |       return loss;
1644 |     },
1645 |     getParamsAndGrads: function() {
1646 |       // accumulate parameters and gradients for the entire network
1647 |       var response = [];
1648 |       for(var i=0;i<this.layers.length;i++) {
1649 |         var layer_reponse = this.layers[i].getParamsAndGrads();
1650 |         for(var j=0;j<layer_reponse.length;j++) {
1651 |           response.push(layer_reponse[j]);
1652 |         }
1653 |       }
1654 |       return response;
1655 |     },
1656 |     getPrediction: function() {
1657 |       // this is a convenience function for returning the argmax
1658 |       // prediction, assuming the last layer of the net is a softmax
1659 |       var S = this.layers[this.layers.length-1];
1660 |       assert(S.layer_type === 'softmax', 'getPrediction function assumes softmax as last layer of the net!');
1661 | 
1662 |       var p = S.out_act.w;
1663 |       var maxv = p[0];
1664 |       var maxi = 0;
1665 |       for(var i=1;i<p.length;i++) {
1666 |         if(p[i] > maxv) { maxv = p[i]; maxi = i;}
1667 |       }
1668 |       return maxi; // return index of the class with highest class probability
1669 |     },
1670 |     toJSON: function() {
1671 |       var json = {};
1672 |       json.layers = [];
1673 |       for(var i=0;i<this.layers.length;i++) {
1674 |         json.layers.push(this.layers[i].toJSON());
1675 |       }
1676 |       return json;
1677 |     },
1678 |     fromJSON: function(json) {
1679 |       this.layers = [];
1680 |       for(var i=0;i<json.layers.length;i++) {
1681 |         var Lj = json.layers[i]
1682 |         var t = Lj.layer_type;
1683 |         var L;
1684 |         if(t==='input') { L = new global.InputLayer(); }
1685 |         if(t==='relu') { L = new global.ReluLayer(); }
1686 |         if(t==='sigmoid') { L = new global.SigmoidLayer(); }
1687 |         if(t==='tanh') { L = new global.TanhLayer(); }
1688 |         if(t==='dropout') { L = new global.DropoutLayer(); }
1689 |         if(t==='conv') { L = new global.ConvLayer(); }
1690 |         if(t==='pool') { L = new global.PoolLayer(); }
1691 |         if(t==='lrn') { L = new global.LocalResponseNormalizationLayer(); }
1692 |         if(t==='softmax') { L = new global.SoftmaxLayer(); }
1693 |         if(t==='regression') { L = new global.RegressionLayer(); }
1694 |         if(t==='fc') { L = new global.FullyConnLayer(); }
1695 |         if(t==='maxout') { L = new global.MaxoutLayer(); }
1696 |         if(t==='svm') { L = new global.SVMLayer(); }
1697 |         L.fromJSON(Lj);
1698 |         this.layers.push(L);
1699 |       }
1700 |     }
1701 |   }
1702 | 
1703 |   global.Net = Net;
1704 | })(convnetjs);
1705 | (function(global) {
1706 |   "use strict";
1707 |   var Vol = global.Vol; // convenience
1708 | 
1709 |   var Trainer = function(net, options) {
1710 | 
1711 |     this.net = net;
1712 | 
1713 |     var options = options || {};
1714 |     this.learning_rate = typeof options.learning_rate !== 'undefined' ? options.learning_rate : 0.01;
1715 |     this.l1_decay = typeof options.l1_decay !== 'undefined' ? options.l1_decay : 0.0;
1716 |     this.l2_decay = typeof options.l2_decay !== 'undefined' ? options.l2_decay : 0.0;
1717 |     this.batch_size = typeof options.batch_size !== 'undefined' ? options.batch_size : 1;
1718 |     this.method = typeof options.method !== 'undefined' ? options.method : 'sgd'; // sgd/adagrad/adadelta/windowgrad/netsterov
1719 | 
1720 |     this.momentum = typeof options.momentum !== 'undefined' ? options.momentum : 0.9;
1721 |     this.ro = typeof options.ro !== 'undefined' ? options.ro : 0.95; // used in adadelta
1722 |     this.eps = typeof options.eps !== 'undefined' ? options.eps : 1e-6; // used in adadelta
1723 | 
1724 |     this.k = 0; // iteration counter
1725 |     this.gsum = []; // last iteration gradients (used for momentum calculations)
1726 |     this.xsum = []; // used in adadelta
1727 |   }
1728 | 
1729 |   Trainer.prototype = {
1730 |     train: function(x, y) {
1731 | 
1732 |       var start = new Date().getTime();
1733 |       this.net.forward(x, true); // also set the flag that lets the net know we're just training
1734 |       var end = new Date().getTime();
1735 |       var fwd_time = end - start;
1736 | 
1737 |       var start = new Date().getTime();
1738 |       var cost_loss = this.net.backward(y);
1739 |       var l2_decay_loss = 0.0;
1740 |       var l1_decay_loss = 0.0;
1741 |       var end = new Date().getTime();
1742 |       var bwd_time = end - start;
1743 | 
1744 |       this.k++;
1745 |       if(this.k % this.batch_size === 0) {
1746 | 
1747 |         var pglist = this.net.getParamsAndGrads();
1748 | 
1749 |         // initialize lists for accumulators. Will only be done once on first iteration
1750 |         if(this.gsum.length === 0 && (this.method !== 'sgd' || this.momentum > 0.0)) {
1751 |           // only vanilla sgd doesnt need either lists
1752 |           // momentum needs gsum
1753 |           // adagrad needs gsum
1754 |           // adadelta needs gsum and xsum
1755 |           for(var i=0;i<pglist.length;i++) {
1756 |             this.gsum.push(global.zeros(pglist[i].params.length));
1757 |             if(this.method === 'adadelta') {
1758 |               this.xsum.push(global.zeros(pglist[i].params.length));
1759 |             } else {
1760 |               this.xsum.push([]); // conserve memory
1761 |             }
1762 |           }
1763 |         }
1764 | 
1765 |         // perform an update for all sets of weights
1766 |         for(var i=0;i<pglist.length;i++) {
1767 |           var pg = pglist[i]; // param, gradient, other options in future (custom learning rate etc)
1768 |           var p = pg.params;
1769 |           var g = pg.grads;
1770 | 
1771 |           // learning rate for some parameters.
1772 |           var l2_decay_mul = typeof pg.l2_decay_mul !== 'undefined' ? pg.l2_decay_mul : 1.0;
1773 |           var l1_decay_mul = typeof pg.l1_decay_mul !== 'undefined' ? pg.l1_decay_mul : 1.0;
1774 |           var l2_decay = this.l2_decay * l2_decay_mul;
1775 |           var l1_decay = this.l1_decay * l1_decay_mul;
1776 | 
1777 |           var plen = p.length;
1778 |           for(var j=0;j<plen;j++) {
1779 |             l2_decay_loss += l2_decay*p[j]*p[j]/2; // accumulate weight decay loss
1780 |             l1_decay_loss += l1_decay*Math.abs(p[j]);
1781 |             var l1grad = l1_decay * (p[j] > 0 ? 1 : -1);
1782 |             var l2grad = l2_decay * (p[j]);
1783 | 
1784 |             var gij = (l2grad + l1grad + g[j]) / this.batch_size; // raw batch gradient
1785 | 
1786 |             var gsumi = this.gsum[i];
1787 |             var xsumi = this.xsum[i];
1788 |             if(this.method === 'adagrad') {
1789 |               // adagrad update
1790 |               gsumi[j] = gsumi[j] + gij * gij;
1791 |               var dx = - this.learning_rate / Math.sqrt(gsumi[j] + this.eps) * gij;
1792 |               p[j] += dx;
1793 |             } else if(this.method === 'windowgrad') {
1794 |               // this is adagrad but with a moving window weighted average
1795 |               // so the gradient is not accumulated over the entire history of the run.
1796 |               // it's also referred to as Idea #1 in Zeiler paper on Adadelta. Seems reasonable to me!
1797 |               gsumi[j] = this.ro * gsumi[j] + (1-this.ro) * gij * gij;
1798 |               var dx = - this.learning_rate / Math.sqrt(gsumi[j] + this.eps) * gij; // eps added for better conditioning
1799 |               p[j] += dx;
1800 |             } else if(this.method === 'adadelta') {
1801 |               // assume adadelta if not sgd or adagrad
1802 |               gsumi[j] = this.ro * gsumi[j] + (1-this.ro) * gij * gij;
1803 |               var dx = - Math.sqrt((xsumi[j] + this.eps)/(gsumi[j] + this.eps)) * gij;
1804 |               xsumi[j] = this.ro * xsumi[j] + (1-this.ro) * dx * dx; // yes, xsum lags behind gsum by 1.
1805 |               p[j] += dx;
1806 |             } else if(this.method === 'nesterov') {
1807 |             	var dx = gsumi[j];
1808 |             	gsumi[j] = gsumi[j] * this.momentum + this.learning_rate * gij;
1809 |                 dx = this.momentum * dx - (1.0 + this.momentum) * gsumi[j];
1810 |                 p[j] += dx;
1811 |             } else {
1812 |               // assume SGD
1813 |               if(this.momentum > 0.0) {
1814 |                 // momentum update
1815 |                 var dx = this.momentum * gsumi[j] - this.learning_rate * gij; // step
1816 |                 gsumi[j] = dx; // back this up for next iteration of momentum
1817 |                 p[j] += dx; // apply corrected gradient
1818 |               } else {
1819 |                 // vanilla sgd
1820 |                 p[j] +=  - this.learning_rate * gij;
1821 |               }
1822 |             }
1823 |             g[j] = 0.0; // zero out gradient so that we can begin accumulating anew
1824 |           }
1825 |         }
1826 |       }
1827 | 
1828 |       // appending softmax_loss for backwards compatibility, but from now on we will always use cost_loss
1829 |       // in future, TODO: have to completely redo the way loss is done around the network as currently
1830 |       // loss is a bit of a hack. Ideally, user should specify arbitrary number of loss functions on any layer
1831 |       // and it should all be computed correctly and automatically.
1832 |       return {fwd_time: fwd_time, bwd_time: bwd_time,
1833 |               l2_decay_loss: l2_decay_loss, l1_decay_loss: l1_decay_loss,
1834 |               cost_loss: cost_loss, softmax_loss: cost_loss,
1835 |               loss: cost_loss + l1_decay_loss + l2_decay_loss}
1836 |     }
1837 |   }
1838 | 
1839 |   global.Trainer = Trainer;
1840 |   global.SGDTrainer = Trainer; // backwards compatibility
1841 | })(convnetjs);
1842 | 
1843 | (function(global) {
1844 |   "use strict";
1845 | 
1846 |   // used utilities, make explicit local references
1847 |   var randf = global.randf;
1848 |   var randi = global.randi;
1849 |   var Net = global.Net;
1850 |   var Trainer = global.Trainer;
1851 |   var maxmin = global.maxmin;
1852 |   var randperm = global.randperm;
1853 |   var weightedSample = global.weightedSample;
1854 |   var getopt = global.getopt;
1855 |   var arrUnique = global.arrUnique;
1856 | 
1857 |   /*
1858 |   A MagicNet takes data: a list of convnetjs.Vol(), and labels
1859 |   which for now are assumed to be class indeces 0..K. MagicNet then:
1860 |   - creates data folds for cross-validation
1861 |   - samples candidate networks
1862 |   - evaluates candidate networks on all data folds
1863 |   - produces predictions by model-averaging the best networks
1864 |   */
1865 |   var MagicNet = function(data, labels, opt) {
1866 |     var opt = opt || {};
1867 |     if(typeof data === 'undefined') { data = []; }
1868 |     if(typeof labels === 'undefined') { labels = []; }
1869 | 
1870 |     // required inputs
1871 |     this.data = data; // store these pointers to data
1872 |     this.labels = labels;
1873 | 
1874 |     // optional inputs
1875 |     this.train_ratio = getopt(opt, 'train_ratio', 0.7);
1876 |     this.num_folds = getopt(opt, 'num_folds', 10);
1877 |     this.num_candidates = getopt(opt, 'num_candidates', 50); // we evaluate several in parallel
1878 |     // how many epochs of data to train every network? for every fold?
1879 |     // higher values mean higher accuracy in final results, but more expensive
1880 |     this.num_epochs = getopt(opt, 'num_epochs', 50);
1881 |     // number of best models to average during prediction. Usually higher = better
1882 |     this.ensemble_size = getopt(opt, 'ensemble_size', 10);
1883 | 
1884 |     // candidate parameters
1885 |     this.batch_size_min = getopt(opt, 'batch_size_min', 10);
1886 |     this.batch_size_max = getopt(opt, 'batch_size_max', 300);
1887 |     this.l2_decay_min = getopt(opt, 'l2_decay_min', -4);
1888 |     this.l2_decay_max = getopt(opt, 'l2_decay_max', 2);
1889 |     this.learning_rate_min = getopt(opt, 'learning_rate_min', -4);
1890 |     this.learning_rate_max = getopt(opt, 'learning_rate_max', 0);
1891 |     this.momentum_min = getopt(opt, 'momentum_min', 0.9);
1892 |     this.momentum_max = getopt(opt, 'momentum_max', 0.9);
1893 |     this.neurons_min = getopt(opt, 'neurons_min', 5);
1894 |     this.neurons_max = getopt(opt, 'neurons_max', 30);
1895 | 
1896 |     // computed
1897 |     this.folds = []; // data fold indices, gets filled by sampleFolds()
1898 |     this.candidates = []; // candidate networks that are being currently evaluated
1899 |     this.evaluated_candidates = []; // history of all candidates that were fully evaluated on all folds
1900 |     this.unique_labels = arrUnique(labels);
1901 |     this.iter = 0; // iteration counter, goes from 0 -> num_epochs * num_training_data
1902 |     this.foldix = 0; // index of active fold
1903 | 
1904 |     // callbacks
1905 |     this.finish_fold_callback = null;
1906 |     this.finish_batch_callback = null;
1907 | 
1908 |     // initializations
1909 |     if(this.data.length > 0) {
1910 |       this.sampleFolds();
1911 |       this.sampleCandidates();
1912 |     }
1913 |   };
1914 | 
1915 |   MagicNet.prototype = {
1916 | 
1917 |     // sets this.folds to a sampling of this.num_folds folds
1918 |     sampleFolds: function() {
1919 |       var N = this.data.length;
1920 |       var num_train = Math.floor(this.train_ratio * N);
1921 |       this.folds = []; // flush folds, if any
1922 |       for(var i=0;i<this.num_folds;i++) {
1923 |         var p = randperm(N);
1924 |         this.folds.push({train_ix: p.slice(0, num_train), test_ix: p.slice(num_train, N)});
1925 |       }
1926 |     },
1927 | 
1928 |     // returns a random candidate network
1929 |     sampleCandidate: function() {
1930 |       var input_depth = this.data[0].w.length;
1931 |       var num_classes = this.unique_labels.length;
1932 | 
1933 |       // sample network topology and hyperparameters
1934 |       var layer_defs = [];
1935 |       layer_defs.push({type:'input', out_sx:1, out_sy:1, out_depth: input_depth});
1936 |       var nl = weightedSample([0,1,2,3], [0.2, 0.3, 0.3, 0.2]); // prefer nets with 1,2 hidden layers
1937 |       for(var q=0;q<nl;q++) {
1938 |         var ni = randi(this.neurons_min, this.neurons_max);
1939 |         var act = ['tanh','maxout','relu'][randi(0,3)];
1940 |         if(randf(0,1)<0.5) {
1941 |           var dp = Math.random();
1942 |           layer_defs.push({type:'fc', num_neurons: ni, activation: act, drop_prob: dp});
1943 |         } else {
1944 |           layer_defs.push({type:'fc', num_neurons: ni, activation: act});
1945 |         }
1946 |       }
1947 |       layer_defs.push({type:'softmax', num_classes: num_classes});
1948 |       var net = new Net();
1949 |       net.makeLayers(layer_defs);
1950 | 
1951 |       // sample training hyperparameters
1952 |       var bs = randi(this.batch_size_min, this.batch_size_max); // batch size
1953 |       var l2 = Math.pow(10, randf(this.l2_decay_min, this.l2_decay_max)); // l2 weight decay
1954 |       var lr = Math.pow(10, randf(this.learning_rate_min, this.learning_rate_max)); // learning rate
1955 |       var mom = randf(this.momentum_min, this.momentum_max); // momentum. Lets just use 0.9, works okay usually ;p
1956 |       var tp = randf(0,1); // trainer type
1957 |       var trainer_def;
1958 |       if(tp<0.33) {
1959 |         trainer_def = {method:'adadelta', batch_size:bs, l2_decay:l2};
1960 |       } else if(tp<0.66) {
1961 |         trainer_def = {method:'adagrad', learning_rate: lr, batch_size:bs, l2_decay:l2};
1962 |       } else {
1963 |         trainer_def = {method:'sgd', learning_rate: lr, momentum: mom, batch_size:bs, l2_decay:l2};
1964 |       }
1965 | 
1966 |       var trainer = new Trainer(net, trainer_def);
1967 | 
1968 |       var cand = {};
1969 |       cand.acc = [];
1970 |       cand.accv = 0; // this will maintained as sum(acc) for convenience
1971 |       cand.layer_defs = layer_defs;
1972 |       cand.trainer_def = trainer_def;
1973 |       cand.net = net;
1974 |       cand.trainer = trainer;
1975 |       return cand;
1976 |     },
1977 | 
1978 |     // sets this.candidates with this.num_candidates candidate nets
1979 |     sampleCandidates: function() {
1980 |       this.candidates = []; // flush, if any
1981 |       for(var i=0;i<this.num_candidates;i++) {
1982 |         var cand = this.sampleCandidate();
1983 |         this.candidates.push(cand);
1984 |       }
1985 |     },
1986 | 
1987 |     step: function() {
1988 | 
1989 |       // run an example through current candidate
1990 |       this.iter++;
1991 | 
1992 |       // step all candidates on a random data point
1993 |       var fold = this.folds[this.foldix]; // active fold
1994 |       var dataix = fold.train_ix[randi(0, fold.train_ix.length)];
1995 |       for(var k=0;k<this.candidates.length;k++) {
1996 |         var x = this.data[dataix];
1997 |         var l = this.labels[dataix];
1998 |         this.candidates[k].trainer.train(x, l);
1999 |       }
2000 | 
2001 |       // process consequences: sample new folds, or candidates
2002 |       var lastiter = this.num_epochs * fold.train_ix.length;
2003 |       if(this.iter >= lastiter) {
2004 |         // finished evaluation of this fold. Get final validation
2005 |         // accuracies, record them, and go on to next fold.
2006 |         var val_acc = this.evalValErrors();
2007 |         for(var k=0;k<this.candidates.length;k++) {
2008 |           var c = this.candidates[k];
2009 |           c.acc.push(val_acc[k]);
2010 |           c.accv += val_acc[k];
2011 |         }
2012 |         this.iter = 0; // reset step number
2013 |         this.foldix++; // increment fold
2014 | 
2015 |         if(this.finish_fold_callback !== null) {
2016 |           this.finish_fold_callback();
2017 |         }
2018 | 
2019 |         if(this.foldix >= this.folds.length) {
2020 |           // we finished all folds as well! Record these candidates
2021 |           // and sample new ones to evaluate.
2022 |           for(var k=0;k<this.candidates.length;k++) {
2023 |             this.evaluated_candidates.push(this.candidates[k]);
2024 |           }
2025 |           // sort evaluated candidates according to accuracy achieved
2026 |           this.evaluated_candidates.sort(function(a, b) {
2027 |             return (a.accv / a.acc.length)
2028 |                  > (b.accv / b.acc.length)
2029 |                  ? -1 : 1;
2030 |           });
2031 |           // and clip only to the top few ones (lets place limit at 3*ensemble_size)
2032 |           // otherwise there are concerns with keeping these all in memory
2033 |           // if MagicNet is being evaluated for a very long time
2034 |           if(this.evaluated_candidates.length > 3 * this.ensemble_size) {
2035 |             this.evaluated_candidates = this.evaluated_candidates.slice(0, 3 * this.ensemble_size);
2036 |           }
2037 |           if(this.finish_batch_callback !== null) {
2038 |             this.finish_batch_callback();
2039 |           }
2040 |           this.sampleCandidates(); // begin with new candidates
2041 |           this.foldix = 0; // reset this
2042 |         } else {
2043 |           // we will go on to another fold. reset all candidates nets
2044 |           for(var k=0;k<this.candidates.length;k++) {
2045 |             var c = this.candidates[k];
2046 |             var net = new Net();
2047 |             net.makeLayers(c.layer_defs);
2048 |             var trainer = new Trainer(net, c.trainer_def);
2049 |             c.net = net;
2050 |             c.trainer = trainer;
2051 |           }
2052 |         }
2053 |       }
2054 |     },
2055 | 
2056 |     evalValErrors: function() {
2057 |       // evaluate candidates on validation data and return performance of current networks
2058 |       // as simple list
2059 |       var vals = [];
2060 |       var fold = this.folds[this.foldix]; // active fold
2061 |       for(var k=0;k<this.candidates.length;k++) {
2062 |         var net = this.candidates[k].net;
2063 |         var v = 0.0;
2064 |         for(var q=0;q<fold.test_ix.length;q++) {
2065 |           var x = this.data[fold.test_ix[q]];
2066 |           var l = this.labels[fold.test_ix[q]];
2067 |           net.forward(x);
2068 |           var yhat = net.getPrediction();
2069 |           v += (yhat === l ? 1.0 : 0.0); // 0 1 loss
2070 |         }
2071 |         v /= fold.test_ix.length; // normalize
2072 |         vals.push(v);
2073 |       }
2074 |       return vals;
2075 |     },
2076 | 
2077 |     // returns prediction scores for given test data point, as Vol
2078 |     // uses an averaged prediction from the best ensemble_size models
2079 |     // x is a Vol.
2080 |     predict_soft: function(data) {
2081 |       // forward prop the best networks
2082 |       // and accumulate probabilities at last layer into a an output Vol
2083 | 
2084 |       var eval_candidates = [];
2085 |       var nv = 0;
2086 |       if(this.evaluated_candidates.length === 0) {
2087 |         // not sure what to do here, first batch of nets hasnt evaluated yet
2088 |         // lets just predict with current candidates.
2089 |         nv = this.candidates.length;
2090 |         eval_candidates = this.candidates;
2091 |       } else {
2092 |         // forward prop the best networks from evaluated_candidates
2093 |         nv = Math.min(this.ensemble_size, this.evaluated_candidates.length);
2094 |         eval_candidates = this.evaluated_candidates
2095 |       }
2096 | 
2097 |       // forward nets of all candidates and average the predictions
2098 |       var xout, n;
2099 |       for(var j=0;j<nv;j++) {
2100 |         var net = eval_candidates[j].net;
2101 |         var x = net.forward(data);
2102 |         if(j===0) {
2103 |           xout = x;
2104 |           n = x.w.length;
2105 |         } else {
2106 |           // add it on
2107 |           for(var d=0;d<n;d++) {
2108 |             xout.w[d] += x.w[d];
2109 |           }
2110 |         }
2111 |       }
2112 |       // produce average
2113 |       for(var d=0;d<n;d++) {
2114 |         xout.w[d] /= nv;
2115 |       }
2116 |       return xout;
2117 |     },
2118 | 
2119 |     predict: function(data) {
2120 |       var xout = this.predict_soft(data);
2121 |       if(xout.w.length !== 0) {
2122 |         var stats = maxmin(xout.w);
2123 |         var predicted_label = stats.maxi;
2124 |       } else {
2125 |         var predicted_label = -1; // error out
2126 |       }
2127 |       return predicted_label;
2128 | 
2129 |     },
2130 | 
2131 |     toJSON: function() {
2132 |       // dump the top ensemble_size networks as a list
2133 |       var nv = Math.min(this.ensemble_size, this.evaluated_candidates.length);
2134 |       var json = {};
2135 |       json.nets = [];
2136 |       for(var i=0;i<nv;i++) {
2137 |         json.nets.push(this.evaluated_candidates[i].net.toJSON());
2138 |       }
2139 |       return json;
2140 |     },
2141 | 
2142 |     fromJSON: function(json) {
2143 |       this.ensemble_size = json.nets.length;
2144 |       this.evaluated_candidates = [];
2145 |       for(var i=0;i<this.ensemble_size;i++) {
2146 |         var net = new Net();
2147 |         net.fromJSON(json.nets[i]);
2148 |         var dummy_candidate = {};
2149 |         dummy_candidate.net = net;
2150 |         this.evaluated_candidates.push(dummy_candidate);
2151 |       }
2152 |     },
2153 | 
2154 |     // callback functions
2155 |     // called when a fold is finished, while evaluating a batch
2156 |     onFinishFold: function(f) { this.finish_fold_callback = f; },
2157 |     // called when a batch of candidates has finished evaluating
2158 |     onFinishBatch: function(f) { this.finish_batch_callback = f; }
2159 | 
2160 |   };
2161 | 
2162 |   global.MagicNet = MagicNet;
2163 | })(convnetjs);
2164 | (function(lib) {
2165 |   "use strict";
2166 |   if (typeof module === "undefined" || typeof module.exports === "undefined") {
2167 |     window.convnetjs = lib; // in ordinary browser attach library to window
2168 |   } else {
2169 |     module.exports = lib; // in nodejs
2170 |   }
2171 | })(convnetjs);
2172 | 


--------------------------------------------------------------------------------
/src/vendor/uncertain/deepqlearn.js:
--------------------------------------------------------------------------------
  1 | var convnetjs   = require('./convnet.js');
  2 | var cnnutil     = require('../../bower_components/convnetjs/build/util.js');
  3 | 
  4 | var deepqlearn = deepqlearn || { REVISION: 'ALPHA' };
  5 | 
  6 | (function(global) {
  7 |   "use strict";
  8 | 
  9 |   // An agent is in state0 and does action0
 10 |   // environment then assigns reward0 and provides new state, state1
 11 |   // Experience nodes store all this information, which is used in the
 12 |   // Q-learning update step
 13 |   var Experience = function(state0, action0, reward0, state1) {
 14 |     this.state0 = state0;
 15 |     this.action0 = action0;
 16 |     this.reward0 = reward0;
 17 |     this.state1 = state1;
 18 |   }
 19 | 
 20 |   // A Brain object does all the magic.
 21 |   // over time it receives some inputs and some rewards
 22 |   // and its job is to set the outputs to maximize the expected reward
 23 |   var Brain = function(num_states, num_actions, opt) {
 24 |     var opt = opt || {};
 25 |     // in number of time steps, of temporal memory
 26 |     // the ACTUAL input to the net will be (x,a) temporal_window times, and followed by current x
 27 |     // so to have no information from previous time step going into value function, set to 0.
 28 |     this.temporal_window = typeof opt.temporal_window !== 'undefined' ? opt.temporal_window : 1;
 29 |     // size of experience replay memory
 30 |     this.experience_size = typeof opt.experience_size !== 'undefined' ? opt.experience_size : 30000;
 31 |     // number of examples in experience replay memory before we begin learning
 32 |     this.start_learn_threshold = typeof opt.start_learn_threshold !== 'undefined'? opt.start_learn_threshold : Math.floor(Math.min(this.experience_size*0.1, 1000));
 33 |     // gamma is a crucial parameter that controls how much plan-ahead the agent does. In [0,1]
 34 |     this.gamma = typeof opt.gamma !== 'undefined' ? opt.gamma : 0.8;
 35 | 
 36 |     // number of steps we will learn for
 37 |     this.learning_steps_total = typeof opt.learning_steps_total !== 'undefined' ? opt.learning_steps_total : 100000;
 38 |     // how many steps of the above to perform only random actions (in the beginning)?
 39 |     this.learning_steps_burnin = typeof opt.learning_steps_burnin !== 'undefined' ? opt.learning_steps_burnin : 3000;
 40 |     // what epsilon value do we bottom out on? 0.0 => purely deterministic policy at end
 41 |     this.epsilon_min = typeof opt.epsilon_min !== 'undefined' ? opt.epsilon_min : 0.05;
 42 |     // what epsilon to use at test time? (i.e. when learning is disabled)
 43 |     this.epsilon_test_time = typeof opt.epsilon_test_time !== 'undefined' ? opt.epsilon_test_time : 0.01;
 44 | 
 45 |     // behavioural policy determining how the agent explores the world (either 'greedy' or 'thompson')
 46 |     this.behavior_policy = typeof opt.behavior_policy !== 'undefined' ? opt.behavior_policy : 'greedy';
 47 | 
 48 |     // advanced feature. Sometimes a random action should be biased towards some values
 49 |     // for example in flappy bird, we may want to choose to not flap more often
 50 |     if(typeof opt.random_action_distribution !== 'undefined') {
 51 |       // this better sum to 1 by the way, and be of length this.num_actions
 52 |       this.random_action_distribution = opt.random_action_distribution;
 53 |       if(this.random_action_distribution.length !== num_actions) {
 54 |         console.log('TROUBLE. random_action_distribution should be same length as num_actions.');
 55 |       }
 56 |       var a = this.random_action_distribution;
 57 |       var s = 0.0; for(var k=0;k<a.length;k++) { s+= a[k]; }
 58 |       if(Math.abs(s-1.0)>0.0001) { console.log('TROUBLE. random_action_distribution should sum to 1!'); }
 59 |     } else {
 60 |       this.random_action_distribution = [];
 61 |     }
 62 | 
 63 |     // states that go into neural net to predict optimal action look as
 64 |     // x0,a0,x1,a1,x2,a2,...xt
 65 |     // this variable controls the size of that temporal window. Actions are
 66 |     // encoded as 1-of-k hot vectors
 67 |     this.net_inputs = num_states * this.temporal_window + num_actions * this.temporal_window + num_states;
 68 |     this.num_states = num_states;
 69 |     this.num_actions = num_actions;
 70 |     this.window_size = Math.max(this.temporal_window, 2); // must be at least 2, but if we want more context even more
 71 |     this.state_window = new Array(this.window_size);
 72 |     this.action_window = new Array(this.window_size);
 73 |     this.reward_window = new Array(this.window_size);
 74 |     this.net_window = new Array(this.window_size);
 75 | 
 76 |     // create [state -> value of all possible actions] modeling net for the value function
 77 |     var layer_defs = [];
 78 |     if(typeof opt.layer_defs !== 'undefined') {
 79 |       // this is an advanced usage feature, because size of the input to the network, and number of
 80 |       // actions must check out. This is not very pretty Object Oriented programming but I can't see
 81 |       // a way out of it :(
 82 |       layer_defs = opt.layer_defs;
 83 |       if(layer_defs.length < 2) { console.log('TROUBLE! must have at least 2 layers'); }
 84 |       if(layer_defs[0].type !== 'input') { console.log('TROUBLE! first layer must be input layer!'); }
 85 |       if(layer_defs[layer_defs.length-1].type !== 'regression') { console.log('TROUBLE! last layer must be input regression!'); }
 86 |       if(layer_defs[0].out_depth * layer_defs[0].out_sx * layer_defs[0].out_sy !== this.net_inputs) {
 87 |         console.log('TROUBLE! Number of inputs must be num_states * temporal_window + num_actions * temporal_window + num_states!');
 88 |       }
 89 |       if(layer_defs[layer_defs.length-1].num_neurons !== this.num_actions) {
 90 |         console.log('TROUBLE! Number of regression neurons should be num_actions!');
 91 |       }
 92 |     } else {
 93 |       // create a very simple neural net by default
 94 |       layer_defs.push({type:'input', out_sx:1, out_sy:1, out_depth:this.net_inputs});
 95 |       if(typeof opt.hidden_layer_sizes !== 'undefined') {
 96 |         // allow user to specify this via the option, for convenience
 97 |         var hl = opt.hidden_layer_sizes;
 98 |         for(var k=0;k<hl.length;k++) {
 99 |           layer_defs.push({type:'fc', num_neurons:hl[k], activation:'relu'}); // relu by default
100 |         }
101 |       }
102 |       layer_defs.push({type:'regression', num_neurons:num_actions}); // value function output
103 |     }
104 |     this.value_net = new convnetjs.Net();
105 |     this.value_net.makeLayers(layer_defs);
106 | 
107 |     // and finally we need a Temporal Difference Learning trainer!
108 |     var tdtrainer_options = {learning_rate:0.01, momentum:0.0, batch_size:64, l2_decay:0.01};
109 |     if(typeof opt.tdtrainer_options !== 'undefined') {
110 |       tdtrainer_options = opt.tdtrainer_options; // allow user to overwrite this
111 |     }
112 |     this.tdtrainer = new convnetjs.SGDTrainer(this.value_net, tdtrainer_options);
113 | 
114 |     // experience replay
115 |     this.experience = [];
116 | 
117 |     // various housekeeping variables
118 |     this.age = 0; // incremented every backward()
119 |     this.forward_passes = 0; // incremented every forward()
120 |     this.epsilon = 1.0; // controls exploration exploitation tradeoff. Should be annealed over time
121 |     this.latest_reward = 0;
122 |     this.last_input_array = [];
123 |     this.average_reward_window = new cnnutil.Window(1000, 10);
124 |     this.average_loss_window = new cnnutil.Window(1000, 10);
125 |     this.learning = true;
126 |   }
127 |   Brain.prototype = {
128 |     random_action: function() {
129 |       // a bit of a helper function. It returns a random action
130 |       // we are abstracting this away because in future we may want to
131 |       // do more sophisticated things. For example some actions could be more
132 |       // or less likely at "rest"/default state.
133 |       if(this.random_action_distribution.length === 0) {
134 |         return convnetjs.randi(0, this.num_actions);
135 |       } else {
136 |         // okay, lets do some fancier sampling:
137 |         var p = convnetjs.randf(0, 1.0);
138 |         var cumprob = 0.0;
139 |         for(var k=0;k<this.num_actions;k++) {
140 |           cumprob += this.random_action_distribution[k];
141 |           if(p < cumprob) { return k; }
142 |         }
143 |       }
144 |     },
145 |     policy_greedy: function(s) {
146 |       // Behavioural policy. Compute the value of doing any action
147 |       // in this state and return the argmax action and its value
148 |       var svol = new convnetjs.Vol(1, 1, this.net_inputs);
149 |       svol.w = s;
150 |       var action_values = this.value_net.forward(svol);
151 |       var maxk = 0;
152 |       var maxval = action_values.w[0];
153 |       for(var k=1;k<this.num_actions;k++) {
154 |         if(action_values.w[k] > maxval) { maxk = k; maxval = action_values.w[k]; }
155 |       }
156 |       return {action:maxk, value:maxval};
157 |     },
158 |     policy_thompson: function(s) {
159 |       // Behavioural policy. Compute the value of doing any action
160 |       // in this state and return the argmax action and its value
161 |       // taking uncertainty into account - sampling from the dropout
162 |       // network
163 |       var svol = new convnetjs.Vol(1, 1, this.net_inputs);
164 |       svol.w = s;
165 |       var is_sample = true;
166 |       var action_values = this.value_net.forward(svol, is_sample);
167 |       // Choose the action that maximises the UCB
168 |       var maxk = 0;
169 |       var maxval = action_values.w[0];
170 |       for(var k=1;k<this.num_actions;k++) {
171 |         if(action_values.w[k] > maxval) { maxk = k; maxval = action_values.w[k]; }
172 |       }
173 |       return {action:maxk, value:maxval};
174 |     },
175 |     getNetInput: function(xt) {
176 |       // return s = (x,a,x,a,x,a,xt) state vector.
177 |       // It's a concatenation of last window_size (x,a) pairs and current state x
178 |       var w = [];
179 |       w = w.concat(xt); // start with current state
180 |       // and now go backwards and append states and actions from history temporal_window times
181 |       var n = this.window_size;
182 |       for(var k=0;k<this.temporal_window;k++) {
183 |         // state
184 |         w = w.concat(this.state_window[n-1-k]);
185 |         // action, encoded as 1-of-k indicator vector. We scale it up a bit because
186 |         // we dont want weight regularization to undervalue this information, as it only exists once
187 |         var action1ofk = new Array(this.num_actions);
188 |         for(var q=0;q<this.num_actions;q++) action1ofk[q] = 0.0;
189 |         action1ofk[this.action_window[n-1-k]] = 1.0*this.num_states;
190 |         w = w.concat(action1ofk);
191 |       }
192 |       return w;
193 |     },
194 |     forward: function(input_array) {
195 |       // compute forward (behavior) pass given the input neuron signals from body
196 |       this.forward_passes += 1;
197 |       this.last_input_array = input_array; // back this up
198 | 
199 |       // create network input
200 |       var action;
201 |       if(this.forward_passes > this.temporal_window) {
202 |         // we have enough to actually do something reasonable
203 |         var net_input = this.getNetInput(input_array);
204 |         if(this.behavior_policy == 'greedy') {
205 |           // Greedy sampling with some epsilon scheduling
206 |           if(this.learning) {
207 |             // compute epsilon for the epsilon-greedy policy
208 |             this.epsilon = Math.min(1.0, Math.max(this.epsilon_min,
209 |               1.0-(this.age - this.learning_steps_burnin)/(this.learning_steps_total - this.learning_steps_burnin)));
210 |           } else {
211 |             this.epsilon = this.epsilon_test_time; // use test-time value
212 |           }
213 |           var rf = convnetjs.randf(0,1);
214 |           if(rf < this.epsilon) {
215 |             // choose a random action with epsilon probability
216 |             action = this.random_action();
217 |           } else {
218 |             // otherwise use our policy to make decision
219 |             var maxact = this.policy_greedy(net_input);
220 |             action = maxact.action;
221 |           }
222 |         } else if(this.behavior_policy == 'thompson') {
223 |           // Thompson sampling
224 |           if(this.experience.length < this.learning_steps_burnin) {
225 |             action = this.random_action();
226 |           } else {
227 |             var maxact = this.policy_thompson(net_input);
228 |             action = maxact.action;
229 |           }
230 |         }
231 |       } else {
232 |         // pathological case that happens first few iterations
233 |         // before we accumulate window_size inputs
234 |         var net_input = [];
235 |         action = this.random_action();
236 |       }
237 | 
238 |       // remember the state and action we took for backward pass
239 |       this.net_window.shift();
240 |       this.net_window.push(net_input);
241 |       this.state_window.shift();
242 |       this.state_window.push(input_array);
243 |       this.action_window.shift();
244 |       this.action_window.push(action);
245 | 
246 |       return action;
247 |     },
248 |     backward: function(reward) {
249 |       this.latest_reward = reward;
250 |       this.average_reward_window.add(reward);
251 |       this.reward_window.shift();
252 |       this.reward_window.push(reward);
253 | 
254 |       if(!this.learning) { return; }
255 | 
256 |       // various book-keeping
257 |       this.age += 1;
258 | 
259 |       // it is time t+1 and we have to store (s_t, a_t, r_t, s_{t+1}) as new experience
260 |       // (given that an appropriate number of state measurements already exist, of course)
261 |       if(this.forward_passes > this.temporal_window + 1) {
262 |         var e = new Experience();
263 |         var n = this.window_size;
264 |         e.state0 = this.net_window[n-2];
265 |         e.action0 = this.action_window[n-2];
266 |         e.reward0 = this.reward_window[n-2];
267 |         e.state1 = this.net_window[n-1];
268 |         if(this.experience.length < this.experience_size) {
269 |           this.experience.push(e);
270 |         } else {
271 |           // replace. finite memory!
272 |           var ri = convnetjs.randi(0, this.experience_size);
273 |           this.experience[ri] = e;
274 |         }
275 |       }
276 | 
277 |       // learn based on experience, once we have some samples to go on
278 |       // this is where the magic happens...
279 |       if(this.experience.length > this.start_learn_threshold) {
280 |         var avcost = 0.0;
281 |         for(var k=0;k < this.tdtrainer.batch_size;k++) {
282 |           var re = convnetjs.randi(0, this.experience.length);
283 |           var e = this.experience[re];
284 |           var x = new convnetjs.Vol(1, 1, this.net_inputs);
285 |           x.w = e.state0;
286 |           var maxact;
287 |           if(this.behavior_policy == 'greedy') {
288 |             maxact = this.policy_greedy(e.state1);
289 |           } else if(this.behavior_policy == 'thompson') {
290 |             maxact = this.policy_thompson(e.state1);
291 |           }
292 |           var r = e.reward0 + this.gamma * maxact.value;
293 |           var ystruct = {dim: e.action0, val: r};
294 |           var loss = this.tdtrainer.train(x, ystruct);
295 |           avcost += loss.loss;
296 |         }
297 |         avcost = avcost/this.tdtrainer.batch_size;
298 |         this.average_loss_window.add(avcost);
299 |       }
300 |     },
301 |     visSelf: function(elt) {
302 |       elt.innerHTML = ''; // erase elt first
303 | 
304 |       // elt is a DOM element that this function fills with brain-related information
305 |       var brainvis = document.createElement('div');
306 | 
307 |       // basic information
308 |       var desc = document.createElement('div');
309 |       var t = '';
310 |       t += 'experience replay size: ' + this.experience.length + '<br>';
311 |       t += 'exploration epsilon: ' + this.epsilon + '<br>';
312 |       t += 'age: ' + this.age + '<br>';
313 |       t += 'average Q-learning loss: ' + this.average_loss_window.get_average() + '<br />';
314 |       t += 'smooth-ish reward: ' + this.average_reward_window.get_average() + '<br />';
315 |       desc.innerHTML = t;
316 |       brainvis.appendChild(desc);
317 | 
318 |       elt.appendChild(brainvis);
319 |     }
320 |   }
321 | 
322 |   global.Brain = Brain;
323 | })(deepqlearn);
324 | 
325 | (function(lib) {
326 |   "use strict";
327 |   if (typeof module === "undefined" || typeof module.exports === "undefined") {
328 |     window.deepqlearn = lib; // in ordinary browser attach library to window
329 |   } else {
330 |     module.exports = lib; // in nodejs
331 |   }
332 | })(deepqlearn);
333 | 


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