Prediction intervals<\/strong> provide a measure of uncertainty for predictions on regression problems.<\/p>\n For example, a 95% prediction interval indicates that 95 out of 100 times, the true value will fall between the lower and upper values of the range. This is different from a simple point prediction that might represent the center of the uncertainty interval.<\/p>\n There are no standard techniques for calculating a prediction interval for deep learning neural networks on regression predictive modeling problems. Nevertheless, a quick and dirty prediction interval can be estimated using an ensemble of models that, in turn, provide a distribution of point predictions from which an interval can be calculated.<\/p>\n In this tutorial, you will discover how to calculate a prediction interval for deep learning neural networks.<\/p>\n After completing this tutorial, you will know:<\/p>\n Let\u2019s get started.<\/p>\n Prediction Intervals for Deep Learning Neural Networks This tutorial is divided into three parts; they are:<\/p>\n Generally, predictive models for regression problems (i.e. predicting a numerical value) make a point prediction.<\/p>\n This means they predict a single value but do not give any indication of the uncertainty about the prediction.<\/p>\n By definition, a prediction is an estimate or an approximation and contains some uncertainty. The uncertainty comes from the errors in the model itself and noise in the input data. The model is an approximation of the relationship between the input variables and the output variables.<\/p>\n A prediction interval is a quantification of the uncertainty on a prediction.<\/p>\n It provides a probabilistic upper and lower bounds on the estimate of an outcome variable.<\/p>\n A prediction interval for a single future observation is an interval that will, with a specified degree of confidence, contain a future randomly selected observation from a distribution.<\/p>\n<\/blockquote>\n \u2014 Page 27, Statistical Intervals: A Guide for Practitioners and Researchers<\/a>, 2017.<\/p>\n Prediction intervals are most commonly used when making predictions or forecasts with a regression model, where a quantity is being predicted.<\/p>\n The prediction interval surrounds the prediction made by the model and hopefully covers the range of the true outcome.<\/p>\n For more on prediction intervals in general, see the tutorial:<\/p>\n Now that we are familiar with what a prediction interval is, we can consider how we might calculate an interval for a neural network. Let\u2019s start by defining a regression problem and a neural network model to address it.<\/p>\n In this section, we will define a regression predictive modeling problem and a neural network model to address it.<\/p>\n First, let\u2019s introduce a standard regression dataset. We will use the housing dataset.<\/p>\n The housing dataset is a standard machine learning dataset comprising 506 rows of data with 13 numerical input variables and a numerical target variable.<\/p>\n Using a test harness of repeated stratified 10-fold cross-validation with three repeats, a naive model can achieve a mean absolute error (MAE) of about 6.6. A top-performing model<\/a> can achieve a MAE on this same test harness of about 1.9. This provides the bounds of expected performance on this dataset.<\/p>\n The dataset involves predicting the house price given details of the house\u2019s suburb in the American city of Boston.<\/p>\n No need to download the dataset; we will download it automatically as part of our worked examples.<\/p>\n The example below downloads and loads the dataset as a Pandas DataFrame and summarizes the shape of the dataset and the first five rows of data.<\/p>\n Running the example confirms the 506 rows of data and 13 input variables and a single numeric target variable (14 in total). We can also see that all input variables are numeric.<\/p>\n Next, we can prepare the dataset for modeling.<\/p>\n First, the dataset can be split into input and output columns, and then the rows can be split into train and test datasets<\/a>.<\/p>\n In this case, we will use approximately 67% of the rows to train the model and the remaining 33% to estimate the performance of the model.<\/p>\n You can learn more about the train-test split in this tutorial:<\/p>\n We will then scale all input columns (variables) to have the range 0-1, called data normalization, which is a good practice when working with neural network models.<\/p>\n You can learn more about normalizing input data with the MinMaxScaler in this tutorial:<\/p>\n The complete example of preparing the data for modeling is listed below.<\/p>\n Running the example loads the dataset as before, then splits the columns into input and output elements, rows into train and test sets, and finally scales all input variables to the range [0,1]<\/p>\n The shape of the train and test sets is printed, showing we have 339 rows to train the model and 167 to evaluate it.<\/p>\n Next, we can define, train and evaluate a Multilayer Perceptron (MLP) model on the dataset.<\/p>\n We will define a simple model with two hidden layers and an output layer that predicts a numeric value. We will use the ReLU activation function<\/a> and \u201che<\/em>\u201d weight initialization, which are a good practice.<\/p>\n The number of nodes in each hidden layer was chosen after a little trial and error.<\/p>\n We will use the efficient Adam version of stochastic gradient descent with close to default learning rate and momentum values and fit the model using the mean squared error (MSE) loss function, a standard for regression predictive modeling problems.<\/p>\n You can learn more about the Adam optimization algorithm in this tutorial:<\/p>\n The model will then be fit for 300 epochs with a batch size of 16 samples. This configuration was chosen after a little trial and error.<\/p>\n You can learn more about batches and epochs in this tutorial:<\/p>\n Finally, the model can be used to make predictions on the test dataset and we can evaluate the predictions by comparing them to the expected values in the test set and calculate the mean absolute error (MAE), a useful measure of model performance.<\/p>\n Tying this together, the complete example is listed below.<\/p>\n Running the example loads and prepares the dataset, defines and fits the MLP model on the training dataset, and evaluates its performance on the test set.<\/p>\n Note<\/strong>: Your results may vary<\/a> given the stochastic nature of the algorithm or evaluation procedure, or differences in numerical precision. Consider running the example a few times and compare the average outcome.<\/p>\n In this case, we can see that the model achieves a mean absolute error of approximately 2.3, which is better than a naive model and getting close to an optimal model.<\/p>\n No doubt we could achieve near-optimal performance with further tuning of the model, but this is good enough for our investigation of prediction intervals.<\/p>\n Next, let\u2019s look at how we might calculate a prediction interval using our MLP model on the housing dataset.<\/p>\n In this section, we will develop a prediction interval using the regression problem and model developed in the previous section.<\/p>\n Calculating prediction intervals for nonlinear regression algorithms like neural networks is challenging compared to linear methods like linear regression where the prediction interval calculation is trivial. There is no standard technique.<\/p>\n There are many ways to calculate an effective prediction interval for neural network models. I recommend some of the papers listed in the \u201cfurther reading<\/em>\u201d section to learn more.<\/p>\n In this tutorial, we will use a very simple approach that has plenty of room for extension. I refer to it as \u201cquick and dirty<\/em>\u201d because it is fast and easy to calculate, but is limited.<\/p>\n It involves fitting multiple final models (e.g. 10 to 30). The distribution of the point predictions from ensemble members is then used to calculate both a point prediction and a prediction interval.<\/p>\n For example, a point prediction can be taken as the mean of the point predictions from ensemble members, and a 95% prediction interval can be taken as 1.96 standard deviations<\/a> from the mean.<\/p>\n This is a simple Gaussian prediction interval, although alternatives could be used, such as the min and max of the point predictions. Alternatively, the bootstrap method could be used to train each ensemble member on a different bootstrap sample and the 2.5th and 97.5th percentiles of the point predictions can be used as prediction intervals.<\/p>\n For more on the bootstrap method, see the tutorial:<\/p>\n These extensions are left as exercises; we will stick with the simple Gaussian prediction interval.<\/p>\n Let\u2019s assume that the training dataset, defined in the previous section, is the entire dataset and we are training a final model or models on this entire dataset. We can then make predictions with prediction intervals on the test set and evaluate how effective the interval might be in the future.<\/p>\n We can simplify the code by dividing the elements developed in the previous section into functions.<\/p>\n First, let\u2019s define a function for loading and preparing a regression dataset defined by a URL.<\/p>\n Next, we can define a function that will define and train an MLP model given the training dataset, then return the fit model ready for making predictions.<\/p>\n We require multiple models to make point predictions that will define a distribution of point predictions from which we can estimate the interval.<\/p>\n As such, we will need to fit multiple models on the training dataset. Each model must be different so that it makes different predictions. This can be achieved given the stochastic nature of training MLP models, given the random initial weights, and given the use of the stochastic gradient descent optimization algorithm.<\/p>\n The more models, the better the point predictions will estimate the capability of the model. I would recommend at least 10 models, and perhaps not much benefit beyond 30 models.<\/p>\n The function below fits an ensemble of models and stores them in a list that is returned.<\/p>\n For interest, each fit model is also evaluated on the test set which is reported after each model is fit. We would expect that each model will have a slightly different estimated performance on the hold-out test set and the reported scores will help us confirm this expectation.<\/p>\n Finally, we can use the trained ensemble of models to make point predictions, which can be summarized into a prediction interval.<\/p>\n The function below implements this. First, each model makes a point prediction on the input data, then the 95% prediction interval is calculated and the lower, mean, and upper values of the interval are returned.<\/p>\n The function is designed to take a single row as input, but could easily be adapted for multiple rows.<\/p>\n Finally, we can call these functions.<\/p>\n First, the dataset is loaded and prepared, then the ensemble is defined and fit.<\/p>\n We can then use a single row of data from the test set and make a prediction with a prediction interval, the results of which are then reported.<\/p>\n We also report the expected value which we would expect would be covered by the prediction interval (perhaps close to 95% of the time; this is not entirely accurate, but is a rough approximation).<\/p>\n Tying this together, the complete example of making predictions with a prediction interval with a Multilayer Perceptron neural network is listed below.<\/p>\n Running the example fits each ensemble member in turn and reports its estimated performance on the hold out tests set; finally, a single prediction with prediction interval is made and reported.<\/p>\n Note<\/strong>: Your results may vary<\/a> given the stochastic nature of the algorithm or evaluation procedure, or differences in numerical precision. Consider running the example a few times and compare the average outcome.<\/p>\n In this case, we can see that each model has a slightly different performance, confirming our expectation that the models are indeed different.<\/p>\n Finally, we can see that the ensemble made a point prediction of about 30.5 with a 95% prediction interval of [26.287, 34.822]. We can also see that the true value was 28.2 and that the interval does capture this value, which is great.<\/p>\n This is a quick and dirty technique for making predictions with a prediction interval for neural networks, as we discussed above.<\/p>\n There are easy extensions such as using the bootstrap method applied to point predictions that may be more reliable, and more advanced techniques described in some of the papers listed below that I recommend that you explore.<\/p>\n This section provides more resources on the topic if you are looking to go deeper.<\/p>\n In this tutorial, you discovered how to calculate a prediction interval for deep learning neural networks.<\/p>\n Specifically, you learned:<\/p>\n Do you have any questions?<\/strong> The post Prediction Intervals for Deep Learning Neural Networks<\/a> appeared first on Machine Learning Mastery<\/a>.<\/p>\n<\/div>\n Go to Source<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"\n
![\"Prediction](\"https:\/\/machinelearningmastery.com\/wp-content\/uploads\/2021\/05\/Prediction-Intervals-for-Deep-Learning-Neural-Networks.jpg\")
<\/p>\n
Photo by eugene_o<\/a>, some rights reserved.<\/p>\n<\/div>\nTutorial Overview<\/h2>\n
\n
Prediction Interval<\/h2>\n
\n
\n
Neural Network for Regression<\/h2>\n
\n
# load and summarize the housing dataset\r\nfrom pandas import read_csv\r\nfrom matplotlib import pyplot\r\n# load dataset\r\nurl = 'https:\/\/raw.githubusercontent.com\/jbrownlee\/Datasets\/master\/housing.csv'\r\ndataframe = read_csv(url, header=None)\r\n# summarize shape\r\nprint(dataframe.shape)\r\n# summarize first few lines\r\nprint(dataframe.head())<\/pre>\n
(506, 14)\r\n 0 1 2 3 4 5 ... 8 9 10 11 12 13\r\n0 0.00632 18.0 2.31 0 0.538 6.575 ... 1 296.0 15.3 396.90 4.98 24.0\r\n1 0.02731 0.0 7.07 0 0.469 6.421 ... 2 242.0 17.8 396.90 9.14 21.6\r\n2 0.02729 0.0 7.07 0 0.469 7.185 ... 2 242.0 17.8 392.83 4.03 34.7\r\n3 0.03237 0.0 2.18 0 0.458 6.998 ... 3 222.0 18.7 394.63 2.94 33.4\r\n4 0.06905 0.0 2.18 0 0.458 7.147 ... 3 222.0 18.7 396.90 5.33 36.2\r\n\r\n[5 rows x 14 columns]<\/pre>\n
...\r\n# split into input and output values\r\nX, y = values[:,:-1], values[:,-1]\r\n# split into train and test sets\r\nX_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.67)<\/pre>\n
\n
...\r\n# scale input data\r\nscaler = MinMaxScaler()\r\nscaler.fit(X_train)\r\nX_train = scaler.transform(X_train)\r\nX_test = scaler.transform(X_test)<\/pre>\n
\n
# load and prepare the dataset for modeling\r\nfrom pandas import read_csv\r\nfrom sklearn.model_selection import train_test_split\r\nfrom sklearn.preprocessing import MinMaxScaler\r\n# load dataset\r\nurl = 'https:\/\/raw.githubusercontent.com\/jbrownlee\/Datasets\/master\/housing.csv'\r\ndataframe = read_csv(url, header=None)\r\nvalues = dataframe.values\r\n# split into input and output values\r\nX, y = values[:,:-1], values[:,-1]\r\n# split into train and test sets\r\nX_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.67)\r\n# scale input data\r\nscaler = MinMaxScaler()\r\nscaler.fit(X_train)\r\nX_train = scaler.transform(X_train)\r\nX_test = scaler.transform(X_test)\r\n# summarize\r\nprint(X_train.shape, X_test.shape, y_train.shape, y_test.shape)<\/pre>\n
(339, 13) (167, 13) (339,) (167,)<\/pre>\n
...\r\n# define neural network model\r\nfeatures = X_train.shape[1]\r\nmodel = Sequential()\r\nmodel.add(Dense(20, kernel_initializer='he_normal', activation='relu', input_dim=features))\r\nmodel.add(Dense(5, kernel_initializer='he_normal', activation='relu'))\r\nmodel.add(Dense(1))<\/pre>\n
...\r\n# compile the model and specify loss and optimizer\r\nopt = Adam(learning_rate=0.01, beta_1=0.85, beta_2=0.999)\r\nmodel.compile(optimizer=opt, loss='mse')<\/pre>\n
\n
...\r\n# fit the model on the training dataset\r\nmodel.fit(X_train, y_train, verbose=2, epochs=300, batch_size=16)<\/pre>\n
\n
...\r\n# make predictions on the test set\r\nyhat = model.predict(X_test, verbose=0)\r\n# calculate the average error in the predictions\r\nmae = mean_absolute_error(y_test, yhat)\r\nprint('MAE: %.3f' % mae)<\/pre>\n# train and evaluate a multilayer perceptron neural network on the housing regression dataset\r\nfrom pandas import read_csv\r\nfrom sklearn.model_selection import train_test_split\r\nfrom sklearn.metrics import mean_absolute_error\r\nfrom sklearn.preprocessing import MinMaxScaler\r\nfrom tensorflow.keras.models import Sequential\r\nfrom tensorflow.keras.layers import Dense\r\nfrom tensorflow.keras.optimizers import Adam\r\n# load dataset\r\nurl = 'https:\/\/raw.githubusercontent.com\/jbrownlee\/Datasets\/master\/housing.csv'\r\ndataframe = read_csv(url, header=None)\r\nvalues = dataframe.values\r\n# split into input and output values\r\nX, y = values[:, :-1], values[:,-1]\r\n# split into train and test sets\r\nX_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.67, random_state=1)\r\n# scale input data\r\nscaler = MinMaxScaler()\r\nscaler.fit(X_train)\r\nX_train = scaler.transform(X_train)\r\nX_test = scaler.transform(X_test)\r\n# define neural network model\r\nfeatures = X_train.shape[1]\r\nmodel = Sequential()\r\nmodel.add(Dense(20, kernel_initializer='he_normal', activation='relu', input_dim=features))\r\nmodel.add(Dense(5, kernel_initializer='he_normal', activation='relu'))\r\nmodel.add(Dense(1))\r\n# compile the model and specify loss and optimizer\r\nopt = Adam(learning_rate=0.01, beta_1=0.85, beta_2=0.999)\r\nmodel.compile(optimizer=opt, loss='mse')\r\n# fit the model on the training dataset\r\nmodel.fit(X_train, y_train, verbose=2, epochs=300, batch_size=16)\r\n# make predictions on the test set\r\nyhat = model.predict(X_test, verbose=0)\r\n# calculate the average error in the predictions\r\nmae = mean_absolute_error(y_test, yhat)\r\nprint('MAE: %.3f' % mae)<\/pre>\n...\r\nEpoch 296\/300\r\n22\/22 - 0s - loss: 7.1741\r\nEpoch 297\/300\r\n22\/22 - 0s - loss: 6.8044\r\nEpoch 298\/300\r\n22\/22 - 0s - loss: 6.8623\r\nEpoch 299\/300\r\n22\/22 - 0s - loss: 7.7010\r\nEpoch 300\/300\r\n22\/22 - 0s - loss: 6.5374\r\nMAE: 2.300<\/pre>\n
Neural Network Prediction Interval<\/h2>\n
\n
# load and prepare the dataset\r\ndef load_dataset(url):\r\n\tdataframe = read_csv(url, header=None)\r\n\tvalues = dataframe.values\r\n\t# split into input and output values\r\n\tX, y = values[:, :-1], values[:,-1]\r\n\t# split into train and test sets\r\n\tX_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.67, random_state=1)\r\n\t# scale input data\r\n\tscaler = MinMaxScaler()\r\n\tscaler.fit(X_train)\r\n\tX_train = scaler.transform(X_train)\r\n\tX_test = scaler.transform(X_test)\r\n\treturn X_train, X_test, y_train, y_test<\/pre>\n
# define and fit the model\r\ndef fit_model(X_train, y_train):\r\n\t# define neural network model\r\n\tfeatures = X_train.shape[1]\r\n\tmodel = Sequential()\r\n\tmodel.add(Dense(20, kernel_initializer='he_normal', activation='relu', input_dim=features))\r\n\tmodel.add(Dense(5, kernel_initializer='he_normal', activation='relu'))\r\n\tmodel.add(Dense(1))\r\n\t# compile the model and specify loss and optimizer\r\n\topt = Adam(learning_rate=0.01, beta_1=0.85, beta_2=0.999)\r\n\tmodel.compile(optimizer=opt, loss='mse')\r\n\t# fit the model on the training dataset\r\n\tmodel.fit(X_train, y_train, verbose=0, epochs=300, batch_size=16)\r\n\treturn model<\/pre>\n
# fit an ensemble of models\r\ndef fit_ensemble(n_members, X_train, X_test, y_train, y_test):\r\n\tensemble = list()\r\n\tfor i in range(n_members):\r\n\t\t# define and fit the model on the training set\r\n\t\tmodel = fit_model(X_train, y_train)\r\n\t\t# evaluate model on the test set\r\n\t\tyhat = model.predict(X_test, verbose=0)\r\n\t\tmae = mean_absolute_error(y_test, yhat)\r\n\t\tprint('>%d, MAE: %.3f' % (i+1, mae))\r\n\t\t# store the model\r\n\t\tensemble.append(model)\r\n\treturn ensemble<\/pre>\n# make predictions with the ensemble and calculate a prediction interval\r\ndef predict_with_pi(ensemble, X):\r\n\t# make predictions\r\n\tyhat = [model.predict(X, verbose=0) for model in ensemble]\r\n\tyhat = asarray(yhat)\r\n\t# calculate 95% gaussian prediction interval\r\n\tinterval = 1.96 * yhat.std()\r\n\tlower, upper = yhat.mean() - interval, yhat.mean() + interval\r\n\treturn lower, yhat.mean(), upper<\/pre>\n
...\r\n# load dataset\r\nurl = 'https:\/\/raw.githubusercontent.com\/jbrownlee\/Datasets\/master\/housing.csv'\r\nX_train, X_test, y_train, y_test = load_dataset(url)\r\n# fit ensemble\r\nn_members = 30\r\nensemble = fit_ensemble(n_members, X_train, X_test, y_train, y_test)<\/pre>\n
...\r\n# make predictions with prediction interval\r\nnewX = asarray([X_test[0, :]])\r\nlower, mean, upper = predict_with_pi(ensemble, newX)\r\nprint('Point prediction: %.3f' % mean)\r\nprint('95%% prediction interval: [%.3f, %.3f]' % (lower, upper))\r\nprint('True value: %.3f' % y_test[0])<\/pre>\n# prediction interval for mlps on the housing regression dataset\r\nfrom numpy import asarray\r\nfrom pandas import read_csv\r\nfrom sklearn.model_selection import train_test_split\r\nfrom sklearn.metrics import mean_absolute_error\r\nfrom sklearn.preprocessing import MinMaxScaler\r\nfrom tensorflow.keras.models import Sequential\r\nfrom tensorflow.keras.layers import Dense\r\nfrom tensorflow.keras.optimizers import Adam\r\n\r\n# load and prepare the dataset\r\ndef load_dataset(url):\r\n\tdataframe = read_csv(url, header=None)\r\n\tvalues = dataframe.values\r\n\t# split into input and output values\r\n\tX, y = values[:, :-1], values[:,-1]\r\n\t# split into train and test sets\r\n\tX_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.67, random_state=1)\r\n\t# scale input data\r\n\tscaler = MinMaxScaler()\r\n\tscaler.fit(X_train)\r\n\tX_train = scaler.transform(X_train)\r\n\tX_test = scaler.transform(X_test)\r\n\treturn X_train, X_test, y_train, y_test\r\n\r\n# define and fit the model\r\ndef fit_model(X_train, y_train):\r\n\t# define neural network model\r\n\tfeatures = X_train.shape[1]\r\n\tmodel = Sequential()\r\n\tmodel.add(Dense(20, kernel_initializer='he_normal', activation='relu', input_dim=features))\r\n\tmodel.add(Dense(5, kernel_initializer='he_normal', activation='relu'))\r\n\tmodel.add(Dense(1))\r\n\t# compile the model and specify loss and optimizer\r\n\topt = Adam(learning_rate=0.01, beta_1=0.85, beta_2=0.999)\r\n\tmodel.compile(optimizer=opt, loss='mse')\r\n\t# fit the model on the training dataset\r\n\tmodel.fit(X_train, y_train, verbose=0, epochs=300, batch_size=16)\r\n\treturn model\r\n\r\n# fit an ensemble of models\r\ndef fit_ensemble(n_members, X_train, X_test, y_train, y_test):\r\n\tensemble = list()\r\n\tfor i in range(n_members):\r\n\t\t# define and fit the model on the training set\r\n\t\tmodel = fit_model(X_train, y_train)\r\n\t\t# evaluate model on the test set\r\n\t\tyhat = model.predict(X_test, verbose=0)\r\n\t\tmae = mean_absolute_error(y_test, yhat)\r\n\t\tprint('>%d, MAE: %.3f' % (i+1, mae))\r\n\t\t# store the model\r\n\t\tensemble.append(model)\r\n\treturn ensemble\r\n\r\n# make predictions with the ensemble and calculate a prediction interval\r\ndef predict_with_pi(ensemble, X):\r\n\t# make predictions\r\n\tyhat = [model.predict(X, verbose=0) for model in ensemble]\r\n\tyhat = asarray(yhat)\r\n\t# calculate 95% gaussian prediction interval\r\n\tinterval = 1.96 * yhat.std()\r\n\tlower, upper = yhat.mean() - interval, yhat.mean() + interval\r\n\treturn lower, yhat.mean(), upper\r\n\r\n# load dataset\r\nurl = 'https:\/\/raw.githubusercontent.com\/jbrownlee\/Datasets\/master\/housing.csv'\r\nX_train, X_test, y_train, y_test = load_dataset(url)\r\n# fit ensemble\r\nn_members = 30\r\nensemble = fit_ensemble(n_members, X_train, X_test, y_train, y_test)\r\n# make predictions with prediction interval\r\nnewX = asarray([X_test[0, :]])\r\nlower, mean, upper = predict_with_pi(ensemble, newX)\r\nprint('Point prediction: %.3f' % mean)\r\nprint('95%% prediction interval: [%.3f, %.3f]' % (lower, upper))\r\nprint('True value: %.3f' % y_test[0])<\/pre>\n>1, MAE: 2.259\r\n>2, MAE: 2.144\r\n>3, MAE: 2.732\r\n>4, MAE: 2.628\r\n>5, MAE: 2.483\r\n>6, MAE: 2.551\r\n>7, MAE: 2.505\r\n>8, MAE: 2.299\r\n>9, MAE: 2.706\r\n>10, MAE: 2.145\r\n>11, MAE: 2.765\r\n>12, MAE: 3.244\r\n>13, MAE: 2.385\r\n>14, MAE: 2.592\r\n>15, MAE: 2.418\r\n>16, MAE: 2.493\r\n>17, MAE: 2.367\r\n>18, MAE: 2.569\r\n>19, MAE: 2.664\r\n>20, MAE: 2.233\r\n>21, MAE: 2.228\r\n>22, MAE: 2.646\r\n>23, MAE: 2.641\r\n>24, MAE: 2.492\r\n>25, MAE: 2.558\r\n>26, MAE: 2.416\r\n>27, MAE: 2.328\r\n>28, MAE: 2.383\r\n>29, MAE: 2.215\r\n>30, MAE: 2.408\r\nPoint prediction: 30.555\r\n95% prediction interval: [26.287, 34.822]\r\nTrue value: 28.200<\/pre>\n
Further Reading<\/h2>\n
Tutorials<\/h3>\n
\n
Papers<\/h3>\n
\n
Articles<\/h3>\n
\n
Summary<\/h2>\n
\n
\nAsk your questions in the comments below and I will do my best to answer.<\/p>\n