### Install Modeltime

Source: https://github.com/business-science/modeltime/blob/master/README.md

Instructions for installing the package from CRAN or the development version from GitHub.

```r
install.packages("modeltime", dependencies = TRUE)
```

```r
remotes::install_github("business-science/modeltime", dependencies = TRUE)
```

--------------------------------

### Define ARIMA Model Specification

Source: https://context7.com/business-science/modeltime/llms.txt

Sets up an ARIMA model specification using the 'auto_arima' engine. This is a common starting point for time series forecasting.

```r
model_spec_arima <- arima_reg() %>%
    set_engine("auto_arima")
```

--------------------------------

### Configure Prophet Model with Logistic Growth

Source: https://github.com/business-science/modeltime/blob/master/NEWS.md

Use `prophet_reg()` or `prophet_boost()` with `growth = 'logistic'` to enable logistic growth. Set `logistic_cap` and/or `logistic_floor` for saturation boundaries.

```r
prophet_reg(
    growth = 'logistic',
    logistic_cap = 100,
    logistic_floor = 0
)
```

--------------------------------

### Create XGBoost Workflow with Recipe

Source: https://context7.com/business-science/modeltime/llms.txt

Builds a tidymodels workflow that integrates a preprocessing recipe with an XGBoost model specification. This workflow is prepared for fitting.

```r
wflw_xgb <- workflow() %>%
    add_recipe(recipe_spec) %>%
    add_model(model_spec_xgb)
```

--------------------------------

### Prepare Recipe for ML Models with Time Series Features

Source: https://context7.com/business-science/modeltime/llms.txt

Creates a preprocessing recipe for machine learning models, including time series signature features. This recipe is designed to be used with tidymodels workflows.

```r
recipe_spec <- recipe(value ~ date, data = extract_nested_train_split(nested_data_tbl))
```

--------------------------------

### Prophet Model with Tuned Parameters

Source: https://context7.com/business-science/modeltime/llms.txt

Creates a Prophet model specification with custom parameters for growth, changepoints, seasonality, and prior scales. Requires careful tuning for optimal performance.

```r
# Prophet with tuned parameters
model_prophet_tuned <- prophet_reg(
    growth                   = "linear",
    changepoint_num          = 25,
    changepoint_range        = 0.8,
    seasonality_yearly       = TRUE,
    seasonality_weekly       = FALSE,
    seasonality_daily        = FALSE,
    season                   = "additive",
    prior_scale_changepoints = 0.05,
    prior_scale_seasonality  = 10
) %>%
    set_engine("prophet") %>%
    fit(value ~ date, data = training(splits))
```

--------------------------------

### Forecast without Calibration/Refitting

Source: https://github.com/business-science/modeltime/blob/master/NEWS.md

Use this to make fast forecasts without calculating out-of-sample accuracy and refitting. This approach bypasses `modeltime_calibrate()` and `modeltime_refit()` steps. Note that confidence intervals will not be available as calibration data is needed for this.

```r
modeltime_table(
    model_fit_prophet,
    model_fit_lm
) %>%
    modeltime_forecast(
        h = "3 years",
        actual_data = m750
    ) %>%
    plot_modeltime_forecast(.conf_interval_show = F)
```

--------------------------------

### Define XGBoost Model Specification with Parameters

Source: https://context7.com/business-science/modeltime/llms.txt

Sets up an XGBoost model specification with specific parameters for trees, tree depth, and learning rate. This allows for fine-tuning the gradient boosting model.

```r
model_spec_xgb <- boost_tree(
    trees      = 500,
    tree_depth = 6,
    learn_rate = 0.01
) %>%
    set_engine("xgboost") %>%
    set_mode("regression")
```

--------------------------------

### Create XGBoost Workflow

Source: https://context7.com/business-science/modeltime/llms.txt

Builds a tidymodels workflow that includes a time series recipe and an XGBoost model. This workflow can be used for training and prediction.

```r
wflw_xgb <- workflow() %>%
    add_recipe(recipe_spec %>% step_timeseries_signature(date)) %>%
    add_model(model_spec_xgb)
```

--------------------------------

### Generate and Plot Forecasts

Source: https://context7.com/business-science/modeltime/llms.txt

Generates forecasts for the test period using the calibrated models and plots the forecasts against the actual data. This provides a visual comparison of model performance.

```r
calibration_tbl %>%
    modeltime_forecast(new_data = testing(splits), actual_data = m750) %>%
    plot_modeltime_forecast(.interactive = FALSE)
```

--------------------------------

### Create Preprocessing Recipe with Time Series Features

