From b052b56d33f4c9d82700dc324ee6cfb93219932b Mon Sep 17 00:00:00 2001 From: Ben Letham Date: Fri, 4 May 2018 15:07:35 -0700 Subject: [PATCH] Refactor cross validation metrics for rolling window, add visualization, put example in notebook (R) --- R/DESCRIPTION | 2 - R/NAMESPACE | 9 +- R/R/diagnostics.R | 149 +++++++++++++++++++++++++ R/R/metrics.R | 150 -------------------------- R/R/plot.R | 65 +++++++++++ R/man/coverage.Rd | 20 ++++ R/man/create_metric_data.Rd | 20 ---- R/man/mae.Rd | 20 ++++ R/man/make_metrics_function.Rd | 18 ---- R/man/mape.Rd | 20 ++++ R/man/metrics.Rd | 91 ---------------- R/man/mse.Rd | 20 ++++ R/man/performance_metrics.Rd | 46 ++++++++ R/man/plot_cross_validation_metric.Rd | 36 +++++++ R/man/rmse.Rd | 20 ++++ R/man/rolling_mean.Rd | 21 ++++ R/tests/testthat/test_diagnostics.R | 29 +++++ notebooks/diagnostics.ipynb | 62 +++++++++-- python/fbprophet/diagnostics.py | 59 ++++++++++ 19 files changed, 561 insertions(+), 296 deletions(-) delete mode 100644 R/R/metrics.R create mode 100644 R/man/coverage.Rd delete mode 100644 R/man/create_metric_data.Rd create mode 100644 R/man/mae.Rd delete mode 100644 R/man/make_metrics_function.Rd create mode 100644 R/man/mape.Rd delete mode 100644 R/man/metrics.Rd create mode 100644 R/man/mse.Rd create mode 100644 R/man/performance_metrics.Rd create mode 100644 R/man/plot_cross_validation_metric.Rd create mode 100644 R/man/rmse.Rd create mode 100644 R/man/rolling_mean.Rd diff --git a/R/DESCRIPTION b/R/DESCRIPTION index b99208d..44c6b73 100644 --- a/R/DESCRIPTION +++ b/R/DESCRIPTION @@ -25,8 +25,6 @@ Imports: stats, tidyr (>= 0.6.1), utils, - purrr, - rlang, xts Suggests: knitr, diff --git a/R/NAMESPACE b/R/NAMESPACE index 89162c8..86ace30 100644 --- a/R/NAMESPACE +++ b/R/NAMESPACE @@ -5,21 +5,16 @@ S3method(predict,prophet) export(add_changepoints_to_plot) export(add_regressor) export(add_seasonality) -export(all_metrics) export(cross_validation) export(dyplot.prophet) export(fit.prophet) -export(mae) export(make_future_dataframe) -export(mape) -export(me) -export(mpe) -export(mse) +export(performance_metrics) +export(plot_cross_validation_metric) export(plot_forecast_component) export(predictive_samples) export(prophet) export(prophet_plot_components) -export(rmse) export(simulated_historical_forecasts) import(Rcpp) importFrom(dplyr,"%>%") diff --git a/R/R/diagnostics.R b/R/R/diagnostics.R index 88f2d8b..cc3ea58 100644 --- a/R/R/diagnostics.R +++ b/R/R/diagnostics.R @@ -191,3 +191,152 @@ prophet_copy <- function(m, cutoff = NULL) { m2$seasonalities <- m$seasonalities return(m2) } + +#' Compute performance metrics from cross-validation results. +#' +#' Computes a suite of performance metrics on the output of cross-validation. +#' By default the following metrics are included: +#' 'mse': mean squared error +#' 'rmse': root mean squared error +#' 'mae': mean absolute error +#' 'mape': mean percent error +#' 'coverage': coverage of the upper and lower intervals +#' +#' A subset of these can be specified by passing a list of names as the +#' `metrics` argument. +#' +#' Metrics are calculated over a rolling window of cross validation +#' predictions, after sorting by horizon. The size of that window (number of +#' simulated forecast points) is determined by the rolling_window argument, +#' which specifies a proportion of simulated forecast points to include in +#' each window. rolling_window=0 will compute it separately for each simulated +#' forecast point (i.e., 'mse' will actually be squared error with no mean). +#' The default of rolling_window=0.1 will use 10% of the rows in df in each +#' window. rolling_window=1 will compute the metric across all simulated +#' forecast points. The results are set to the right edge of the window. +#' +#' The output is a dataframe containing column 'horizon' along with columns +#' for each of the metrics computed. +#' +#' @param df The dataframe returned by cross_validation. +#' @param metrics An array of performance metrics to compute. If not provided, +#' will use c('mse', 'rmse', 'mae', 'mape', 'coverage'). +#' @param rolling_window Proportion of data to use in each rolling window for +#' computing the metrics. Should be in [0, 1]. +#' +#' @return A dataframe with a column for each metric, and column 'horizon'. +#' +#' @export +performance_metrics <- function(df, metrics = NULL, rolling_window = 0.1) { + valid_metrics <- c('mse', 'rmse', 'mae', 'mape', 'coverage') + if (is.null(metrics)) { + metrics <- valid_metrics + } + if (length(metrics) != length(unique(metrics))) { + stop('Input metrics must be an array of unique values.') + } + if (!all(metrics %in% valid_metrics)) { + stop( + paste('Valid values for metrics are:', paste(metrics, collapse = ", ")) + ) + } + df_m <- df + df_m$horizon <- df_m$ds - df_m$cutoff + df_m <- df_m[order(df_m$horizon),] + # Window size + w <- as.integer(rolling_window * nrow(df_m)) + w <- max(w, 1) + w <- min(w, nrow(df_m)) + cols <- c('horizon') + for (metric in metrics) { + df_m[[metric]] <- get(metric)(df_m, w) + cols <- c(cols, metric) + } + df_m <- df_m[cols] + return(na.omit(df_m)) +} + +#' Compute a rolling mean of x +#' +#' Right-aligned. Padded with NAs on the front so the output is the same +#' size as x. +#' +#' @param x Array. +#' @param w Integer window size (number of elements). +#' +#' @return Rolling mean of x with window size w. +#' +#' @keywords internal +rolling_mean <- function(x, w) { + s <- cumsum(c(0, x)) + prefix <- rep(NA, w - 1) + return(c(prefix, (s[(w + 1):length(s)] - s[1:(length(s) - w)]) / w)) +} + +# The functions below specify performance metrics for cross-validation results. +# Each takes as input the output of cross_validation, and returns the statistic +# as an array, given a window size for rolling aggregation. + +#' Mean squared error +#' +#' @param df Cross-validation results dataframe. +#' @param w Aggregation window size. +#' +#' @return Array of mean squared errors. +#' +#' @keywords internal +mse <- function(df, w) { + se <- (df$y - df$yhat) ** 2 + return(rolling_mean(se, w)) +} + +#' Root mean squared error +#' +#' @param df Cross-validation results dataframe. +#' @param w Aggregation window size. +#' +#' @return Array of root mean squared errors. +#' +#' @keywords internal +rmse <- function(df, w) { + return(sqrt(mse(df, w))) +} + +#' Mean absolute error +#' +#' @param df Cross-validation results dataframe. +#' @param w Aggregation window size. +#' +#' @return Array of mean absolute errors. +#' +#' @keywords internal +mae <- function(df, w) { + ae <- abs(df$y - df$yhat) + return(rolling_mean(ae, w)) +} + +#' Mean absolute percent error +#' +#' @param df Cross-validation results dataframe. +#' @param w Aggregation window size. +#' +#' @return Array of mean absolute percent errors. +#' +#' @keywords internal +mape <- function(df, w) { + ape <- abs((df$y - df$yhat) / df$y) + return(rolling_mean(ape, w)) +} + +#' Coverage +#' +#' @param df Cross-validation results dataframe. +#' @param w Aggregation window size. +#' +#' @return Array of coverages +#' +#' @keywords internal +coverage <- function(df, w) { + is_covered <- (df$y >= df$yhat_lower) & (df$y <= df$yhat_upper) + return(rolling_mean(is_covered, w)) +} diff --git a/R/R/metrics.R b/R/R/metrics.R deleted file mode 100644 index ce9a5ce..0000000 --- a/R/R/metrics.R +++ /dev/null @@ -1,150 +0,0 @@ -## Copyright (c) 2017-present, Facebook, Inc. -## All rights reserved. - -## This source code is licensed under the BSD-style license found in the -## LICENSE file in the root directory of this source tree. An additional grant -## of patent rights can be found in the PATENTS file in the same directory. - -#' @title Metrics for Time Series Forecasts -#' -#' @description -#' A time-series forecast requires making a quantitative prediction of future values. -#' After forecast, we also have to provide accurracy of forecasts to check wether the forecast serves our need. -#' Metrics for time series forecasts are so useful in telling you how your model is good and helping you determine which particular forecasting models work best. -#' -#' @details -#' Here, as a notation, we assume that \eqn{y} is the actual value and \eqn{yhat} is the forecast value. -#' -#' Mean Error (ME, \code{me}) -#' -#' The Mean Error (ME) is defined by the formula: -#' \deqn{ \frac{1}{n} \sum_{t=1}^{n} y_{t}-yhat_{t} .} -#' -#' Mean Squared Error (MSE, \code{mse}) -#' -#' The Mean Squared Error (MSE) is defined by the formula: -#' \deqn{ \frac{1}{n} \sum_{t=1}^{n} (y_{t}-yhat_{t})^2 .} -#' -#' Root Mean Square Error (RMSE, \code{rmse}) -#' -#' Root Mean Square Error (RMSE) is define by the formula: -#' \deqn{ \sqrt{\frac{1}{n} \sum_{t=1}^{n} (y_{t}-yhat_{t})^2} .} -#' -#' Mean Absolute Error (MAE, \code{mae}) -#' -#' The Mean Absolute Error (MAE) is defined by the formula: -#' \deqn{ \frac{1}{n} \sum_{t=1}^{n} | y_{t}-yhat_{t} | .} -#' -#' Mean Percentage Error (MPE, \code{mpe}) -#' -#' The Mean Percentage Error (MPE) is usually expressed as a percentage -#' and is defined by the formula: -#' \deqn{ \frac{100}{n} \sum_{t=1}^{n} \frac {y_{t}-yhat_{t}}{y_{t}} .} -#' -#' Mean Absolute Percentage Error (MAPE, \code{mape}) -#' -#' The Mean absolute Percentage Error (MAPE), also known as Mean Absolute Percentage Deviation (MAPD), is usually expressed as a percentage, -#' and is defined by the formula: -#' \deqn{ \frac{100}{n} \sum_{t=1}^{n} | \frac {y_{t}-yhat_{t}}{y_{t}}| .} -#' -#' @param m Prophet object. Default NULL -#' @param df A dataframe which is output of `simulated_historical_forecasts` or `cross_validation` Default NULL -#' -#' @return metrics value (numeric) -#' -#'@examples -#'\dontrun{ -#' # Create example model -#' library(readr) -#' library(prophet) -#' df <- read_csv('../tests/testthat/data.csv') -#' m <- prophet(df) -#' future <- make_future_dataframe(m, periods = 365) -#' forecast <- predict(m, future) -#' all_metrics(forecast) -#' df.cv <- cross_validation(m, horizon = 100, units = 'days') -#' all_metrics(df.cv) -#' # You can check your models's accuracy using me, mse, rmse ...etc. -#' print(rmse(m)) -#'} -#' @name metrics -NULL - -#' Prepare dataframe for metrics calculation. -#' -#' @param m Prophet object. Default NULL -#' @param df A dataframe which is output of `simulated_historical_forecasts` or `cross_validation` Default NULL -#' -#' @return A dataframe only with y and yhat as a column. -#' -#' @keywords internal -create_metric_data <- function(m=NULL, df=NULL) -{ - if(is.null(m) && is.null(df)) - { - stop("You have to specify one of `m` and `df` at least.") - } - if(!is.null(m) && !is.null(df)) - { - warning("You specify both of `m` and `df`. `df` is used for metrics calclation.") - } - - data <- if(!is.null(df)){ - df - } else if("prophet" %in% class(m)) { - dplyr::inner_join(m$history, predict(m, NULL), by="ds") - } - - dplyr::select(data, y, yhat) %>% na.omit() -} - -#' Meta function to make the function which evaluate metrics. -#' -#' @param metrics metrics function -#' -#' @return A function using for metrics evaluation. -#' -#' @keywords internal -make_metrics_function <- function(metrics) -{ - function(m=NULL, df=NULL) - { - data <- create_metric_data(m, df) - metrics(data$y, data$yhat) - } -} - -#' @rdname metrics -#' @export -me <- make_metrics_function(function(y, yhat){mean(y - yhat)}) - -#' @rdname metrics -#' @export -mse <- make_metrics_function(function(y, yhat){mean((y - yhat)^2)}) - -#' @rdname metrics -#' @export -rmse <- make_metrics_function(function(y, yhat){sqrt(mean((y - yhat)^2))}) - -#' @rdname metrics -#' @export -mae <- make_metrics_function(function(y, yhat){mean(abs(y - yhat))}) - -#' @rdname metrics -#' @export -mpe <- make_metrics_function(function(y, yhat){100*mean((y - yhat)/y)}) - -#' @rdname metrics -#' @export -mape <- make_metrics_function(function(y, yhat){100*mean(abs((y - yhat)/y))}) - -#' @rdname metrics -#' @export -all_metrics <- function(m=NULL, df=NULL) -{ - # Define all metrics functions as a character - metrics <- rlang::set_names(c("me", "mse", "rmse", "mae", "mpe", "mape")) - # Convert character to function and evalate each metrics in invoke_map_df - # The result is data.frame with each metrics name - purrr::invoke_map_df(metrics, list(list(m, df))) -} diff --git a/R/R/plot.R b/R/R/plot.R index 1ee71be..af13905 100644 --- a/R/R/plot.R +++ b/R/R/plot.R @@ -406,3 +406,68 @@ dyplot.prophet <- function(x, fcst, uncertainty=TRUE, return(dyBase) } +#' Plot a performance metric vs. forecast horizon from cross validation. + +#' Cross validation produces a collection of out-of-sample model predictions +#' that can be compared to actual values, at a range of different horizons +#' (distance from the cutoff). This computes a specified performance metric +#' for each prediction, and aggregated over a rolling window with horizon. +#' +#' This uses fbprophet.diagnostics.performance_metrics to compute the metrics. +#' Valid values of metric are 'mse', 'rmse', 'mae', 'mape', and 'coverage'. +#' +#' rolling_window is the proportion of data included in the rolling window of +#' aggregation. The default value of 0.1 means 10% of data are included in the +#' aggregation for computing the metric. +#' +#' As a concrete example, if metric='mse', then this plot will show the +#' squared error for each cross validation prediction, along with the MSE +#' averaged over rolling windows of 10% of the data. +#' +#' @param df_cv The output from fbprophet.diagnostics.cross_validation. +#' @param metric Metric name, one of 'mse', 'rmse', 'mae', 'mape', 'coverage'. +#' @param rolling_window Proportion of data to use for rolling average of +#' metric. In [0, 1]. Defaults to 0.1. +#' +#' @return A ggplot2 plot. +#' +#' @export +plot_cross_validation_metric <- function(df_cv, metric, rolling_window=0.1) { + df_none <- performance_metrics(df_cv, metrics = metric, rolling_window = 0) + df_h <- performance_metrics( + df_cv, metrics = metric, rolling_window = rolling_window + ) + + # Better plotting of difftime + # Target ~10 ticks + tick_w <- max(as.double(df_none$horizon, units = 'secs')) / 10. + # Find the largest time resolution that has <1 unit per bin + dts <- c('days', 'hours', 'mins', 'secs') + dt_conversions <- c( + 24 * 60 * 60, + 60 * 60, + 60, + 1 + ) + for (i in seq_along(dts)) { + if (as.difftime(1, units = dts[i]) < as.difftime(tick_w, units = 'secs')) { + break + } + } + df_none$x_plt <- ( + as.double(df_none$horizon, units = 'secs') / dt_conversions[i] + ) + df_h$x_plt <- as.double(df_h$horizon, units = 'secs') / dt_conversions[i] + + gg <- ( + ggplot2::ggplot(df_none, ggplot2::aes_string(x = 'x_plt', y = metric)) + + ggplot2::labs(x = paste0('Horizon (', dts[i], ')'), y = metric) + + ggplot2::geom_point(color = 'gray') + + ggplot2::geom_line( + data = df_h, ggplot2::aes_string(x = 'x_plt', y = metric), color = 'blue' + ) + + ggplot2::theme(aspect.ratio = 3 / 5) + ) + + return(gg) +} diff --git a/R/man/coverage.Rd b/R/man/coverage.Rd new file mode 100644 index 0000000..102ed91 --- /dev/null +++ b/R/man/coverage.Rd @@ -0,0 +1,20 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/diagnostics.R +\name{coverage} +\alias{coverage} +\title{Coverage} +\usage{ +coverage(df, w) +} +\arguments{ +\item{df}{Cross-validation results dataframe.} + +\item{w}{Aggregation window size.} +} +\value{ +Array of coverages +} +\description{ +Coverage +} +\keyword{internal} diff --git a/R/man/create_metric_data.Rd b/R/man/create_metric_data.Rd deleted file mode 100644 index 8242f42..0000000 --- a/R/man/create_metric_data.Rd +++ /dev/null @@ -1,20 +0,0 @@ -% Generated by roxygen2: do not edit by hand -% Please edit documentation in R/metrics.R -\name{create_metric_data} -\alias{create_metric_data} -\title{Prepare dataframe for metrics calculation.} -\usage{ -create_metric_data(m = NULL, df = NULL) -} -\arguments{ -\item{m}{Prophet object. Default NULL} - -\item{df}{A dataframe which is output of `simulated_historical_forecasts` or `cross_validation` Default NULL} -} -\value{ -A dataframe only with y and yhat as a column. -} -\description{ -Prepare dataframe for metrics calculation. -} -\keyword{internal} diff --git a/R/man/mae.Rd b/R/man/mae.Rd new file mode 100644 index 0000000..e0967f1 --- /dev/null +++ b/R/man/mae.Rd @@ -0,0 +1,20 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/diagnostics.R +\name{mae} +\alias{mae} +\title{Mean absolute error} +\usage{ +mae(df, w) +} +\arguments{ +\item{df}{Cross-validation results dataframe.} + +\item{w}{Aggregation window size.} +} +\value{ +Array of mean absolute errors. +} +\description{ +Mean absolute error +} +\keyword{internal} diff --git a/R/man/make_metrics_function.Rd b/R/man/make_metrics_function.Rd deleted file mode 100644 index c3df5b3..0000000 --- a/R/man/make_metrics_function.Rd +++ /dev/null @@ -1,18 +0,0 @@ -% Generated by roxygen2: do not edit by hand -% Please edit documentation in R/metrics.R -\name{make_metrics_function} -\alias{make_metrics_function} -\title{Meta function to make the function which evaluate metrics.} -\usage{ -make_metrics_function(metrics) -} -\arguments{ -\item{metrics}{metrics function} -} -\value{ -A function using for metrics evaluation. -} -\description{ -Meta function to make the function which evaluate metrics. -} -\keyword{internal} diff --git a/R/man/mape.Rd b/R/man/mape.Rd new file mode 100644 index 0000000..f8da415 --- /dev/null +++ b/R/man/mape.Rd @@ -0,0 +1,20 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/diagnostics.R +\name{mape} +\alias{mape} +\title{Mean absolute percent error} +\usage{ +mape(df, w) +} +\arguments{ +\item{df}{Cross-validation results dataframe.} + +\item{w}{Aggregation window size.} +} +\value{ +Array of mean absolute percent errors. +} +\description{ +Mean absolute percent error +} +\keyword{internal} diff --git a/R/man/metrics.Rd b/R/man/metrics.Rd deleted file mode 100644 index 9f9d081..0000000 --- a/R/man/metrics.Rd +++ /dev/null @@ -1,91 +0,0 @@ -% Generated by roxygen2: do not edit by hand -% Please edit documentation in R/metrics.R -\name{metrics} -\alias{metrics} -\alias{me} -\alias{mse} -\alias{rmse} -\alias{mae} -\alias{mpe} -\alias{mape} -\alias{all_metrics} -\title{Metrics for Time Series Forecasts} -\usage{ -me(m = NULL, df = NULL) - -mse(m = NULL, df = NULL) - -rmse(m = NULL, df = NULL) - -mae(m = NULL, df = NULL) - -mpe(m = NULL, df = NULL) - -mape(m = NULL, df = NULL) - -all_metrics(m = NULL, df = NULL) -} -\arguments{ -\item{m}{Prophet object. Default NULL} - -\item{df}{A dataframe which is output of `simulated_historical_forecasts` or `cross_validation` Default NULL} -} -\value{ -metrics value (numeric) -} -\description{ -A time-series forecast requires making a quantitative prediction of future values. -After forecast, we also have to provide accurracy of forecasts to check wether the forecast serves our need. -Metrics for time series forecasts are so useful in telling you how your model is good and helping you determine which particular forecasting models work best. -} -\details{ -Here, as a notation, we assume that \eqn{y} is the actual value and \eqn{yhat} is the forecast value. - -Mean Error (ME, \code{me}) - -The Mean Error (ME) is defined by the formula: -\deqn{ \frac{1}{n} \sum_{t=1}^{n} y_{t}-yhat_{t} .} - -Mean Squared Error (MSE, \code{mse}) - -The Mean Squared Error (MSE) is defined by the formula: -\deqn{ \frac{1}{n} \sum_{t=1}^{n} (y_{t}-yhat_{t})^2 .} - -Root Mean Square Error (RMSE, \code{rmse}) - -Root Mean Square Error (RMSE) is define by the formula: -\deqn{ \sqrt{\frac{1}{n} \sum_{t=1}^{n} (y_{t}-yhat_{t})^2} .} - -Mean Absolute Error (MAE, \code{mae}) - -The Mean Absolute Error (MAE) is defined by the formula: -\deqn{ \frac{1}{n} \sum_{t=1}^{n} | y_{t}-yhat_{t} | .} - -Mean Percentage Error (MPE, \code{mpe}) - -The Mean Percentage Error (MPE) is usually expressed as a percentage -and is defined by the formula: -\deqn{ \frac{100}{n} \sum_{t=1}^{n} \frac {y_{t}-yhat_{t}}{y_{t}} .} - -Mean Absolute Percentage Error (MAPE, \code{mape}) - -The Mean absolute Percentage Error (MAPE), also known as Mean Absolute Percentage Deviation (MAPD), is usually expressed as a percentage, -and is defined by the formula: -\deqn{ \frac{100}{n} \sum_{t=1}^{n} | \frac {y_{t}-yhat_{t}}{y_{t}}| .} -} -\examples{ -\dontrun{ -# Create example model -library(readr) -library(prophet) -df <- read_csv('../tests/testthat/data.csv') -m <- prophet(df) -future <- make_future_dataframe(m, periods = 365) -forecast <- predict(m, future) -all_metrics(forecast) -df.cv <- cross_validation(m, horizon = 100, units = 'days') -all_metrics(df.cv) -# You can check your models's accuracy using me, mse, rmse ...etc. -print(rmse(m)) -} -} diff --git a/R/man/mse.Rd b/R/man/mse.Rd new file mode 100644 index 0000000..663c166 --- /dev/null +++ b/R/man/mse.Rd @@ -0,0 +1,20 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/diagnostics.R +\name{mse} +\alias{mse} +\title{Mean squared error} +\usage{ +mse(df, w) +} +\arguments{ +\item{df}{Cross-validation results dataframe.} + +\item{w}{Aggregation window size.} +} +\value{ +Array of mean squared errors. +} +\description{ +Mean squared error +} +\keyword{internal} diff --git a/R/man/performance_metrics.Rd b/R/man/performance_metrics.Rd new file mode 100644 index 0000000..435ffcd --- /dev/null +++ b/R/man/performance_metrics.Rd @@ -0,0 +1,46 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/diagnostics.R +\name{performance_metrics} +\alias{performance_metrics} +\title{Compute performance metrics from cross-validation results.} +\usage{ +performance_metrics(df, metrics = NULL, rolling_window = 0.1) +} +\arguments{ +\item{df}{The dataframe returned by cross_validation.} + +\item{metrics}{An array of performance metrics to compute. If not provided, +will use c('mse', 'rmse', 'mae', 'mape', 'coverage').} + +\item{rolling_window}{Proportion of data to use in each rolling window for +computing the metrics. Should be in [0, 1].} +} +\value{ +A dataframe with a column for each metric, and column 'horizon'. +} +\description{ +Computes a suite of performance metrics on the output of cross-validation. +By default the following metrics are included: +'mse': mean squared error +'rmse': root mean squared error +'mae': mean absolute error +'mape': mean percent error +'coverage': coverage of the upper and lower intervals +} +\details{ +A subset of these can be specified by passing a list of names as the +`metrics` argument. + +Metrics are calculated over a rolling window of cross validation +predictions, after sorting by horizon. The size of that window (number of +simulated forecast points) is determined by the rolling_window argument, +which specifies a proportion of simulated forecast points to include in +each window. rolling_window=0 will compute it separately for each simulated +forecast point (i.e., 'mse' will actually be squared error with no mean). +The default of rolling_window=0.1 will use 10% of the rows in df in each +window. rolling_window=1 will compute the metric across all simulated +forecast points. The results are set to the right edge of the window. + +The output is a dataframe containing column 'horizon' along with columns +for each of the metrics computed. +} diff --git a/R/man/plot_cross_validation_metric.Rd b/R/man/plot_cross_validation_metric.Rd new file mode 100644 index 0000000..19fc7fb --- /dev/null +++ b/R/man/plot_cross_validation_metric.Rd @@ -0,0 +1,36 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/plot.R +\name{plot_cross_validation_metric} +\alias{plot_cross_validation_metric} +\title{Plot a performance metric vs. forecast horizon from cross validation. +Cross validation produces a collection of out-of-sample model predictions +that can be compared to actual values, at a range of different horizons +(distance from the cutoff). This computes a specified performance metric +for each prediction, and aggregated over a rolling window with horizon.} +\usage{ +plot_cross_validation_metric(df_cv, metric, rolling_window = 0.1) +} +\arguments{ +\item{df_cv}{The output from fbprophet.diagnostics.cross_validation.} + +\item{metric}{Metric name, one of 'mse', 'rmse', 'mae', 'mape', 'coverage'.} + +\item{rolling_window}{Proportion of data to use for rolling average of +metric. In [0, 1]. Defaults to 0.1.} +} +\value{ +A ggplot2 plot. +} +\description{ +This uses fbprophet.diagnostics.performance_metrics to compute the metrics. +Valid values of metric are 'mse', 'rmse', 'mae', 'mape', and 'coverage'. +} +\details{ +rolling_window is the proportion of data included in the rolling window of +aggregation. The default value of 0.1 means 10% of data are included in the +aggregation for computing the metric. + +As a concrete example, if metric='mse', then this plot will show the +squared error for each cross validation prediction, along with the MSE +averaged over rolling windows of 10% of the data. +} diff --git a/R/man/rmse.Rd b/R/man/rmse.Rd new file mode 100644 index 0000000..9c591e7 --- /dev/null +++ b/R/man/rmse.Rd @@ -0,0 +1,20 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/diagnostics.R +\name{rmse} +\alias{rmse} +\title{Root mean squared error} +\usage{ +rmse(df, w) +} +\arguments{ +\item{df}{Cross-validation results dataframe.} + +\item{w}{Aggregation window size.} +} +\value{ +Array of root mean squared errors. +} +\description{ +Root mean squared error +} +\keyword{internal} diff --git a/R/man/rolling_mean.Rd b/R/man/rolling_mean.Rd new file mode 100644 index 0000000..b422503 --- /dev/null +++ b/R/man/rolling_mean.Rd @@ -0,0 +1,21 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/diagnostics.R +\name{rolling_mean} +\alias{rolling_mean} +\title{Compute a rolling mean of x} +\usage{ +rolling_mean(x, w) +} +\arguments{ +\item{x}{Array.} + +\item{w}{Integer window size (number of elements).} +} +\value{ +Rolling mean of x with window size w. +} +\description{ +Right-aligned. Padded with NAs on the front so the output is the same +size as x. +} +\keyword{internal} diff --git a/R/tests/testthat/test_diagnostics.R b/R/tests/testthat/test_diagnostics.R index 287743f..64a0a85 100644 --- a/R/tests/testthat/test_diagnostics.R +++ b/R/tests/testthat/test_diagnostics.R @@ -103,3 +103,32 @@ test_that("cross_validation_default_value_check", { m, horizon = 32, units = 'days', period = 10, initial = 96) expect_equal(sum(dplyr::select(df.cv1 - df.cv2, y, yhat)), 0) }) + +test_that("performance_metrics", { + skip_if_not(Sys.getenv('R_ARCH') != '/i386') + m <- prophet(DATA) + df_cv <- cross_validation( + m, horizon = 4, units = "days", period = 10, initial = 90) + # Aggregation level none + df_none <- performance_metrics(df_cv, rolling_window = 0) + expect_true(all( + sort(colnames(df_none)) + == sort(c('horizon', 'coverage', 'mae', 'mape', 'mse', 'rmse')) + )) + expect_equal(nrow(df_none), 14) + # Aggregation level 0.2 + df_horizon <- performance_metrics(df_cv, rolling_window = 0.2) + expect_equal(length(unique(df_horizon$horizon)), 4) + expect_equal(nrow(df_horizon), 13) + # Aggregation level all + df_all <- performance_metrics(df_cv, rolling_window = 1) + expect_equal(nrow(df_all), 1) + for (metric in c('mse', 'mape', 'mae', 'coverage')) { + expect_equal(df_all[[metric]][1], mean(df_none[[metric]])) + } + # Custom list of metrics + df_horizon <- performance_metrics(df_cv, metrics = c('coverage', 'mse')) + expect_true(all( + sort(colnames(df_horizon)) == sort(c('coverage', 'mse', 'horizon')) + )) +}) diff --git a/notebooks/diagnostics.ipynb b/notebooks/diagnostics.ipynb index cdf7cc8..e7bdae4 100644 --- a/notebooks/diagnostics.ipynb +++ b/notebooks/diagnostics.ipynb @@ -122,7 +122,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 3, "metadata": { "output_hidden": true }, @@ -154,7 +154,8 @@ "Initial log joint probability = -60.6813\n", "Optimization terminated normally: \n", " Convergence detected: relative gradient magnitude is below tolerance\n", - "Initial log joint probability = -66.0636\n", + "\r", + "|======================================================|100% ~0 s remaining Initial log joint probability = -66.0636\n", "Optimization terminated normally: \n", " Convergence detected: relative gradient magnitude is below tolerance\n", "Initial log joint probability = -60.4143\n", @@ -164,12 +165,12 @@ "Optimization terminated normally: \n", " Convergence detected: relative gradient magnitude is below tolerance\n", " ds y yhat yhat_lower yhat_upper cutoff\n", - "1 2010-02-16 8.242493 8.957810 8.496165 9.456103 2010-02-15\n", - "2 2010-02-17 8.008033 8.724243 8.226506 9.250160 2010-02-15\n", - "3 2010-02-18 8.045268 8.607983 8.105585 9.092535 2010-02-15\n", - "4 2010-02-19 7.928766 8.529845 8.011191 9.017690 2010-02-15\n", - "5 2010-02-20 7.745003 8.271791 7.768912 8.725352 2010-02-15\n", - "6 2010-02-21 7.866339 8.603075 8.104359 9.099205 2010-02-15\n" + "1 2010-02-16 8.242493 8.957810 8.462753 9.434153 2010-02-15\n", + "2 2010-02-17 8.008033 8.724243 8.241599 9.221809 2010-02-15\n", + "3 2010-02-18 8.045268 8.607983 8.137073 9.106919 2010-02-15\n", + "4 2010-02-19 7.928766 8.529845 8.017107 8.980099 2010-02-15\n", + "5 2010-02-20 7.745003 8.271791 7.782124 8.775150 2010-02-15\n", + "6 2010-02-21 7.866339 8.603075 8.129926 9.118596 2010-02-15\n" ] }, "metadata": {}, @@ -293,6 +294,33 @@ "The `performance_metrics` utility can be used to compute some useful statistics of the prediction performance (`yhat`, `yhat_lower`, and `yhat_upper` compared to `y`), as a function of the distance from the cutoff (how far into the future the prediction was). The statistics computed are mean squared error (MSE), root mean squared error (RMSE), mean absolute error (MAE), mean absolute percent error (MAPE), and coverage of the `yhat_lower` and `yhat_upper` estimates. These are computed on a rolling window of the predictions in `df_cv` after sorting by horizon (`ds` minus `cutoff`). By default 10% of the predictions will be included in each window, but this can be changed with the `rolling_window` argument." ] }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + " horizon mse rmse mae mape coverage\n", + "1844 37 days 0.5090136 0.7134519 0.5128365 0.05930799 0.6733668\n", + "2208 37 days 0.5079983 0.7127400 0.5118634 0.05919618 0.6758794\n", + "2571 37 days 0.5072650 0.7122254 0.5107879 0.05906802 0.6783920\n", + "2935 37 days 0.5069671 0.7120162 0.5104987 0.05903779 0.6809045\n", + "3298 37 days 0.5069325 0.7119919 0.5103136 0.05901526 0.6809045\n", + "3661 37 days 0.4851145 0.6965016 0.5029428 0.05843547 0.6834171\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%R\n", + "df.p <- performance_metrics(df.cv)\n", + "head(df.p)" + ] + }, { "cell_type": "code", "execution_count": 5, @@ -404,6 +432,24 @@ "Cross validation performance metrics can be visualized with `plot_cross_validation_metric`, here shown for MAPE. Dots show the absolute percent error for each prediction in `df_cv`. The blue line shows the MAPE, where the mean is taken over a rolling window of the dots. We see for this forecast that errors around 5% are typical for predictions one month into the future, and that errors increase up to around 11% for predictions that are a year out." ] }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtAAAAGwCAIAAAAPKcUMAAAACXBIWXMAAAsSAAALEgHS3X78AAAg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\n" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%R -w 10 -h 6 -u in\n", + "plot_cross_validation_metric(df.cv, metric = 'mape')" + ] + }, { "cell_type": "code", "execution_count": 6, diff --git a/python/fbprophet/diagnostics.py b/python/fbprophet/diagnostics.py index 1715442..2f47bd3 100644 --- a/python/fbprophet/diagnostics.py +++ b/python/fbprophet/diagnostics.py @@ -260,6 +260,20 @@ def performance_metrics(df, metrics=None, rolling_window=0.1): def rolling_mean(x, w): + """Compute a rolling mean of x + + Right-aligned. Padded with NaNs on the front so the output is the same + size as x. + + Parameters + ---------- + x: Array. + w: Integer window size (number of elements). + + Returns + ------- + Rolling mean of x with window size w. + """ s = np.cumsum(np.insert(x, 0, 0)) prefix = np.empty(w - 1) prefix.fill(np.nan) @@ -273,6 +287,15 @@ def rolling_mean(x, w): def mse(df, w): """Mean squared error + + Parameters + ---------- + df: Cross-validation results dataframe. + w: Aggregation window size. + + Returns + ------- + Array of mean squared errors. """ se = (df['y'] - df['yhat']) ** 2 return rolling_mean(se.values, w) @@ -280,12 +303,30 @@ def mse(df, w): def rmse(df, w): """Root mean squared error + + Parameters + ---------- + df: Cross-validation results dataframe. + w: Aggregation window size. + + Returns + ------- + Array of root mean squared errors. """ return np.sqrt(mse(df, w)) def mae(df, w): """Mean absolute error + + Parameters + ---------- + df: Cross-validation results dataframe. + w: Aggregation window size. + + Returns + ------- + Array of mean absolute errors. """ ae = np.abs(df['y'] - df['yhat']) return rolling_mean(ae.values, w) @@ -293,6 +334,15 @@ def mae(df, w): def mape(df, w): """Mean absolute percent error + + Parameters + ---------- + df: Cross-validation results dataframe. + w: Aggregation window size. + + Returns + ------- + Array of mean absolute percent errors. """ ape = np.abs((df['y'] - df['yhat']) / df['y']) return rolling_mean(ape.values, w) @@ -300,6 +350,15 @@ def mape(df, w): def coverage(df, w): """Coverage + + Parameters + ---------- + df: Cross-validation results dataframe. + w: Aggregation window size. + + Returns + ------- + Array of coverages. """ is_covered = (df['y'] >= df['yhat_lower']) & (df['y'] <= df['yhat_upper']) return rolling_mean(is_covered.values, w)