/*
* MLP.java
*
* This class implements a multi layer perceptron network with
* logistic activation functions and backpropagation algorithm.
*
* @author Juliano Jinzenji Duque <julianojd@gmail.com>
* @author Luiz Eduardo Virgilio da Silva <luizeduardovs@gmail.com>
*
* CSIM
* Computing on Signals and Images on Medicine Group
* University of Sao Paulo
* Ribeirao Preto - SP - Brazil
*/
public class MLP {
private int nInputs, nHidden, nOutput; // Number of neurons in each layer
private double[/* i */] input, hidden, output;
private double[/* j */][/* i */] weightL1, // Weights values of connection between neuron "j"
// from hidden layer and "i" from input layer
weigthL2; // Weights values of connection between neuron "j"
// from output layer and "i" from hidden layer
private double learningRate = 0.5;
/**
* Creates a new instance of MLP.
*
* @param nInput number of neurons at input layer
* @param nHidden number of neurons at hidden layer
* @param nOutput number of neurons at output layer
*/
public MLP(int nInput, int nHidden, int nOutput) {
this.nInputs = nInput;
this.nHidden = nHidden;
this.nOutput = nOutput;
input = new double[nInput+1];
hidden = new double[nHidden+1];
output = new double[nOutput+1];
weightL1 = new double[nHidden+1][nInput+1];
weigthL2 = new double[nOutput+1][nHidden+1];
// Initialize weigths
generateRandomWeights();
}
/**
* Set the learning rate for training.
*
* @param lr learning rate
*/
public void setLearningRate(double lr) {
learningRate = lr;
}
/**
* Initialize weights with random values between interval [-0.5,0.5[
*/
private void generateRandomWeights() {
for(int j=1; j<=nHidden; j++)
for(int i=0; i<=nInputs; i++) {
weightL1[j][i] = Math.random() - 0.5;
}
for(int j=1; j<=nOutput; j++)
for(int i=0; i<=nHidden; i++) {
weigthL2[j][i] = Math.random() - 0.5;
}
}
/**
* Train the network with given a pattern.
* The pattern is passed through the network and the weights are adjusted
* by backpropagation, considering the desired output.
*
* @param pattern the pattern to be learned
* @param desiredOutput the desired output for pattern
* @return the network output before weights adjusting
*/
public double[] train(double[] pattern, double[] desiredOutput) {
double[] output = passNet(pattern);
backpropagation(desiredOutput);
return output;
}
/**
* Passes a pattern through the network. Activatinon functions are logistics.
*
* @param pattern pattern to be passed through the network
* @return the network output for this pattern
*/
public double[] passNet(double[] pattern) {
for(int i=0; i<nInputs; i++) {
input[i+1] = pattern[i];
}
// Set bias
input[0] = 1.0;
hidden[0] = 1.0;
// Passing through hidden layer
for(int j=1; j<=nHidden; j++) {
hidden[j] = 0.0;
for(int i=0; i<=nInputs; i++) {
hidden[j] += weightL1[j][i] * input[i];
}
hidden[j] = 1.0/(1.0+Math.exp(-hidden[j]));
}
// Passing through output layer
for(int j=1; j<=nOutput; j++) {
output[j] = 0.0;
for(int i=0; i<=nHidden; i++) {
output[j] += weigthL2[j][i] * hidden[i];
}
output[j] = 1.0/(1+0+Math.exp(-output[j]));
}
return output;
}
/**
* This method adjust weigths considering error backpropagation. The desired
* output is compared with the last network output and weights are adjusted
* using the choosen learn rate.
*
* @param desiredOutput desired output for the last given pattern
*/
private void backpropagation(double[] desiredOutput) {
double[] errorL2 = new double[nOutput+1];
double[] errorL1 = new double[nHidden+1];
double Esum = 0.0;
for(int i=1; i<=nOutput; i++) // Layer 2 error gradient
errorL2[i] = output[i] * (1.0-output[i]) * (desiredOutput[i-1]-output[i]);
for(int i=0; i<=nHidden; i++) { // Layer 1 error gradient
for(int j=1; j<=nOutput; j++)
Esum += weigthL2[j][i] * errorL2[j];
errorL1[i] = hidden[i] * (1.0-hidden[i]) * Esum;
Esum = 0.0;
}
for(int j=1; j<=nOutput; j++)
for(int i=0; i<=nHidden; i++)
weigthL2[j][i] += learningRate * errorL2[j] * hidden[i];
for(int j=1; j<=nHidden; j++)
for(int i=0; i<=nInputs; i++)
weightL1[j][i] += learningRate * errorL1[j] * input[i];
}
}