Source: https://context7.com/business-science/modeltime/llms.txt

Generates a tidymodels recipe for time series data, including creating time series signature features and handling dummy variables. This recipe is used for machine learning models.

```r
recipe_spec <- recipe(value ~ date, data = training(splits)) %>%
    step_timeseries_signature(date) %>%
    step_rm(matches("(.iso)|(.xts)|(hour)|(minute)|(second)|(am.pm)")) %>%
    step_normalize(date_index.num, date_year) %>%
    step_dummy(all_nominal(), one_hot = TRUE)
```

--------------------------------

### Prepare Nested Time Series Data

Source: https://context7.com/business-science/modeltime/llms.txt

Initializes multi-series data for nested forecasting workflows.

```r
library(modeltime)
library(tidymodels)
library(timetk)
library(dplyr)

# Multi-series data
data_tbl <- walmart_sales_weekly %>%
    select(id, date = Date, value = Weekly_Sales)
```

--------------------------------

### Define XGBoost Model Specification

Source: https://context7.com/business-science/modeltime/llms.txt

Sets up an XGBoost model specification. XGBoost is a popular gradient boosting library.

```r
model_spec_xgb <- boost_tree() %>%
    set_engine("xgboost")
```

--------------------------------

### Prophet Model Configuration Changes

Source: https://github.com/business-science/modeltime/blob/master/NEWS.md

The `prophet_reg()` and `prophet_boost()` functions have updated arguments. `num_changepoints` is now `changepoint_num`. Logistic growth is supported with `growth = 'logistic'` and saturation bounds like `logistic_cap` and `logistic_floor`.

```r
prophet_reg(
    changepoint_num = 25,
    changepoint_range = 0.8,
    seasonality_yearly = TRUE,
    seasonality_weekly = TRUE,
    seasonality_daily = TRUE,
    logistic_cap = 100,
    logistic_floor = 0
)
```

--------------------------------

### Create Random Forest Workflow

Source: https://context7.com/business-science/modeltime/llms.txt

Constructs a tidymodels workflow combining a time series preprocessing recipe with a Random Forest model specification. This workflow is ready for fitting.

```r
wflw_rf <- workflow() %>%
    add_recipe(recipe_spec) %>%
    add_model(model_spec_rf)
```

--------------------------------

### Create Prophet Modeltime Table

Source: https://context7.com/business-science/modeltime/llms.txt

Creates a modeltime table containing only the fitted Prophet model. This is useful for managing individual model results before combining them.

```r
prophet_tbl <- modeltime_table(model_prophet)
```

--------------------------------

### modeltime_table - Create Model Tables

Source: https://context7.com/business-science/modeltime/llms.txt

Organizes multiple fitted models into a Modeltime Table for unified forecasting operations.

```APIDOC
## modeltime_table

### Description
Creates a Modeltime Table object to manage multiple fitted models for forecasting.

### Parameters
- **...** (model objects) - Required - One or more fitted model objects.

### Response
- **.model_id** (integer) - Unique identifier for the model.
- **.model** (list) - The fitted model object.
- **.model_desc** (string) - Description of the model.
```

--------------------------------

### Generate Forecasts with modeltime_forecast

Source: https://context7.com/business-science/modeltime/llms.txt

Creates forecasts from calibrated models. Supports horizon-based forecasting, conformal prediction, and keeping additional data columns.

```r
library(modeltime)
library(tidymodels)
library(timetk)
library(dplyr)

m750 <- m4_monthly %>% filter(id == "M750")
splits <- initial_time_split(m750, prop = 0.9)

model_arima <- arima_reg() %>%
    set_engine("auto_arima") %>%
    fit(value ~ date, data = training(splits))

model_prophet <- prophet_reg() %>%
    set_engine("prophet") %>%
    fit(value ~ date, data = training(splits))

models_tbl <- modeltime_table(model_arima, model_prophet)

calibration_tbl <- models_tbl %>%
    modeltime_calibrate(new_data = testing(splits))

# Forecast on test data with actual values for comparison
forecast_tbl <- calibration_tbl %>%
    modeltime_forecast(
        new_data    = testing(splits),
        actual_data = m750
    )

# Output columns: .model_id, .model_desc, .key, .index, .value, .conf_lo, .conf_hi

# Forecast using horizon (h) notation
forecast_h <- calibration_tbl %>%
    modeltime_forecast(
        h           = "3 years",
        actual_data = m750
    )

# Forecast without calibration (no confidence intervals)
forecast_no_ci <- models_tbl %>%
    modeltime_forecast(
        new_data    = testing(splits),
        actual_data = m750
    )

# Keep additional data columns with forecast
forecast_keep <- calibration_tbl %>%
    modeltime_forecast(
        new_data  = testing(splits),
        keep_data = TRUE
    )

# Conformal prediction confidence intervals
forecast_conformal <- calibration_tbl %>%
    modeltime_forecast(
        new_data      = testing(splits),
        actual_data   = m750,
        conf_interval = 0.95,
        conf_method   = "conformal_split"
    )
```

