Skip to content

Commit 7173283

Browse files
FurkanOMFurkanOM
committed
initialize repository
1 parent 0a52881 commit 7173283

File tree

3 files changed

+457
-0
lines changed

3 files changed

+457
-0
lines changed

‎Network.js

+260
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,260 @@
1+
/*
2+
** @data -> Multidimensional array inputs and outputs
3+
** @hiddenNeurons -> Hidden neuron number
4+
** @outputNeurons -> Output neuron number
5+
** @error -> Training process will be stop if the error lower than this number
6+
** @epoch -> Number of iterations
7+
** @learningRate -> Learning rate
8+
** @useAdaptiveLearningRate -> If you don't use adaptive learning rate mechanism you can set this value as false (default => true)
9+
** If you don't set momentum and weight decay values network automatically ignore these processes
10+
*/
11+
function Network(data, hiddenNeurons, outputNeurons, error, epoch, learningRate, useAdaptiveLearningRate=true){
12+
this.trainingData = data;
13+
this.inputNeurons = data[0].length - outputNeurons;
14+
this.hiddenNeurons = hiddenNeurons;
15+
this.outputNeurons = outputNeurons;
16+
this.error = error;
17+
this.epoch = epoch;
18+
this.learningRate = learningRate;
19+
this.testData;
20+
this.trainingError = null;
21+
this.testError = null;
22+
this.weightDecay = 0;
23+
this.momentum = 0;
24+
this.adaptiveLearningRateA = 0.001;
25+
this.adaptiveLearningRateB = 0.001;
26+
this.useAdaptiveLearningRate = useAdaptiveLearningRate;
27+
}
28+
29+
Network.prototype.init = function(){
30+
var inputNeuronCount = this.inputNeurons;
31+
var hiddenNeuronCount = this.hiddenNeurons;
32+
var outputNeuronCount = this.outputNeurons;
33+
34+
this.inputNeurons = [];
35+
this.hiddenNeurons = [];
36+
this.outputNeurons = [];
37+
38+
for(var i = 0; i < inputNeuronCount; i++){
39+
var neuron = new Neuron();
40+
neuron.initNeuron(hiddenNeuronCount);
41+
this.inputNeurons.push(neuron);
42+
}
43+
44+
var biasNeuron = new Neuron();
45+
biasNeuron.initNeuron(hiddenNeuronCount);
46+
biasNeuron.setOutput(1);
47+
this.inputNeurons.push(biasNeuron);
48+
49+
for(var i = 0; i < hiddenNeuronCount; i++){
50+
var neuron = new Neuron();
51+
neuron.initNeuron(outputNeuronCount);
52+
this.hiddenNeurons.push(neuron);
53+
}
54+
55+
biasNeuron = new Neuron();
56+
biasNeuron.initNeuron(outputNeuronCount);
57+
biasNeuron.setOutput(1);
58+
this.hiddenNeurons.push(biasNeuron);
59+
60+
for(var i = 0; i < outputNeuronCount; i++){
61+
var neuron = new Neuron();
62+
this.outputNeurons.push(neuron);
63+
}
64+
};
65+
66+
Network.prototype.train = function(){
67+
var prevError = 0;
68+
for(var i = 0; i < this.epoch; i++){
69+
70+
this.shuffleArray(this.trainingData);
71+
var totalError = 0;
72+
for(var j = 0; j < this.trainingData.length; j++){
73+
74+
this.feedForward(this.trainingData[j]);
75+
totalError += this.calculateError();
76+
this.backPropagation();
77+
78+
}
79+
totalError = totalError / this.trainingData.length;
80+
this.trainingError = totalError;
81+
82+
/*
83+
* -> Adaptive Learning Rate Start
84+
*/
85+
if(this.useAdaptiveLearningRate){
86+
if(prevError < totalError){
87+
this.learningRate -= this.learningRate * this.adaptiveLearningRateB;
88+
}else{
89+
this.learningRate += this.adaptiveLearningRateA;
90+
}
91+
}
92+
prevError = totalError;
93+
/*
94+
* -> Adaptive Learning Rate End
95+
*/
96+
// We add weight sum to error for prevent the weight increasing so much
97+
totalError += (this.weightDecay/2) * this.getSumOfWeightSquares();
98+
if(totalError < this.error)
99+
break;
100+
}
101+
};
102+
103+
Network.prototype.test = function(){
104+
var totalError = 0;
105+
for(var i = 0; i < this.testData.length; i++){
106+
107+
this.feedForward(this.testData[i]);
108+
totalError += this.calculateError();
109+
110+
}
111+
this.testError = totalError / this.testData.length;
112+
};
113+
114+
Network.prototype.backPropagation = function(){
115+
for(var i = 0; i < this.outputNeurons.length; i++){
116+
117+
var outputError = this.outputNeurons[i].getError();
118+
119+
for(var j = 0; j < this.hiddenNeurons.length; j++){
120+
var accumulateOutputError = 0;
121+
if(i != 0){
122+
accumulateOutputError = this.hiddenNeurons[j].getError();
123+
}
124+
var weight = this.hiddenNeurons[j].getWeight(i);
125+
this.hiddenNeurons[j].setError(accumulateOutputError + (outputError * weight));
126+
127+
var delta = this.learningRate * outputError * this.hiddenNeurons[j].getOutput();
128+
var prevDelta = this.hiddenNeurons[j].getPrevDelta(i);
129+
var newWeight = weight + delta;
130+
if(this.useWeightDecay) newWeight -= this.weightDecay * weight;
131+
if(this.useMomentum) newWeight += this.momentum * prevDelta;
132+
this.hiddenNeurons[j].setWeight(i, newWeight);
133+
this.hiddenNeurons[j].setPrevDelta(i, delta);
134+
}
135+
}
136+
137+
for(var i = 0; i < this.hiddenNeurons.length-1; i++){ // Because of bias
138+
139+
var accumulatedError = this.hiddenNeurons[i].getError();
140+
var derivative = this.hiddenNeurons[i].getOutput() * (1 - this.hiddenNeurons[i].getOutput());
141+
142+
for(var j = 0; j < this.inputNeurons.length; j++){
143+
var delta = this.learningRate * accumulatedError * derivative * this.inputNeurons[j].getOutput();
144+
145+
var weight = this.inputNeurons[j].getWeight(i);
146+
var prevDelta = this.inputNeurons[j].getPrevDelta(i);
147+
148+
var newWeight = weight + delta;
149+
if(this.useWeightDecay) newWeight -= this.weightDecay * weight;
150+
if(this.useMomentum) newWeight += this.momentum * prevDelta;
151+
152+
this.inputNeurons[j].setWeight(i, newWeight);
153+
this.inputNeurons[j].setPrevDelta(i, delta);
154+
}
155+
}
156+
};
157+
158+
Network.prototype.calculateError = function(){
159+
var totalError = 0;
160+
for(var i = 0; i < this.outputNeurons.length; i++){
161+
var error = this.outputNeurons[i].getActual() - this.outputNeurons[i].getOutput();
162+
this.outputNeurons[i].setError(error);
163+
totalError += Math.pow(error, 2);
164+
}
165+
return totalError;
166+
};
167+
168+
Network.prototype.feedForward = function(array){
169+
this.setOutputs(array);
170+
171+
for(var i = 0; i < this.hiddenNeurons.length-1; i++){ // Because of bias
172+
var input = 0;
173+
for(var j = 0; j < this.inputNeurons.length; j++){
174+
input += this.inputNeurons[j].getOutput() * this.inputNeurons[j].getWeight(i);
175+
}
176+
this.hiddenNeurons[i].setOutput(this.sigmoid(input));
177+
}
178+
179+
for(var i = 0; i < this.outputNeurons.length; i++){
180+
var input = 0;
181+
for(var j = 0; j < this.hiddenNeurons.length; j++){
182+
input += this.hiddenNeurons[j].getOutput() * this.hiddenNeurons[j].getWeight(i);
183+
}
184+
this.outputNeurons[i].setOutput(input);
185+
}
186+
};
187+
188+
Network.prototype.getSumOfWeightSquares = function(){
189+
var sum = 0;
190+
for(var i = 0; i < this.outputNeurons.length; i++){
191+
for(var j = 0; j < this.hiddenNeurons.length; j++){
192+
sum += Math.pow(this.hiddenNeurons[j].getWeight(i), 2);
193+
}
194+
}
195+
for(var i = 0; i < this.hiddenNeurons.length - 1; i++){
196+
for(var j = 0; j < this.inputNeurons.length; j++){
197+
sum += Math.pow(this.inputNeurons[j].getWeight(i), 2);
198+
}
199+
}
200+
return sum;
201+
};
202+
203+
Network.prototype.getRSquare = function(){
204+
var actuals = [];
205+
var outputs = [];
206+
for(var i = 0; i < this.testData.length; i++){
207+
this.feedForward(this.testData[i]);
208+
actuals.push(this.outputNeurons[0].getActual());
209+
outputs.push(this.outputNeurons[0].getOutput());
210+
}
211+
var meanActuals = 0;
212+
for(var i = 0; i < actuals.length; i++){
213+
meanActuals += actuals[i];
214+
}
215+
meanActuals = meanActuals / actuals.length;
216+
var sumOfSquares = 0;
217+
var sumOfSquaresOfResiduals = 0;
218+
for(var i = 0; i < actuals.length; i++){
219+
sumOfSquares += Math.pow(actuals[i] - meanActuals, 2);
220+
sumOfSquaresOfResiduals += Math.pow(actuals[i] - outputs[i], 2);
221+
}
222+
var rSquare = 1 - sumOfSquaresOfResiduals / sumOfSquares;
223+
return [rSquare, actuals, outputs];
224+
};
225+
226+
Network.prototype.setWeightDecay = function(weightDecay){
227+
this.weightDecay = weightDecay;
228+
};
229+
230+
Network.prototype.setMomentum = function(momentum){
231+
this.momentum = momentum;
232+
};
233+
234+
Network.prototype.setTestData = function(testData){
235+
this.testData = testData;
236+
};
237+
238+
Network.prototype.sigmoid = function(value){
239+
return 1 / (1 + Math.exp(-1 * value));
240+
};
241+
242+
Network.prototype.setOutputs = function(array){
243+
var i = 0;
244+
for(; i < this.inputNeurons.length-1; i++){ // Because of bias
245+
this.inputNeurons[i].setOutput(array[i]);
246+
}
247+
for(var j = 0; j < this.outputNeurons.length; j++){
248+
this.outputNeurons[j].setActual(array[i]);
249+
i++;
250+
}
251+
};
252+
253+
Network.prototype.shuffleArray = function(array) {
254+
for (var i = array.length - 1; i > 0; i--) {
255+
var j = Math.floor(Math.random() * (i + 1));
256+
var temp = array[i];
257+
array[i] = array[j];
258+
array[j] = temp;
259+
}
260+
};

