layer-oriented-deep-learning-network-js/lib/network/DeepNetwork.js

A feed-forward neural network with injectable layers, activation functions, and optimizers.

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var DeepNetwork = function () {
    function DeepNetwork(layers) {
        _classCallCheck(this, DeepNetwork);

        if (layers.length !== 3) {
            throw new Error('Having more or less than 1 hidden layer is not yet supported.');
        }

        this.inputLayer = layers[0];

        this.hiddenLayer = layers[1];
        this.hiddenLayer.setInputLayer(this.inputLayer);

        this.outputLayer = layers[2];
        this.outputLayer.setInputLayer(this.hiddenLayer);
        this.hiddenLayer.setOutputLayer(this.outputLayer);
    }

    _createClass(DeepNetwork, [{
        key: 'invoke',
        value: function invoke(inputs) {
            // for (var i = 0, len = inputs.length; i < len; i++) {
            //     if (!isFinite(inputs[i])) {
            //         throw new Error('Neural network input is not a finite number.');
            //     }
            // }

            this.inputLayer.feedForward(inputs);
            this.hiddenLayer.feedForward();
            var outputs = this.outputLayer.feedForward();

            for (var i = 0, len = outputs.length; i < len; i++) {
                if (!isFinite(outputs[i])) {
                    throw new Error('Neural network output is not a finite number.');
                }
            }

            return outputs;
        }
    }, {
        key: 'learn',
        value: function learn(targetOutputs) {
            this.outputLayer.backPropagateCalculateErrorGradient(targetOutputs);
            this.hiddenLayer.backPropagateCalculateErrorGradient();
            this.outputLayer.backPropagateOptimize();
            this.hiddenLayer.backPropagateOptimize();
        }
    }, {
        key: 'loadFromJson',
        value: function loadFromJson(json) {
            var weights = json.layers[1].weights;
            for (var i = 0; i < weights.length; i++) {
                //@TODO do this inside the layers
                this.hiddenLayer.weights[i] = weights[i];
            }
            weights = json.layers[2].weights;
            for (i = 0; i < weights.length; i++) {
                //@TODO do this inside the layers
                this.outputLayer.weights[i] = weights[i];
            }
        }
    }, {
        key: 'saveToJson',
        value: function saveToJson() {
            //@TODO use more future proof schema
            return {
                layers: [{}, //placeholder for future input layer info
                { weights: Array.from(this.hiddenLayer.weights) }, //@TODO do this inside the layers
                { weights: Array.from(this.outputLayer.weights) } //@TODO do this inside the layers
                ]
            }; //@TODO do this inside the layers
        }
    }]);

    return DeepNetwork;
}();

exports.default = DeepNetwork;