--------------------------------

### Basic Prophet Model Specification

Source: https://context7.com/business-science/modeltime/llms.txt

Generates a basic Prophet model specification using the 'prophet' engine. Requires time series data with a date column.

```r
library(modeltime)
library(tidymodels)
library(timetk)
library(dplyr)

m750 <- m4_monthly %>% filter(id == "M750")
splits <- initial_time_split(m750, prop = 0.9)

# Basic Prophet model
model_prophet <- prophet_reg() %>%
    set_engine("prophet") %>%
    fit(value ~ date, data = training(splits))
```

--------------------------------

### Prepare Nested Data Structure for Modeltime

Source: https://context7.com/business-science/modeltime/llms.txt

Prepares time series data by extending, nesting, and splitting it for use with modeltime. Ensure data is formatted correctly before using these functions.

```r
nested_data_tbl <- data_tbl %>%
    extend_timeseries(
        .id_var        = id,
        .date_var      = date,
        .length_future = 52
    ) %>%
    nest_timeseries(
        .id_var        = id,
        .length_future = 52,
        .length_actual = 52 * 2
    ) %>%
    split_nested_timeseries(
        .length_test = 52
    )
```

--------------------------------

### Create Unified Modeltime Table

Source: https://context7.com/business-science/modeltime/llms.txt

Combines multiple fitted models (ARIMA, Random Forest workflow, XGBoost workflow) into a single modeltime table. This table allows for unified calibration, accuracy assessment, and forecasting.

```r
models_tbl <- modeltime_table(
    model_arima,
    wflw_fit_rf,
    wflw_fit_xgb
)
```

--------------------------------

### Fit XGBoost Workflow

Source: https://context7.com/business-science/modeltime/llms.txt

Fits an XGBoost tidymodels workflow to the training data. This fitted workflow is ready for subsequent steps like calibration and forecasting.

```r
wflw_fit_xgb <- wflw_xgb %>% fit(training(splits))
```

--------------------------------

### Define Prophet Model Specification

Source: https://context7.com/business-science/modeltime/llms.txt

Sets up a Prophet model specification. Prophet is a forecasting procedure developed by Facebook.

```r
model_spec_prophet <- prophet_reg() %>%
    set_engine("prophet")
```

--------------------------------

### Combine Multiple Modeltime Tables

Source: https://context7.com/business-science/modeltime/llms.txt

Combines several individual modeltime tables (ARIMA, ETS, Prophet) into a single, comprehensive table. This facilitates comparison and ensemble modeling.

```r
combined_tbl <- combine_modeltime_tables(arima_tbl, ets_tbl, prophet_tbl)
```

--------------------------------

### Organize Models into a Modeltime Table

Source: https://context7.com/business-science/modeltime/llms.txt

Groups multiple fitted models into a single table for unified forecasting. Supports creation from individual models or a list.

```r
library(modeltime)
library(tidymodels)
library(timetk)
library(dplyr)

m750 <- m4_monthly %>% filter(id == "M750")
splits <- initial_time_split(m750, prop = 0.9)

# Fit multiple models
model_arima <- arima_reg() %>%
    set_engine("auto_arima") %>%
    fit(value ~ date, data = training(splits))

model_ets <- exp_smoothing() %>%
    set_engine("ets") %>%
    fit(value ~ date, data = training(splits))

model_prophet <- prophet_reg() %>%
    set_engine("prophet") %>%
    fit(value ~ date, data = training(splits))

# Create modeltime table with all models
models_tbl <- modeltime_table(
    model_arima,
    model_ets,
    model_prophet
)

# Alternative: convert list of models
model_list <- list(model_arima, model_ets, model_prophet)
models_tbl <- as_modeltime_table(model_list)

# Output shows .model_id, .model, and .model_desc columns
print(models_tbl)
# # Modeltime Table
# # A tibble: 3 x 3
#   .model_id .model   .model_desc
#       <int> <list>   <chr>
# 1         1 <fit[+]> ARIMA(0,1,1)(0,1,1)[12]
# 2         2 <fit[+]> ETS(M,A,M)
# 3         3 <fit[+]> PROPHET
```