‎Neuron.js

+78
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,78 @@
1+
function Neuron(){
2+
this.output;
3+
this.actual;
4+
this.error;
5+
this.weights;
6+
this.prevDeltas;
7+
}
8+
9+
Neuron.prototype.initNeuron = function(connectionNumber){
10+
var weights = [];
11+
var deltas = [];
12+
for(var j = 0; j < connectionNumber; j++){
13+
weights.push(this.getRandomFloatInRange(0.01, -0.01));
14+
deltas.push(0);
15+
}
16+
this.setWeights(weights);
17+
this.setPrevDeltas(deltas);
18+
};
19+
20+
Neuron.prototype.getRandomFloatInRange = function(max, min){
21+
return Math.random() * (max - min) + min;
22+
};
23+
24+
Neuron.prototype.setOutput = function(output){
25+
this.output = output;
26+
};
27+
28+
Neuron.prototype.getOutput = function(){
29+
return this.output;
30+
};
31+
32+
Neuron.prototype.setActual = function(actual){
33+
this.actual = actual;
34+
};
35+
36+
Neuron.prototype.getActual = function(){
37+
return this.actual;
38+
};
39+
40+
Neuron.prototype.setError = function(error){
41+
this.error = error;
42+
};
43+
44+
Neuron.prototype.getError = function(){
45+
return this.error;
46+
};
47+
48+
Neuron.prototype.setWeights = function(weights){
49+
this.weights = weights;
50+
};
51+
52+
Neuron.prototype.getWeights = function(){
53+
return this.weights;
54+
};
55+
56+
Neuron.prototype.setWeight = function(index, value){
57+
this.weights[index] = value;
58+
};
59+
60+
Neuron.prototype.getWeight = function(index){
61+
return this.weights[index];
62+
};
63+
64+
Neuron.prototype.setPrevDeltas = function(prevDeltas){
65+
this.prevDeltas = prevDeltas;
66+
};
67+
68+
Neuron.prototype.getPrevDeltas = function(){
69+
return this.prevDeltas;
70+
};
71+
72+
Neuron.prototype.setPrevDelta = function(index, value){
73+
this.prevDeltas[index] = value;
74+
};
75+
76+
Neuron.prototype.getPrevDelta = function(index){
77+
return this.prevDeltas[index];
78+
};

0 commit comments

Comments
 (0)