Indian summer monsoon rainfall prediction using artificial neural network

Abstract

Forecasting the monsoon temporally is a major scientific issue in the field of monsoon meteorology. The ensemble of statistics and mathematics has increased the accuracy of forecasting of Indian summer monsoon rainfall (ISMR) up to some extent. But due to the nonlinear nature of ISMR, its forecasting accuracy is still below the satisfactory level. Mathematical and statistical models require complex computing power. Therefore, many researchers have paid attention to apply artificial neural network in ISMR forecasting. In this study, we have used feed-forward back-propagation neural network algorithm for ISMR forecasting. Based on this algorithm, we have proposed the five neural network architectures designated as BP1, BP2, $\ldots,$ BP5 using three layers of neurons (one input layer, one hidden layer and one output layer). Detail architecture of the neural networks is provided in this article. Time series data set of ISMR is obtained from Pathasarathy et al. (Theor Appl Climatol 49:217–224 1994) (1871–1994) and IITM (http://www.tropmet.res.in/, 2012) (1995–2010) for the period 1871–2010, for the months of June, July, August and September individually, and for the monsoon season (sum of June, July, August and September). The data set is trained and tested separately for each of the neural network architecture, viz., BP1–BP5. The forecasted results obtained for the training and testing data are then compared with existing model. Results clearly exhibit superiority of our model over the considered existing model. The seasonal rainfall values over India for next 5 years have also been predicted.

Appendices

Appendix 1

The training process of the neural networks, which comprises of 8 steps, is presented next.

Step 1:

Each input node $I_i ( i=1, 2, \ldots, n)$ receive the input data X _i and transmit to the hidden layer nodes $Y_i (i=1, 2, \ldots, n).$

Step 2:

The net input to each hidden node $Y_{input_j} (j=1, 2, \ldots, n)$ is calculated as:

$$ Y_{input_j}= b_{oj}+\sum_{i}X_ib_{ij}, $$

where b _oj is the bias on jth hidden node, and b _ij is the bias on connecting the ith input layer node to the jth node of the hidden layer.

Step 3:

Compute the output of the hidden node by using the AF as:

$$ Y_j=AF(Y_{input_j}), $$

and, this signal is sent to the output layer node from the hidden layer nodes.

Step 4:

For output node O, the net input is calculated as:

$$ O_{input_k}=d_{oj}+\sum_{j}Y_jd_{jk}, $$

where d _oj is the bias on jth output node, and d _jk is the bias on connecting the jth hidden layer node to the kth node of the output layer.

Step 5:

Compute the output information by applying the AF as:

$$ O_k=AF(O_{input_k}) $$

Step 6:

Adjust the weight d _jk for error correction that is occurred due to output node O _k . This information is back-propagated to the hidden layer nodes $Y_{input_j} (j=1, 2, \ldots, 6)$ that provide again information on output layer node O _k .

Step 7:

Due to back-propagation of error to the hidden layer nodes $Y_{input_j} (j=1, 2, \ldots, 6)$ which may be large or small in amount, adjust the weight b _ij for error correction repeatedly until the error is minimized.

Step 8:

When the calculated output is equal to the desired output, stop the whole steps of training process.

Appendix 2

The testing process of the neural networks, which comprises of 3 steps, is presented next.

Step 1:

Use the weights for testing process, which are obtained just after the neural network is completely trained.

Step 2:

The net input to each hidden node $Y_{input_j} (j=1, 2, \ldots, n)$ is:

$$ Y_{input_j}= b_{oj}+\sum_{i}X_ib_{ij}, $$

where b _oj is the bias on jth hidden node, and b _ij is the bias on connecting the ith input layer node to the jth node of the hidden layer, and the output of the hidden node is:

$$ Y_j=AF(Y_{input_j}) $$

Step 3:

For output node O, the net input is:

$$ O_{input_k}=d_{oj}+\sum_{j}Y_jd_{jk}, $$

where d _oj is the bias on jth output node, and d _jk is the bias on connecting the jth hidden layer node to the kth node of the output layer, and the output information is:

$$ O_k=AF(O_{input_k}) $$