--------------------------------

### Retrain Models with modeltime_refit

Source: https://context7.com/business-science/modeltime/llms.txt

Retrains models on updated datasets. Supports parallel processing for efficiency.

```r
library(modeltime)
library(tidymodels)
library(timetk)
library(dplyr)

m750 <- m4_monthly %>% filter(id == "M750")
splits <- initial_time_split(m750, prop = 0.9)

model_arima <- arima_reg() %>%
    set_engine("auto_arima") %>%
    fit(value ~ date, data = training(splits))

model_prophet <- prophet_reg() %>%
    set_engine("prophet") %>%
    fit(value ~ date, data = training(splits))

models_tbl <- modeltime_table(model_arima, model_prophet)

calibration_tbl <- models_tbl %>%
    modeltime_calibrate(new_data = testing(splits))

# Refit on full dataset for production forecasting
refit_tbl <- calibration_tbl %>%
    modeltime_refit(data = m750)

# Generate future forecast after refitting
future_forecast <- refit_tbl %>%
    modeltime_forecast(
        h           = "3 years",
        actual_data = m750
    )

# Parallel refitting for many models
refit_parallel <- calibration_tbl %>%
    modeltime_refit(
        data    = m750,
        control = control_refit(
            verbose   = TRUE,
            cores     = 4,
            allow_par = TRUE
        )
    )
```

--------------------------------

### Visualize Forecasts with plot_modeltime_forecast

Source: https://context7.com/business-science/modeltime/llms.txt

Generates interactive plotly or static ggplot2 visualizations for forecast objects.

```r
library(modeltime)
library(tidymodels)
library(timetk)
library(dplyr)

m750 <- m4_monthly %>% filter(id == "M750")
splits <- initial_time_split(m750, prop = 0.9)

model_arima <- arima_reg() %>%
    set_engine("auto_arima") %>%
    fit(value ~ date, data = training(splits))

model_prophet <- prophet_reg() %>%
    set_engine("prophet") %>%
    fit(value ~ date, data = training(splits))

models_tbl <- modeltime_table(model_arima, model_prophet)

calibration_tbl <- models_tbl %>%
    modeltime_calibrate(new_data = testing(splits))

# Interactive plotly forecast visualization
calibration_tbl %>%
    modeltime_forecast(
        new_data    = testing(splits),
        actual_data = m750
    ) %>%
    plot_modeltime_forecast(.interactive = TRUE)

# Static ggplot2 visualization
calibration_tbl %>%
    modeltime_forecast(
        new_data    = testing(splits),
        actual_data = m750
    ) %>%
    plot_modeltime_forecast(
        .interactive         = FALSE,
        .conf_interval_show  = TRUE,
        .conf_interval_fill  = "lightblue",
        .conf_interval_alpha = 0.25,
        .legend_show         = TRUE,
        .title               = "Monthly Forecast Comparison"
    )
```

--------------------------------

### Croston's Method for Intermittent Demand

Source: https://context7.com/business-science/modeltime/llms.txt

Fits a time series model using Croston's method, suitable for intermittent demand patterns. Requires specifying the smoothing level.

```r
# Croston's method for intermittent demand
model_croston <- exp_smoothing(smooth_level = 0.2) %>%
    set_engine("croston") %>%
    fit(value ~ date, data = training(splits))
```

--------------------------------

### Fit Random Forest Workflow

Source: https://context7.com/business-science/modeltime/llms.txt

Fits a Random Forest tidymodels workflow to the training data. The fitted workflow can then be used for calibration and forecasting.

```r
wflw_fit_rf <- wflw_rf %>% fit(training(splits))
```

--------------------------------

### Create Boosted ARIMA Models

Source: https://context7.com/business-science/modeltime/llms.txt

Uses arima_boost to combine ARIMA with XGBoost for residual modeling. Requires the modeltime and tidymodels ecosystems.

```r
library(modeltime)
library(tidymodels)
library(timetk)
library(dplyr)
library(lubridate)

m750 <- m4_monthly %>% filter(id == "M750")
splits <- initial_time_split(m750, prop = 0.9)

# Boosted ARIMA - ARIMA + XGBoost for residuals
model_arima_boost <- arima_boost(
    min_n      = 2,
    learn_rate = 0.015
) %>%
    set_engine("auto_arima_xgboost") %>%
    fit(
        value ~ date + as.numeric(date) + factor(month(date, label = TRUE)),
        data = training(splits)
    )
```

--------------------------------

### Configure NNETAR Model

