I am getting error exception in the thread, its compile correctly

Question

import java.util.*;
import java.io.*;
import java.lang.*;
import java.util.*;
import java.io.*;
* Class implementing a basic neural network.
public class NeuralNetwork1
double[] hidden;
double[] nethidden;
double[][] weight_hidden_input;
double[][]weight_output_hidden;
double[] netoutput;
double[] output;
double[] training_targets;
double[][] training_inputs;
double[] test_targets;
double[][] test_inputs;
double[] training_error;
double[] test_error;
double[] Deltaweight_hidden_input;
double[] Deltaweight_output_hidden;
double bias = 1;
int learningrate = 1;
int number_of_training_sets;
int number_of_targets;
int number_hidden;
int number_output;
int dataToUseForTraining = 10;
int numberOfDataToUseForValidation = 3;
int dataWindowSize =4;
int number_of_epics = 10;
int counter = 0;
Vector t = new Vector();
public static void main(String[] args){
NeuralNetwork1 n = new NeuralNetwork1();
public NeuralNetwork1()
GetData1 gd = new GetData1(dataToUseForTraining, numberOfDataToUseForValidation, dataWindowSize);
// initialize variables for network
hidden = new double[number_hidden];
nethidden = new double[number_hidden];
Deltaweight_hidden_input=new double[hidden.length];
Deltaweight_output_hidden = new double[netoutput.length];
weight_output_hidden = new double[1][number_hidden];//due to bias
weight_hidden_input=new double[(number_output*number_hidden)+number_hidden][dataWindowSize+1];
netoutput = new double[number_output];
training_targets = gd.getTargetData();
training_inputs = gd.getTrainingData();
test_targets = gd.getTestTargetData();
test_inputs = gd.getTestData();
training_error = new double[training_targets.length];
output = new double[training_targets.length];
//train network
train();
//predict
predict();
public void train() {
for(int i=0; i<number_of_epics; i++) {
System.out.println("inside train");
forwardPass();
backProp();
public void forwardPass() {
double netIH = 0;
double netHO = 0;
do {
//forward pass
//input to hidden
for(int i=0; i<hidden.length; i++) {
for(int j=1; j<training_inputs.length; j++) {
netIH = netIH + (weight_hidden_input[1][j])*(training_inputs[counter][j-1]);
netIH = netIH + (bias*weight_hidden_input[1][0]);
nethidden[i] = netIH;
hidden[i] = sigmoid(netIH);
//hidden to output
for(int i=0; i<netoutput.length; i++) {
for(int j=1; j<hidden.length; j++) {
netHO = netHO + hidden[j]*weight_output_hidden[i][j];
netHO = netHO + (bias* weight_output_hidden[0][hidden.length]);
output[i] = netHO;
output[counter] = sigmoid(netHO);
training_error[counter] = training_targets[counter]-output[counter];
//backProp here
counter++;
}while(counter<number_of_training_sets);
// sigmoid function
public double sigmoid(double x) {
return 1/(1+Math.exp(x));
public void backProp() {
//calculate the training_error for the output layer
for(int i=0; i<netoutput.length; i++) {
Deltaweight_output_hidden[i] = training_error[counter]*output*(1-output[i]);
double tempweight_output_hidden[][] = new double[weight_output_hidden.length][weight_output_hidden.length];
//calculate output_hidden weights adjustment
for(int n=0; n<weight_output_hidden.length; n++) {
for(int m=0; m<hidden.length; m++) {
tempweight_output_hidden[n][m] = learningrate*Deltaweight_output_hidden[n]*hidden[m];
double Total_DeltaWeights[] = new double[hidden.length];
//calculate the training_error for the hidden layer
for(int r=0; r<hidden.length; r++) {
for(int t=0; t<dataWindowSize; t++) {
Total_DeltaWeights[r] = Total_DeltaWeights[r] + Deltaweight_hidden_input[t]*weight_hidden_input[t][r];
Deltaweight_hidden_input[r] =Total_DeltaWeights[r]*(1-Total_DeltaWeights[r]);
System.out.println("Deltaweight_hidden_input["+r+"] = " );
double tempweight_hidden_input[][] = new double[weight_hidden_input.length][weight_hidden_input[0].length];
//calculate input layer weight changes
for(int n=0; n<hidden.length; n++) {
for(int w=0; w<weight_hidden_input[n].length; w++) {
tempweight_hidden_input[n][w] = -(learningrate*Deltaweight_hidden_input[n]*training_inputs[n][w]);
//weightUpdate
for(int v=0; v<weight_hidden_input.length; v++) {
for(int w=0; w<weight_hidden_input.length; w++) {
weight_hidden_input[v][w] = weight_hidden_input[v][w] + tempweight_hidden_input[v][w];
for(int v=0; v<weight_output_hidden.length; v++) {
for(int w=0; w<weight_output_hidden.length; w++) {
weight_output_hidden[v][w] = weight_output_hidden[v][w] + tempweight_output_hidden[v][w];
public void predict() {
class GetData1 extends NeuralNetwork1{
double trainingSet[][];
double targetSet[];
double testSet[][];
double testTargetSet[];
double crossValidationSet[][];
double validationTargetSet[];
Vector vData = new Vector();
double data[];
double td[];
double ts[];
double max;
double min;
int numberOfDataToUseForTraining;
int sizeOfDataWindow;
int numberOfDataToUseForValidation;
public static void main(String args[]) {
GetData1 g = new GetData1(10,5,2);
GetData1(int dataToUseForTraining, int numberOfDataToUseForValidation, int dataWindowSize) {
numberOfDataToUseForTraining = dataToUseForTraining;
sizeOfDataWindow = dataWindowSize;
this.numberOfDataToUseForValidation = numberOfDataToUseForValidation;
readDataFromFile();
normalizeData();
makeTrainingSet(0);
makeTestingSet();
makeCrossValidationSet(0);
public double[][] getTrainingData() {
makeTrainingSet(0);
return trainingSet;
public double[] getTargetData() {
makeTrainingSet(0);
return targetSet;
public double[][] getTestData() {
return testSet;
public double[] getTestTargetData() {
return testTargetSet;
public double[] getValidationTargetData() {
makeCrossValidationSet(0);
return validationTargetSet;
public double[][] getCrossValidationTargetSet() {
makeCrossValidationSet(0);
return crossValidationSet;
public double xmax() {
return max;
public double xmin() {
return min;
public void readDataFromFile() {
BufferedReader rawData = null;
try {
FileReader file = new FileReader("data.txt");
rawData = new BufferedReader(file);
} catch(FileNotFoundException x) {;}
try {
String line;
while( (line = rawData.readLine()) != null ) {
vData.add(line);
} catch(IOException x) {
x.printStackTrace();
public void normalizeData() {
int j=0;
data = new double[vData.size()];
for(int i=0; i<vData.size(); i++) {
data[i] = (double)Double.parseDouble(vData.get(i).toString());
double getTheMaxAndMin[] = new double[data.length];
for(int i=0; i<data.length; i++) {
getTheMaxAndMin[i] = data[i];
Arrays.sort(getTheMaxAndMin);
max = getTheMaxAndMin[getTheMaxAndMin.length-1];
min = getTheMaxAndMin[0];
for(int i=0; i<data.length; i++) {
data[i] = (data[i]-min)/(max-min);
public void makeTrainingSet(int whereToStart) {
//how much data to use for traiing - sizeo of data window + 1
int numberOfSteps = (numberOfDataToUseForTraining-sizeOfDataWindow+1)-whereToStart;
trainingSet = new double[numberOfSteps-1][sizeOfDataWindow];
targetSet = new double[numberOfSteps-1];
int j=0;
for(int i=0; i<numberOfSteps-1; i++) {
int k = 0;
int count = 0;
do {
trainingSet[i][k] = data[j+whereToStart];
k++;
j++;
count++;
} while(count < sizeOfDataWindow);
j = j - (sizeOfDataWindow - 1);
for(int i=sizeOfDataWindow; i<numberOfSteps+sizeOfDataWindow-1; i++) {
targetSet[i-sizeOfDataWindow] = data[i];
for(int i=0; i<trainingSet.length; i++) {
// trainingSet[i][trainingSet[i].length-1] = 1;
public void makeCrossValidationSet(int whereToStart) {
//how much data to use for traiing - sizeo of data window + 1
int numberOfSteps = (numberOfDataToUseForValidation-sizeOfDataWindow+1)-whereToStart;
crossValidationSet = new double[numberOfDataToUseForValidation+numberOfDataToUseForTraining][sizeOfDataWindow];
validationTargetSet = new double[numberOfDataToUseForValidation+numberOfDataToUseForTraining];
int j=0;
for(int i=0; i<crossValidationSet.length; i++) {
int k = 0;
int count = 0;
do {
crossValidationSet[i][k] = data[j+whereToStart];
k++;
j++;
count++;
} while(count < sizeOfDataWindow);
j = j - (sizeOfDataWindow - 1);
for(int i=0; i<validationTargetSet.length; i++) {
validationTargetSet[i] = data[i];
for(int i=0; i<crossValidationSet.length; i++) {
// crossValidationSet[i][crossValidationSet[i].length-1] = 1;
public void makeTestingSet() {
//how much data to use for traiing - sizeo of data window + 1
int numberOfSteps = data.length-sizeOfDataWindow+1;
testSet = new double[numberOfSteps-1][sizeOfDataWindow];
testTargetSet = new double[numberOfSteps-1];
int j=0;
for(int i=0; i<numberOfSteps-1; i++) {
int k = 0;
int count = 0;
do {
testSet[i][k] = data[j];
k++;
j++;
count++;
} while(count < sizeOfDataWindow);
j = j - (sizeOfDataWindow - 1);
for(int i=sizeOfDataWindow; i<numberOfSteps+sizeOfDataWindow-1; i++) {
testTargetSet[i-sizeOfDataWindow] = data[i];
for(int i=0; i<numberOfSteps-1; i++) {
// testSet[i][testSet[i].length-1] = 1;
public void makeTestingSet1() {
int numberOfSteps = data.length - sizeOfDataWindow;
testSet = new double[numberOfSteps][trainingSet[0].length];
for(int i=0; i<trainingSet.length; i++) {
for(int j=0; j<trainingSet[i].length; j++) {
testSet[i][j] = trainingSet[i][j];
testTargetSet = new double[data.length-sizeOfDataWindow];
for(int i=sizeOfDataWindow; i<numberOfSteps+sizeOfDataWindow-1; i++) {
testTargetSet[i-sizeOfDataWindow] = data[i];

Answer 1

wanjeri wrote:
sorry but what do u mean by code tagCode tag: Place one at the beginning and one at the end of your code and repost it. (It will make the code easier to read.)
As for the error you're getting, please post more information, ie, the stack trace.