Feedforward Neural Networks using JavaScript

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

1. Feedforward Neural Network
   
2. NPM version  build status  David deps  npm download
   
3. 
   
4. A implementation of feedforward neural networks in javascript based on the mrbo answer found here:
   
5. 
   
6. Implementation
   
7. 
   
8. Methods
   
9. 
   
10. new FNN(X, Y)
    
11. 
    
12. train(options)
    
13. 
    
14. Options
    
15. 
    
16. hiddenLayers - Array with the size of each hidden layer in the FNN.
    
17. iterations - Maximum number of iterations of the algorithm.
    
18. learningRate - The learning rate (number).
    
19. momentum - The regularization term (number).
    
20. predict(dataset)
    
21. 
    
22. toJSON()
    
23. 
    
24. FNN.load(model)
    
25. 
    
26. License
    
27. 
    
28. MIT

复制代码

本帖隐藏的内容

feedforward-neural-networks-master.zip (7.49 KB)

2016-6-26 23:53:43 上传

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏0 回帖

关键词：Javascript Networks forward network script javascript learning version number hidden

1. "use strict";
   
2. 
   
3. var Layer = require("./layer");
   
4. var Matrix = require("ml-matrix");
   
5. 
   
6. class FeedforwardNeuralNetwork {
   
7.     /**
   
8.      * Constructor for the FNN (Feedforward Neural Networks) that takes an Array of Numbers,
   
9.      * those numbers corresponds to the size of each layer in the FNN, the first and the last number of the array corresponds to the input and the
   
10.      * output layer respectively.
    
11.      *
    
12.      * @constructor
    
13.      */
    
14.     constructor(X, Y) {
    
15.         if (X === true) {
    
16.             const model = Y;
    
17.             this.layers = model.layers;
    
18.             this.inputSize = model.inputSize;
    
19.             this.outputSize = model.outputSize;
    
20.         } else {
    
21.             if (X.length !== Y.length)
    
22.                 throw new RangeError("X and Y must have the same size.");
    
23.             this.X = X;
    
24.             this.Y = Y;
    
25.             this.inputSize = X[0].length;
    
26.             this.outputSize = Y[0].length;
    
27.         }
    
28.     }
    
29. 
    
30.     /**
    
31.      * Build the Neural Network with an array that represent each hidden layer size.
    
32.      *
    
33.      * @param {Array} layersSize - Array of sizes of each layer.
    
34.      */
    
35.     buildNetwork(layersSize) {
    
36.         layersSize.push(this.outputSize);
    
37. 
    
38.         this.layers = new Array(layersSize.length);
    
39. 
    
40.         for (var i = 0; i < layersSize.length; ++i) {
    
41.             var inSize = (i == 0) ? this.inputSize : layersSize[i - 1];
    
42.             this.layers[i] = new Layer(inSize, layersSize[i]);
    
43.         }
    
44. 
    
45.         this.layers[this.layers.length - 1].isSigmoid = false;
    
46.     }
    
47. 
    
48.     /**
    
49.      * Function that applies a forward propagation over the Neural Network
    
50.      * with one case of the dataset.
    
51.      * @param {Array} input - case of the dataset.
    
52.      * @returns {Array} result of the forward propagation.
    
53.      */
    
54.     forwardNN(input) {
    
55.         var results = input.slice();
    
56. 
    
57.         for (var i = 0; i < this.layers.length; ++i) {
    
58.             results = this.layers[i].forward(results);
    
59.         }
    
60. 
    
61.         return results;
    
62.     }
    
63. 
    
64.     /**
    
65.      * Function that makes one iteration (epoch) over the Neural Network with one element
    
66.      * of the dataset with corresponding prediction; the other two arguments are the
    
67.      * learning rate and the momentum that is the regularization term for the parameters
    
68.      * of each perceptron in the Neural Network.
    
69.      * @param {Array} data - Element of the dataset.
    
70.      * @param {Array} prediction - Prediction over the data object.
    
71.      * @param {Number} learningRate
    
72.      * @param momentum - the regularization term.
    
73.      */
    
74.     iteration(data, prediction, learningRate, momentum) {
    
75.         var forwardResult = this.forwardNN(data);
    
76.         var error = new Array(forwardResult.length);
    
77. 
    
78.         if (typeof(prediction) === 'number')
    
79.             prediction = [prediction];
    
80. 
    
81.         for (var i = 0; i < error.length; i++) {
    
82.             error[i] = prediction[i] - forwardResult[i];
    
83.         }
    
84. 
    
85.         var lengthLayers = this.layers.length;
    
86. 
    
87.         for (i = 0; i < lengthLayers; ++i) {
    
88.             error = this.layers[lengthLayers - 1 - i].train(error, learningRate, momentum);
    
89.         }
    
90.     }
    
91. 
    
92.     /**
    
93.      * Method that train the neural network with a given training set with corresponding
    
94.      * predictions. The options argument has an array of the number of perceptrons that we want in each hidden layer, the
    
95.      * number of iterations (default 50) that we want to perform, the learning rate and the momentum that is the
    
96.      * regularization term (default 0.1 for both) for the parameters of each perceptron in the Neural Network.
    
97.      *
    
98.      * options:
    
99.      * * hiddenLayers - Array of number with each hidden layer size.
    
100.      * * iterations - Number
     
101.      * * learningRate - Number
     
102.      * * momentum - Number
     
103.      *
     
104.      * @param {object} options
     
105.      */
     
106.     train(options) {
     
107.         if (options === undefined) options = {};
     
108. 
     
109.         const trainingSet = this.X;
     
110.         const predictions = this.Y;
     
111. 
     
112.         var hiddenLayers = options.hiddenLayers === undefined ? [10] : options.hiddenLayers;
     
113.         var iterations = options.iterations === undefined ? 50 : options.iterations;
     
114.         var learningRate = options.learningRate === undefined ? 0.1 : options.learningRate;
     
115.         var momentum = options.momentum === undefined ? 0.1 : options.momentum;
     
116. 
     
117.         this.buildNetwork(hiddenLayers);
     
118. 
     
119.         for (var i = 0; i < iterations; ++i) {
     
120.             for (var j = 0; j < predictions.length; ++j) {
     
121.                 var index = randomIntegerFromInterval(0, predictions.length - 1);
     
122.                 this.iteration(trainingSet[index], predictions[index], learningRate, momentum);
     
123.             }
     
124.         }
     
125.     }
     
126. 
     
127.     /**
     
128.      * Function that with a dataset, gives all the predictions for this dataset.
     
129.      * @param {Matrix} dataset.
     
130.      * @returns {Array} predictions
     
131.      */
     
132.     predict(dataset) {
     
133.         if (dataset[0].length !== this.inputSize)
     
134.             throw new RangeError("The dataset columns must have the same size of the " +
     
135.                 "input layer");
     
136.         var result = new Array(dataset.length);
     
137.         for (var i = 0; i < dataset.length; i++) {
     
138.             result[i] = this.forwardNN(dataset[i]);
     
139.         }
     
140. 
     
141.         result = new Matrix(result);
     
142.         //return result.columns === 1 ? result.getColumn(0) : result;
     
143.         return result;
     
144.         
     
145.     }
     
146. 
     
147.     toJSON() {
     
148.         return {
     
149.             name: 'FNN',
     
150.             layers: this.layers,
     
151.             inputSize: this.inputSize,
     
152.             outputSize: this.outputSize
     
153.         };
     
154.     }
     
155. 
     
156.     static load(model) {
     
157.         if (model.name !== 'FNN')
     
158.             throw new RangeError('Invalid model: ' + model.name);
     
159.         return new FeedforwardNeuralNetwork(true, model);
     
160.     }
     
161. }
     
162. 
     
163. module.exports = FeedforwardNeuralNetwork;
     
164. 
     
165. /**
     
166. * Function that returns a random number between two numbers (inclusive)
     
167. * @param {number} min - lower bound
     
168. * @param {number} max - upper bound.
     
169. * @returns {number} random number
     
170. */
     
171. function randomIntegerFromInterval(min, max) {
     
172.     return Math.floor(Math.random() * (max - min + 1) + min);
     
173. }

复制代码