Source: https://github.com/business-science/modeltime/blob/master/NEWS.md

Use `nnetar_reg()` with `set_engine("nnetar")` to configure an NNETAR model. This function is used for setting up the NNETAR model specification.

```r
model_fit_nnetar <- nnetar_reg() %>%
    set_engine("nnetar")
```

--------------------------------

### Manual Exponential Smoothing Model Specification

Source: https://context7.com/business-science/modeltime/llms.txt

Creates a manual ETS model specification with explicit settings for error, trend, season components, and damping. Supports various combinations like (M,A,M).

```r
# Manual ETS(M,A,M) - multiplicative error, additive trend, multiplicative season
model_ets_mam <- exp_smoothing(
    seasonal_period = 12,
    error           = "multiplicative",
    trend           = "additive",
    season          = "multiplicative",
    damping         = "damped"
) %>%
    set_engine("ets") %>%
    fit(value ~ date, data = training(splits))
```

--------------------------------

### Calculate Forecast Accuracy Metrics

Source: https://context7.com/business-science/modeltime/llms.txt

Computes standard and custom accuracy metrics for calibrated models. Supports interactive table formatting and extended metrics for intermittent series.

```r
library(modeltime)
library(tidymodels)
library(timetk)
library(dplyr)

m750 <- m4_monthly %>% filter(id == "M750")
splits <- initial_time_split(m750, prop = 0.9)

model_arima <- arima_reg() %>%
    set_engine("auto_arima") %>%
    fit(value ~ date, data = training(splits))

model_prophet <- prophet_reg() %>%
    set_engine("prophet") %>%
    fit(value ~ date, data = training(splits))

models_tbl <- modeltime_table(model_arima, model_prophet)

# Calculate accuracy after calibration
accuracy_tbl <- models_tbl %>%
    modeltime_calibrate(new_data = testing(splits)) %>%
    modeltime_accuracy()

# Output: tibble with .model_id, .model_desc, and accuracy metrics
# mae, mape, mase, smape, rmse, rsq

# Custom metric set
accuracy_custom <- models_tbl %>%
    modeltime_calibrate(new_data = testing(splits)) %>%
    modeltime_accuracy(metric_set = metric_set(mae, rmse, rsq))

# Format as interactive table
accuracy_tbl %>%
    table_modeltime_accuracy(.interactive = TRUE)

# For intermittent series, use extended metrics with MAAPE
accuracy_extended <- models_tbl %>%
    modeltime_calibrate(new_data = testing(splits)) %>%
    modeltime_accuracy(metric_set = extended_forecast_accuracy_metric_set())
```

--------------------------------

### Forecast with Confidence Intervals

Source: https://github.com/business-science/modeltime/blob/master/NEWS.md

The `modeltime_forecast()` function now estimates confidence intervals using centered standard deviation, assuming a mean of zero for residuals.

```r
modeltime_forecast(model_table, new_data = future_data, actual_data = actual_data, interval = 0.95)
```

--------------------------------

### Manual ARIMA Model Specification

Source: https://context7.com/business-science/modeltime/llms.txt

Creates a manual ARIMA model specification with specific non-seasonal and seasonal orders (p,d,q)(P,D,Q). Requires specifying the seasonal period.

```r
# Manual ARIMA(3,1,3)(1,0,1)[12] specification
model_arima <- arima_reg(
    seasonal_period          = 12,
    non_seasonal_ar          = 3,
    non_seasonal_differences = 1,
    non_seasonal_ma          = 3,
    seasonal_ar              = 1,
    seasonal_differences     = 0,
    seasonal_ma              = 1
) %>%
    set_engine("arima") %>%
    fit(log(value) ~ date, data = training(splits))
```

--------------------------------

### Prophet Model with Logistic Growth

Source: https://context7.com/business-science/modeltime/llms.txt

Fits a Prophet model using logistic growth, which is suitable for time series with a saturation point. Requires specifying logistic capacity and floor.

```r
# Prophet with logistic growth (saturation)
model_prophet_logistic <- prophet_reg(
    growth         = "logistic",
    logistic_cap   = 15000,
    logistic_floor = 0
) %>%
    set_engine("prophet") %>%
    fit(value ~ date, data = training(splits))
```

--------------------------------

### Define Random Forest Model Specification

Source: https://context7.com/business-science/modeltime/llms.txt

Sets up a Random Forest model specification with 500 trees. This is a regression model suitable for time series forecasting.

```r
model_spec_rf <- rand_forest(trees = 500) %>%
    set_engine("randomForest") %>%
    set_mode("regression")
```

