Charts can be drawn in Java by using the freely available package JFreeChart (http://www.jfree.org/jfreechart/). This package is attached with this chapter's source code. So, we designed a class called Chart. It implements methods basically for plotting data series by making calls to natively implemented methods of the JFreeChart classes. The following table shows a list of methods contained in this class:

public enum ChartPlotTypeENUM {
  FULL_DATA, COMPARISON;
}

public void plotXYData(Object[] vector, String chartTitle, String xAxisLabel, String yAxisLabel)

public void plotXYData(double[][] matrix, String chartTitle, String xAxisLabel, String yAxisLabel, ChartPlotTypeENUM chartPlotType)

private String selectComparisonSeriesName(int index)

private String selectTemperatureSeriesName(int index)

To work with data files, we have to implement a class called Data. It currently performs reads from the so-called CSV format, which is suitable for data import and export. This class also performs preprocessing on the data by means of normalization.

private String path;

private String fileName;

public enum NormalizationTypesENUM {
  MAX_MIN, MAX_MIN_EQUALIZED; 
}

public Data(String path, String fileName)

public Data( )

public double[][] rawData2Matrix(Data r) throws IOException

private String defineAbsoluteFilePath(Data r) throws IOException

public double[][] normalize(double[][] rawMatrix, NormalizationTypesENUM normType)

public double[][] denormalize(double[][] rawMatrix, double[][] matrixNorm, NormalizationTypesENUM normType)

public double[][] joinArrays(ArrayList<double[][]> listOfArraysToJoin)

To forecast weather, we collected daily data from the Brazilian Institute of Meteorology (INMET). The data was measured from a Brazilian city located in the Amazon region.

From the eight variables available at the INMET website, five were selected for use in this project, where the average of the maximum and the minimum temperature became the mean temperature variable. The neural network was trained to forecast the average temperature. So, the structure of the neural network is as shown in the following figure:

We designed a class called Weather exclusively for the weather case. It only has a static main method and is solely aimed at reading the weather data files, creating and training a neural network with this data, and plotting the error for validation. Let's take a glance at how the data files are read inside this class:

   Data weatherDataInput  = new Data( "data", "inmet_13_14_input.csv" );
  Data weatherDataOutput = new Data( "data", "inmet_13_14_output.csv" );
    
  //sets the normalisation type  
  NormalizationTypesENUM NORMALIZATION_TYPE = Data.NormalizationTypesENUM.MAX_MIN_EQUALIZED;
    
  try {
    double[][] matrixInput = weatherDataInput.rawData2Matrix( weatherDataInput );
    double[][] matrixOutput = weatherDataOutput.rawData2Matrix( weatherDataOutput );
      
    //normalise the data      
    double[][] matrixInputNorm  = weatherDataInput.normalize( matrixInput, NORMALIZATION_TYPE );
    double[][] matrixOutputNorm = weatherDataOutput.normalize( matrixOutput, NORMALIZATION_TYPE );

Then, the main method builds a neural network with four hidden neurons and sets the training dataset, as shown in the following code:

  NeuralNet n1 = new NeuralNet();
  n1 = n1.initNet(4, 1, 4, 1);
      
  n1.setTrainSet( matrixInputNorm );
  n1.setRealMatrixOutputSet( matrixOutputNorm );
      
  n1.setMaxEpochs( 1000 );
  n1.setTargetError( 0.00001 );
  n1.setLearningRate( 0.5 );
  n1.setTrainType( TrainingTypesENUM.BACKPROPAGATION );
  n1.setActivationFnc( ActivationFncENUM.SIGLOG );
      n1.setActivationFncOutputLayer(ActivationFncENUM.LINEAR);
      
  NeuralNet n1Trained = new NeuralNet();
      
  n1Trained = n1.trainNet( n1 );
      
  System.out.println();

Here, the network is trained, and then, the charts of the error are plotted. The following lines show how the chart class is used:

  Chart c1 = new Chart();
  c1.plotXYData( n1.getListOfMSE().toArray(), "MSE Error", "Epochs", "MSE Value" );
      
  //TRAINING:
  double[][] matrixOutputRNA = n1Trained.getNetOutputValues( n1Trained );
  double[][] matrixOutputRNADenorm  = new Data().denormalize( matrixOutput, matrixOutputRNA, NORMALIZATION_TYPE);
      
  ArrayList<double[][]> listOfArraysToJoin = new ArrayList<double[][]>();
  listOfArraysToJoin.add( matrixOutput );
  listOfArraysToJoin.add( matrixOutputRNADenorm );
      
  double[][] matrixOutputsJoined = new Data().joinArrays( listOfArraysToJoin );
      
  Chart c2 = new Chart();
  c2.plotXYData( matrixOutputsJoined, "Real x Estimated - Training Data", "Weather Data", "Temperature (Celsius)", Chart.ChartPlotTypeENUM.COMPARISON );

In the following graph, it is possible to see the MSE training error plotted. The x-axis represents 1000 points (epochs of training), and the y-axis shows the variation of the MSE values. It is noticed that before the 100th epoch, the MSE value establishes.

Another graph is displayed next. It shows a comparison between the real (red line) and the estimated (blue line) average temperature. Dotted black lines symbolize the margins of error (-1.0 °C and +1.0 °C).