--------------------------------

### Create ETS Modeltime Table

Source: https://context7.com/business-science/modeltime/llms.txt

Creates a modeltime table containing only the fitted ETS model. This allows for focused analysis or combination with other model tables.

```r
ets_tbl <- modeltime_table(model_ets)
```

--------------------------------

### Forecast with Actual Data Reconciliation

Source: https://github.com/business-science/modeltime/blob/master/NEWS.md

When using `modeltime_forecast()`, the `actual_data` reconciliation strategy attempts to fill missing rows using a "downup" strategy if the recipe removes them. This prevents `NA` values from causing issues.

```r
modeltime_forecast(model_table, new_data = future_data, actual_data = actual_data)
```

--------------------------------

### Prophet Boost Thread Safety

Source: https://github.com/business-science/modeltime/blob/master/NEWS.md

For `prophet_boost()`, `nthreads` is set to 1 by default to ensure thread safety, addressing potential issues with parallelization.

```r
prophet_boost(nthreads = 1)
```

--------------------------------

### Model Refit with Parameter Updates

Source: https://github.com/business-science/modeltime/blob/master/NEWS.md

When `modeltime_refit()` updates model parameters (e.g., Auto ARIMA selecting a new model), the Model Description column will indicate the change, such as "UPDATE: ARIMA(0,1,1)(1,1,1)[12]".

```r
modeltime_refit(model_table, new_data = training(splits))
```

--------------------------------

### Auto Exponential Smoothing Model Specification

Source: https://context7.com/business-science/modeltime/llms.txt

Generates an Exponential Smoothing (ETS) model specification with automatic component selection using the 'ets' engine. Requires time series data.

```r
library(modeltime)
library(tidymodels)
library(timetk)
library(dplyr)

m750 <- m4_monthly %>% filter(id == "M750")
splits <- initial_time_split(m750, prop = 0.9)

# Auto ETS - automatic component selection
model_ets_auto <- exp_smoothing() %>%
    set_engine("ets") %>%
    fit(value ~ date, data = training(splits))
```

--------------------------------

### Configure TBATS Model

Source: https://github.com/business-science/modeltime/blob/master/NEWS.md

Use `seasonal_reg()` with `set_engine("tbats")` to configure a TBATS model. Specify seasonal periods for daily and weekly seasonality.

```r
seasonal_reg(
    seasonal_period_1 = "1 day",
    seasonal_period_2 = "1 week"
) %>%
    set_engine("tbats")
```

--------------------------------

### modeltime_calibrate - Calibrate Models

Source: https://context7.com/business-science/modeltime/llms.txt

Computes out-of-sample predictions and residuals for confidence interval estimation and accuracy calculation.

```APIDOC
## modeltime_calibrate

### Description
Calibrates a Modeltime Table against new data (test set) to compute residuals.

### Parameters
- **new_data** (data.frame) - Required - The testing dataset.
- **id** (string) - Optional - Column name for panel data identification.
```

--------------------------------

### Theta Method for Time Series Forecasting

Source: https://context7.com/business-science/modeltime/llms.txt

Fits a time series model using the Theta method. This is a simple yet effective forecasting technique.

```r
# Theta method
model_theta <- exp_smoothing() %>%
    set_engine("theta") %>%
    fit(value ~ date, data = training(splits))
```

--------------------------------

### Refit Best Nested Models and Forecast Future

Source: https://context7.com/business-science/modeltime/llms.txt

Refits the best selected models to the full dataset and extracts future forecasts. This is a common workflow for generating production forecasts.

```r
future_forecast <- best_nested_tbl %>%
    modeltime_nested_refit(data = data_tbl) %>%
    extract_nested_future_forecast()
```

--------------------------------

### Model Calibration with Fitted Data

Source: https://github.com/business-science/modeltime/blob/master/NEWS.md

For sequence-based models, `modeltime_calibrate()` checks for existing "Fitted" data when training data overlaps with previous training windows. If found, it uses the "Fitted" data to prevent odd results. The `.type` column will show "Fitted" in this case.

```r
modeltime_calibrate(model_table, training(splits))
```

--------------------------------

### Calibrate Models

Source: https://context7.com/business-science/modeltime/llms.txt

Calibrates a modeltime table against a test dataset. Calibration is a necessary step before accuracy assessment or forecasting.

```r
calibration_tbl <- models_tbl %>%
    modeltime_calibrate(new_data = testing(splits))
```

--------------------------------

### arima_boost - Boosted ARIMA Models

Source: https://context7.com/business-science/modeltime/llms.txt

Combines ARIMA with XGBoost to model residuals, capturing both linear time series patterns and non-linear relationships.

```APIDOC
## arima_boost

### Description
Creates a boosted ARIMA model that uses XGBoost to model the residuals of an ARIMA model.

### Parameters
- **min_n** (numeric) - Required - Minimum number of data points in a node for splitting.
- **learn_rate** (numeric) - Required - The learning rate for the XGBoost engine.

### Request Example
model_arima_boost <- arima_boost(min_n = 2, learn_rate = 0.015) %>% set_engine("auto_arima_xgboost")
```

--------------------------------

### Add New Model to Modeltime Table

Source: https://context7.com/business-science/modeltime/llms.txt

Use `add_modeltime_model()` to append a newly fitted model to an existing modeltime table. Ensure the model object is compatible with modeltime.

```r
model_new <- arima_boost() %>%
    set_engine("auto_arima_xgboost") %>%
    fit(value ~ date + as.numeric(date), data = training(splits))

combined_tbl <- combined_tbl %>%
    add_modeltime_model(model_new)
```

--------------------------------

### Create ARIMA Modeltime Table

Source: https://context7.com/business-science/modeltime/llms.txt

Creates a modeltime table containing only the fitted ARIMA model. This is useful for isolating specific models or preparing for table combination.

```r
arima_tbl <- modeltime_table(model_arima)
```

--------------------------------

### modeltime_accuracy - Calculate Accuracy

Source: https://context7.com/business-science/modeltime/llms.txt

Computes forecast accuracy metrics (MAE, MAPE, MASE, SMAPE, RMSE, RSQ) from calibrated models.

```APIDOC
## modeltime_accuracy

### Description
Calculates performance metrics for calibrated models.

### Parameters
- **metric_set** (function) - Optional - A custom set of metrics to calculate.

### Response
- **mae, mape, mase, smape, rmse, rsq** (numeric) - Various accuracy metrics calculated for the models.
```

--------------------------------

### Combine Modeltime Tables

Source: https://github.com/business-science/modeltime/blob/master/NEWS.md

Use `combine_modeltime_tables()` to merge multiple modeltime tables into a single table. This is a helper function for organizing results.

```r
combine_modeltime_tables(list_of_tables)
```

--------------------------------

### Prophet Model with External Regressors

Source: https://context7.com/business-science/modeltime/llms.txt

Fits a Prophet model that incorporates external regressors, such as a factor representing the month. The formula specifies the target variable, date, and regressors.

```r
# Prophet with external regressors
model_prophet_xreg <- prophet_reg() %>%
    set_engine("prophet") %>%
    fit(value ~ date + factor(month(date)), data = training(splits))
```

--------------------------------

### Calibrate Models on Test Data

Source: https://context7.com/business-science/modeltime/llms.txt

Computes out-of-sample predictions and residuals. Use the id argument for panel data.

```r
library(modeltime)
library(tidymodels)
library(timetk)
library(dplyr)

m750 <- m4_monthly %>% filter(id == "M750")
splits <- initial_time_split(m750, prop = 0.9)

# Fit and organize models
model_arima <- arima_reg() %>%
    set_engine("auto_arima") %>%
    fit(value ~ date, data = training(splits))

model_prophet <- prophet_reg() %>%
    set_engine("prophet") %>%
    fit(value ~ date, data = training(splits))

models_tbl <- modeltime_table(model_arima, model_prophet)

# Calibrate on testing data
calibration_tbl <- models_tbl %>%
    modeltime_calibrate(new_data = testing(splits))

# Calibration adds .type and .calibration_data columns
print(calibration_tbl)

# Calibration data contains predictions and residuals
calibration_tbl$.calibration_data[[1]]
# # A tibble with columns:
# #   date, .actual, .prediction, .residuals

# For panel data with multiple time series, specify id column
# calibration_tbl <- models_tbl %>%
#     modeltime_calibrate(new_data = testing(splits), id = "id")
```

--------------------------------

### Select Best Nested Model

Source: https://context7.com/business-science/modeltime/llms.txt

Selects the best performing model for each group within a nested modeltime table based on a specified metric (e.g., 'rmse').

```r
best_nested_tbl <- nested_modeltime_tbl %>%
    modeltime_nested_select_best(metric = "rmse")
```

--------------------------------

### Auto ARIMA Model Specification

Source: https://context7.com/business-science/modeltime/llms.txt

Generates an ARIMA model specification with automatic parameter selection using the 'auto_arima' engine. Requires data with a time-based feature.

```r
library(modeltime)
library(tidymodels)
library(timetk)
library(dplyr)

# Data preparation
m750 <- m4_monthly %>% filter(id == "M750")
splits <- initial_time_split(m750, prop = 0.9)

# Auto ARIMA - automatic parameter selection
model_auto_arima <- arima_reg() %>%
    set_engine("auto_arima") %>%
    fit(value ~ date, data = training(splits))
```

--------------------------------

### ARIMA with Exogenous Regressors

Source: https://context7.com/business-science/modeltime/llms.txt

Fits an ARIMA model that includes exogenous regressors, such as a factor representing the month of the year. Uses 'auto_arima' engine for automatic order selection.

```r
# ARIMA with exogenous regressors
model_arima_xreg <- arima_reg() %>%
    set_engine("auto_arima") %>%
    fit(value ~ date + factor(month(date, label = TRUE)),
        data = training(splits))
```

--------------------------------

### Assess Model Accuracy

Source: https://context7.com/business-science/modeltime/llms.txt

Calculates accuracy metrics for the calibrated models using the test data. This helps in comparing the performance of different forecasting models.

```r
calibration_tbl %>% modeltime_accuracy()
```

--------------------------------

### Update Model Descriptions

Source: https://context7.com/business-science/modeltime/llms.txt

Updates the descriptions for models within a combined modeltime table. This improves clarity and documentation, especially when dealing with multiple models.

```r
combined_tbl <- combined_tbl %>%
    update_model_description(1, "ARIMA - Auto Selected") %>%
    update_model_description(2, "ETS - State Space") %>%
    update_model_description(3, "Prophet - Facebook")
```

--------------------------------

### Extract Nested Test Forecasts

Source: https://context7.com/business-science/modeltime/llms.txt

Extracts the test forecasts for all models across all groups from a nested modeltime table. This allows for visual inspection and further analysis of predictions.

```r
nested_modeltime_tbl %>%
    extract_nested_test_forecast()
```

--------------------------------

### Fit ARIMA Model

Source: https://context7.com/business-science/modeltime/llms.txt

Fits an ARIMA model to the training data using the 'auto_arima' engine. This is a standard time series model.

```r
model_arima <- arima_reg() %>%
    set_engine("auto_arima") %>%
    fit(value ~ date, data = training(splits))
```

--------------------------------

### Update Model Description

Source: https://github.com/business-science/modeltime/blob/master/NEWS.md

Use `update_model_description()` to easily modify the description of a model within a modeltime table. This function aids in customizing model metadata.

```r
update_model_description(model_id = "model_1", new_description = "Updated Description")
```

--------------------------------

### Fit Models to Nested Time Series Data

Source: https://context7.com/business-science/modeltime/llms.txt

Fits a list of specified models (ARIMA, Prophet, XGBoost workflow) to nested time series data. The 'control_nested_fit' function can be used to control verbosity.

```r
nested_modeltime_tbl <- nested_data_tbl %>%
    modeltime_nested_fit(
        model_list = list(
            model_spec_arima,
            model_spec_prophet,
            wflw_xgb
        ),
        control = control_nested_fit(verbose = TRUE)
    )
```

--------------------------------

### Remove Model by ID from Modeltime Table

Source: https://context7.com/business-science/modeltime/llms.txt

Use `drop_modeltime_model()` to remove one or more models from a modeltime table by their `.model_id`. This is useful for cleaning up or excluding specific models from analysis.

```r
combined_tbl <- combined_tbl %>%
    drop_modeltime_model(.model_id = c(2))
```

--------------------------------

### Fit ETS Model

Source: https://context7.com/business-science/modeltime/llms.txt

Fits an Exponential Smoothing (ETS) model to the training data. ETS models are a class of statistical models for time series forecasting.

```r
model_ets <- exp_smoothing() %>%
    set_engine("ets") %>%
    fit(value ~ date, data = training(splits))
```

--------------------------------

### Extract Nested Test Accuracy

Source: https://context7.com/business-science/modeltime/llms.txt

Extracts the test accuracy metrics for all models across all groups in a nested modeltime table. This is useful for evaluating model performance.

```r
nested_modeltime_tbl %>%
    extract_nested_test_accuracy()
```

--------------------------------

### Extract Specific Model from Modeltime Table

Source: https://context7.com/business-science/modeltime/llms.txt

Use `pluck_modeltime_model()` to extract a specific fitted model object from a modeltime table using its `.model_id`. This allows for further inspection or manipulation of individual models.

```r
extracted_model <- combined_tbl %>%
    pluck_modeltime_model(.model_id = 1)
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.