Fable Modelling & Accuracy Metrics

Core Modelling Pipeline

The core modeling pipeline in the fable framework follows four tidy steps:

1. Declare the tsibble
2. Fit models with model()
3. Generate forecasts with forecast()
4. Visualize with autoplot()

This workflow is designed to align with the tidyverse philosophy — making it intuitive, scalable, and easy to integrate with tools like ggplot2, dplyr, and patchwork.

Setup

Load Libraries

• When you run the code, try to hide all the associated output and warning for the packages below (for cleaner presentation). Of course, read the warning and see if you have to take any appropriate action.

  • Make sure you read up on the syntax of each package

library(fpp3)

Warning: package 'fpp3' was built under R version 4.5.2

Registered S3 method overwritten by 'tsibble':
  method               from 
  as_tibble.grouped_df dplyr

── Attaching packages ──────────────────────────────────────────── fpp3 1.0.2 ──

✔ tibble      3.3.0     ✔ tsibble     1.1.6
✔ dplyr       1.1.4     ✔ tsibbledata 0.4.1
✔ tidyr       1.3.1     ✔ feasts      0.4.2
✔ lubridate   1.9.4     ✔ fable       0.5.0
✔ ggplot2     3.5.2     

Warning: package 'tsibble' was built under R version 4.5.2

Warning: package 'tsibbledata' was built under R version 4.5.2

Warning: package 'feasts' was built under R version 4.5.2

Warning: package 'fabletools' was built under R version 4.5.2

Warning: package 'fable' was built under R version 4.5.2

── Conflicts ───────────────────────────────────────────────── fpp3_conflicts ──
✖ lubridate::date()    masks base::date()
✖ dplyr::filter()      masks stats::filter()
✖ tsibble::intersect() masks base::intersect()
✖ tsibble::interval()  masks lubridate::interval()
✖ dplyr::lag()         masks stats::lag()
✖ tsibble::setdiff()   masks base::setdiff()
✖ tsibble::union()     masks base::union()

library(fredr)

Warning: package 'fredr' was built under R version 4.5.2

library(tidyverse)

Warning: package 'stringr' was built under R version 4.5.2

── Attaching core tidyverse packages ──────────────────────── tidyverse 2.0.0 ──
✔ forcats 1.0.1     ✔ readr   2.1.5
✔ purrr   1.1.0     ✔ stringr 1.6.0

── Conflicts ────────────────────────────────────────── tidyverse_conflicts() ──
✖ dplyr::filter()     masks stats::filter()
✖ tsibble::interval() masks lubridate::interval()
✖ dplyr::lag()        masks stats::lag()
ℹ Use the conflicted package (<http://conflicted.r-lib.org/>) to force all conflicts to become errors

library(patchwork)
library(knitr)
library(kableExtra)

Attaching package: 'kableExtra'

The following object is masked from 'package:dplyr':

    group_rows

library(writexl)

Warning: package 'writexl' was built under R version 4.5.2

Import Data

• Get your own FRED key. https://fred.stlouisfed.org/docs/api/api_key.html

  • Getting started with fredr https://cran.r-project.org/web/packages/fredr/vignettes/fredr.html

remove(list=ls())

fredr_set_key("18f0dfa970a5782481171e8fa3980e41") # replace with your own key please

?fredr

starting httpd help server ... done

myts <- fredr(series_id = "CPIAUCSL",
              observation_start = as.Date("1980-01-01"),
              observation_end   = as.Date("2024-12-01")
              ) |>
  transmute(Month = yearmonth(date), value) |>
  as_tsibble(index = Month)

glimpse(myts)

Rows: 540
Columns: 2
$ Month <mth> 1980 Jan, 1980 Feb, 1980 Mar, 1980 Apr, 1980 May, 1980 Jun, 1980…
$ value <dbl> 78.0, 79.0, 80.1, 80.9, 81.7, 82.5, 82.6, 83.2, 83.9, 84.7, 85.6…

str(myts)

tbl_ts [540 × 2] (S3: tbl_ts/tbl_df/tbl/data.frame)
 $ Month: mth [1:540] 1980 Jan, 1980 Feb, 1980 Mar, 1980 Apr, 1980 May, 1980 Jun...
 $ value: num [1:540] 78 79 80.1 80.9 81.7 82.5 82.6 83.2 83.9 84.7 ...
 - attr(*, "key")= tibble [1 × 1] (S3: tbl_df/tbl/data.frame)
  ..$ .rows: list<int> [1:1] 
  .. ..$ : int [1:540] 1 2 3 4 5 6 7 8 9 10 ...
  .. ..@ ptype: int(0) 
 - attr(*, "index")= chr "Month"
  ..- attr(*, "ordered")= logi TRUE
 - attr(*, "index2")= chr "Month"
 - attr(*, "interval")= interval [1:1] 1M
  ..@ .regular: logi TRUE

• Try to play with the frequency argument in particular and aggregation_method in fredr command.

Tip

Month is the tsibble index.

Split Data

Why Split Data into Train and Test Sets?

1. To Evaluate Out-of-Sample Performance (Generalization Ability):

   • The training set is used to fit the model — it learns patterns from this data.

   • The test set is held out to simulate unseen, future data.

     This helps assess whether the model truly learns meaningful patterns or is just overfitting to noise in the training data.

2. To Mimic Real-World Forecasting Scenarios:

   • In practice, we forecast the future based on the past.

   • A time-based split (like 80% train / 20% test) replicates this real-world condition by ensuring the test data occurs after the training data in time — which is especially crucial in time series forecasting.

There are always multiple ways to do the same thing.

Method 1

train <- myts |> filter_index(~"2015 Dec")
test  <- myts |> filter_index("2016 Jan"~.)

Method 2

split_index <- floor(0.8 * nrow(myts))

# Create training and test sets
train <- myts[1:split_index, ]
test  <- myts[(split_index + 1):nrow(myts), ]

Either way, describe your train and test data.

head(train, 1)

# A tsibble: 1 x 2 [1M]
     Month value
     <mth> <dbl>
1 1980 Jan    78

tail(x = train, n = 1) # Show last month of training set

# A tsibble: 1 x 2 [1M]
     Month value
     <mth> <dbl>
1 2015 Dec  238.

head(x = test, n = 1) # Show first month of test set

# A tsibble: 1 x 2 [1M]
     Month value
     <mth> <dbl>
1 2016 Jan  238.

tail(test, 1)

# A tsibble: 1 x 2 [1M]
     Month value
     <mth> <dbl>
1 2024 Dec  318.

EG - Train data contains monthly observations from January, 1980 - December, 2015 while the test data contains monthly observations from January, 2016 - December, 2024.

Forecasting

We will use the fable framework for forecasting.

Package	Purpose
tsibble	A tidy data structure for time series (like data.frame, but with time-awareness)
feasts	Feature extraction and visualization (seasonality, autocorrelation, etc.)
fable	Forecasting models and methods (e.g., ARIMA, ETS, NAIVE, etc.)
fabletools	Common tools and infrastructure for building forecasting models

tsibble

A tsibble (short for tidy temporal tibble) is a time series-aware data frame from the tsibble package in the fable forecasting framework. It builds on the tibble¹ structure but adds time-related features that make working with time series more natural and powerful in the tidyverse style.

Key Features of a tsibble

Feature	Description
Index	A time variable (e.g., Month, Date, Year) that defines time order
Key	One or more variables identifying multiple series (e.g., by country)
Regularity	Can detect whether data is regular (monthly, quarterly, etc.)
Tidy Format	Fully compatible with dplyr, ggplot2, and other tidyverse tools

Common tsibble Functions

Function	Use
as_tsibble()	Convert data to tsibble format
index_by()	Aggregate to a different time unit
fill_gaps()	Fill missing time periods
has_gaps()	Check for missing intervals
interval()	Report frequency (e.g., monthly)

tsibble::has_gaps(myts)

# A tibble: 1 × 1
  .gaps
  <lgl>
1 FALSE

tsibble::interval(myts)

<interval[1]>
[1] 1M

Important

Before modeling, your time series object train must be declared a tsibble (tidy temporal data structure used by fable).

feasts

The feasts package (Features Extracted from Time Series) is part of the fpp3 framework and provides tools for exploratory data analysis (EDA) and feature extraction for time series models.

It works seamlessly with tsibble objects and focuses on visualizing, decomposing, and extracting features from time series data. These tools are especially useful before modeling, helping you understand structure, seasonality, trends, outliers, and autocorrelation.

Key Features of feasts

Feature	Description
Time series decomposition	STL() for seasonal-trend decomposition
Visual diagnostics	Built-in autoplot() support for ACF, decompositions, and more
Statistical summaries	Extract summaries like trend strength, seasonal strength, entropy
Fourier terms	Generate Fourier terms for modeling complex seasonality
Spectral and autocorrelation tools	Easily compute and visualize ACF, PACF, and periodograms

Common feasts Functions

Function	Purpose
STL()	Seasonal-Trend decomposition using Loess
ACF() / PACF()	Autocorrelation and partial autocorrelation functions
features()	Extracts numeric summaries/statistics for modeling or clustering
Fourier()	Adds seasonal Fourier terms as predictors
gg_season()	Seasonal plots using ggplot2
gg_subseries()	Subseries plots (seasonal slices over time)

When to Use feasts

Use feasts when:

• You want to visualize patterns before modeling

• You want to diagnose structure (seasonality, trend, irregularity)

• You’re preparing a dataset for model comparison or ML feature selection

feasts is focused on feature discovery and diagnostic plotting, complementing the modeling tools provided by fable.

Decomposition

Both models decompose the series using STL, then forecast the seasonally adjusted component with ETS. The additive model assumes constant seasonal effects, while the multiplicative model assumes proportional seasonality via a log transform.

?decomposition_model # fabletools
?STL # fable
?ETS # fable


mods <- train |>
  fabletools::model(
    additive = decomposition_model(
      STL(formula = value ~ season(window="periodic")),
      ETS(formula = season_adjust ~ error("A") + trend("Ad") + season("N")) 
    ),
    multiplicative = decomposition_model(
      dcmp = STL(formula = log(value) ~ season(window = "periodic")),
      ETS(formula = season_adjust)
    )
  )

mods

# A mable: 1 x 2
                   additive            multiplicative
                    <model>                   <model>
1 <STL decomposition model> <STL decomposition model>

?components()

glimpse(mods)

Rows: 1
Columns: 2
$ additive       <model> [STL decomposition model]
$ multiplicative <model> [STL decomposition model]

If you’re using model pipelines (e.g., with fable or caret), many outputs are stored as nested lists. See Section 7.1 for more information. Here’s how you might extract model components:

Goal	Code
Full model	mods$multiplicative[[1]]
Internal ETS model	mods$multiplicative[[1]]$fit$e1$fit
Parameter estimates	mods$multiplicative[[1]]$fit$e1$fit$par
Fitted + residuals	mods$multiplicative[[1]]$fit$e1$fit$est
State estimates	mods$multiplicative[[1]]$fit$e1$fit$states
Accuracy measures	mods$multiplicative[[1]]$fit$e1$fit$fit
Model specification	mods$multiplicative[[1]]$fit$e1$fit$spec

str(mods) # skim

mdl_df [1 × 2] (S3: mdl_df/tbl_df/tbl/data.frame)
 $ additive      : lst_mdl [1:1] 
  ..$ :List of 5
  .. ..$ fit           :List of 2
  .. .. ..$ e1:List of 5
  .. .. .. ..$ fit           :List of 5
  .. .. .. .. ..$ par   : tibble [5 × 2] (S3: tbl_df/tbl/data.frame)
  .. .. .. .. .. ..$ term    : chr [1:5] "alpha" "beta" "phi" "l" ...
  .. .. .. .. .. ..$ estimate: num [1:5] 1 0.763 0.8 77.372 0.775
  .. .. .. .. ..$ est   : tbl_ts [432 × 4] (S3: tbl_ts/tbl_df/tbl/data.frame)
  .. .. .. .. .. ..$ Month        : mth [1:432] 1980 Jan, 1980 Feb, 1980 Mar, 1980 Apr, ...
  .. .. .. .. .. ..$ season_adjust: num [1:432] 78.2 79.2 80.3 81.1 81.9 ...
  .. .. .. .. .. ..$ .fitted      : num [1:432] 78 78.8 79.9 81.2 81.7 ...
  .. .. .. .. .. ..$ .resid       : num [1:432] 0.193 0.3714 0.437 -0.0726 0.146 ...
  .. .. .. .. .. ..- attr(*, "key")= tibble [1 × 1] (S3: tbl_df/tbl/data.frame)
  .. .. .. .. .. .. ..$ .rows: list<int> [1:1] 
  .. .. .. .. .. .. .. ..$ : int [1:432] 1 2 3 4 5 6 7 8 9 10 ...
  .. .. .. .. .. .. .. ..@ ptype: int(0) 
  .. .. .. .. .. ..- attr(*, "index")= chr "Month"
  .. .. .. .. .. .. ..- attr(*, "ordered")= logi TRUE
  .. .. .. .. .. ..- attr(*, "index2")= chr "Month"
  .. .. .. .. .. ..- attr(*, "interval")= interval [1:1] 1M
  .. .. .. .. .. .. ..@ .regular: logi TRUE
  .. .. .. .. ..$ fit   : tibble [1 × 8] (S3: tbl_df/tbl/data.frame)
  .. .. .. .. .. ..$ sigma2 : num 0.21
  .. .. .. .. .. ..$ log_lik: num -971
  .. .. .. .. .. ..$ AIC    : num 1954
  .. .. .. .. .. ..$ AICc   : num 1954
  .. .. .. .. .. ..$ BIC    : num 1979
  .. .. .. .. .. ..$ MSE    : num 0.207
  .. .. .. .. .. ..$ AMSE   : num 0.878
  .. .. .. .. .. ..$ MAE    : num 0.308
  .. .. .. .. ..$ states: tbl_ts [433 × 3] (S3: tbl_ts/tbl_df/tbl/data.frame)
  .. .. .. .. .. ..$ Month: mth [1:433] 1979 Dec, 1980 Jan, 1980 Feb, 1980 Mar, ...
  .. .. .. .. .. ..$ l    : num [1:433] 77.4 78.2 79.2 80.3 81.1 ...
  .. .. .. .. .. ..$ b    : num [1:433] 0.775 0.767 0.897 1.051 0.786 ...
  .. .. .. .. .. ..- attr(*, "key")= tibble [1 × 1] (S3: tbl_df/tbl/data.frame)
  .. .. .. .. .. .. ..$ .rows: list<int> [1:1] 
  .. .. .. .. .. .. .. ..$ : int [1:433] 1 2 3 4 5 6 7 8 9 10 ...
  .. .. .. .. .. .. .. ..@ ptype: int(0) 
  .. .. .. .. .. ..- attr(*, "index")= chr "Month"
  .. .. .. .. .. .. ..- attr(*, "ordered")= logi TRUE
  .. .. .. .. .. ..- attr(*, "index2")= chr "Month"
  .. .. .. .. .. ..- attr(*, "interval")= interval [1:1] 1M
  .. .. .. .. .. .. ..@ .regular: logi TRUE
  .. .. .. .. ..$ spec  : tibble [1 × 5] (S3: tbl_df/tbl/data.frame)
  .. .. .. .. .. ..$ errortype : chr "A"
  .. .. .. .. .. ..$ trendtype : chr "A"
  .. .. .. .. .. ..$ seasontype: chr "N"
  .. .. .. .. .. ..$ damped    : logi TRUE
  .. .. .. .. .. ..$ period    : num 12
  .. .. .. .. .. ..- attr(*, "out.attrs")=List of 2
  .. .. .. .. .. .. ..$ dim     : Named int [1:3] 1 1 1
  .. .. .. .. .. .. .. ..- attr(*, "names")= chr [1:3] "errortype" "trendtype" "seasontype"
  .. .. .. .. .. .. ..$ dimnames:List of 3
  .. .. .. .. .. .. .. ..$ errortype : chr "errortype=A"
  .. .. .. .. .. .. .. ..$ trendtype : chr "trendtype=Ad"
  .. .. .. .. .. .. .. ..$ seasontype: chr "seasontype=N"
  .. .. .. .. ..- attr(*, "class")= chr "ETS"
  .. .. .. ..$ model         :Classes 'mdl_defn', 'R6' <mdl_defn>
  Public:
    add_data: function (.data) 
    check: function (.data) 
    clone: function (deep = FALSE) 
    data: NULL
    env: environment
    extra: list
    formula: formula
    initialize: function (formula, ..., .env) 
    model: ETS
    origin: 1980 Jan
    prepare: function (...) 
    print: function (...) 
    recall_lag: function (x, n = 1L, ...) 
    recent_data: NULL
    remove_data: function () 
    specials: environment
    stage: NULL
    train: function (.data, specials, opt_crit, nmse, bounds, ic, restrict = TRUE,  
  .. .. .. ..$ data          : tbl_ts [432 × 2] (S3: tbl_ts/tbl_df/tbl/data.frame)
  .. .. .. .. ..$ Month        : mth [1:432] 1980 Jan, 1980 Feb, 1980 Mar, 1980 Apr, 198...
  .. .. .. .. ..$ season_adjust: num [1:432] 78.2 79.2 80.3 81.1 81.9 ...
  .. .. .. .. ..- attr(*, "key")= tibble [1 × 1] (S3: tbl_df/tbl/data.frame)
  .. .. .. .. .. ..$ .rows: list<int> [1:1] 
  .. .. .. .. .. .. ..$ : int [1:432] 1 2 3 4 5 6 7 8 9 10 ...
  .. .. .. .. .. .. ..@ ptype: int(0) 
  .. .. .. .. ..- attr(*, "index")= chr "Month"
  .. .. .. .. .. ..- attr(*, "ordered")= logi TRUE
  .. .. .. .. ..- attr(*, "index2")= chr "Month"
  .. .. .. .. ..- attr(*, "interval")= interval [1:1] 1M
  .. .. .. .. .. ..@ .regular: logi TRUE
  .. .. .. ..$ response      :List of 1
  .. .. .. .. ..$ : symbol season_adjust
  .. .. .. ..$ transformation:List of 1
  .. .. .. .. ..$ :function (season_adjust)  
  .. .. .. .. .. ..- attr(*, "class")= chr "transformation"
  .. .. .. .. .. ..- attr(*, "inverse")=function (season_adjust)  
  .. .. .. ..- attr(*, "class")= chr "mdl_ts"
  .. .. ..$ e2:List of 5
  .. .. .. ..$ fit           :List of 8
  .. .. .. .. ..$ b      : num(0) 
  .. .. .. .. ..$ b.se   : num(0) 
  .. .. .. .. ..$ lag    : num 12
  .. .. .. .. ..$ sigma2 : num 0
  .. .. .. .. ..$ .fitted: num [1:432] NA NA NA NA NA NA NA NA NA NA ...
  .. .. .. .. ..$ .resid : num [1:432] NA NA NA NA NA NA NA NA NA NA ...
  .. .. .. .. ..$ time   :List of 2
  .. .. .. .. .. ..$ start   : mth [1:1] 1980 Jan
  .. .. .. .. .. ..$ interval: interval [1:1] 1M
  .. .. .. .. .. .. ..@ .regular: logi TRUE
  .. .. .. .. ..$ future : num [1:12] -0.185 -0.17 -0.225 -0.193 -0.168 ...
  .. .. .. .. ..- attr(*, "class")= chr "RW"
  .. .. .. ..$ model         :Classes 'mdl_defn', 'R6' <mdl_defn>
  Public:
    add_data: function (.data) 
    check: function (.data) 
    clone: function (deep = FALSE) 
    data: NULL
    env: environment
    extra: list
    formula: formula
    initialize: function (formula, ..., .env) 
    model: RW
    origin: 1980 Jan
    prepare: function (...) 
    print: function (...) 
    recall_lag: function (x, n = 1L, ...) 
    recent_data: NULL
    remove_data: function () 
    specials: environment
    stage: NULL
    train: function (.data, specials, ...)  
  .. .. .. ..$ data          : tbl_ts [432 × 2] (S3: tbl_ts/tbl_df/tbl/data.frame)
  .. .. .. .. ..$ Month      : mth [1:432] 1980 Jan, 1980 Feb, 1980 Mar, 1980 Apr, 198...
  .. .. .. .. ..$ season_year: num [1:432] -0.185 -0.17 -0.225 -0.193 -0.168 ...
  .. .. .. .. ..- attr(*, "key")= tibble [1 × 1] (S3: tbl_df/tbl/data.frame)
  .. .. .. .. .. ..$ .rows: list<int> [1:1] 
  .. .. .. .. .. .. ..$ : int [1:432] 1 2 3 4 5 6 7 8 9 10 ...
  .. .. .. .. .. .. ..@ ptype: int(0) 
  .. .. .. .. ..- attr(*, "index")= chr "Month"
  .. .. .. .. .. ..- attr(*, "ordered")= logi TRUE
  .. .. .. .. ..- attr(*, "index2")= chr "Month"
  .. .. .. .. ..- attr(*, "interval")= interval [1:1] 1M
  .. .. .. .. .. ..@ .regular: logi TRUE
  .. .. .. ..$ response      :List of 1
  .. .. .. .. ..$ : symbol season_year
  .. .. .. ..$ transformation:List of 1
  .. .. .. .. ..$ :function (season_year)  
  .. .. .. .. .. ..- attr(*, "class")= chr "transformation"
  .. .. .. .. .. ..- attr(*, "inverse")=function (season_year)  
  .. .. .. ..- attr(*, "class")= chr "mdl_ts"
  .. .. ..- attr(*, "combination")= language e1 + e2
  .. .. ..- attr(*, "class")= chr [1:2] "decomposition_model" "model_combination"
  .. .. ..- attr(*, "dcmp_method")= chr "STL"
  .. ..$ model         :Classes 'mdl_defn', 'R6' <mdl_defn>
  Public:
    add_data: function (.data) 
    check: function (.data) 
    clone: function (deep = FALSE) 
    data: NULL
    env: environment
    extra: list
    formula: formula
    initialize: function (formula, ..., .env) 
    model: dcmp_mdl
    origin: 1980 Jan
    prepare: function (...) 
    print: function (...) 
    recall_lag: function (x, n = 1L, ...) 
    recent_data: NULL
    remove_data: function () 
    specials: environment
    stage: NULL
    train: function (.data, specials, ..., dcmp)  
  .. ..$ data          : tbl_ts [432 × 2] (S3: tbl_ts/tbl_df/tbl/data.frame)
  .. .. ..$ Month: mth [1:432] 1980 Jan, 1980 Feb, 1980 Mar, 1980 Apr, 1980 May,...
  .. .. ..$ value: num [1:432] 78 79 80.1 80.9 81.7 82.5 82.6 83.2 83.9 84.7 ...
  .. .. ..- attr(*, "key")= tibble [1 × 1] (S3: tbl_df/tbl/data.frame)
  .. .. .. ..$ .rows:List of 1
  .. .. .. .. ..$ : int [1:432] 1 2 3 4 5 6 7 8 9 10 ...
  .. .. ..- attr(*, "index")= chr "Month"
  .. .. .. ..- attr(*, "ordered")= logi TRUE
  .. .. ..- attr(*, "index2")= chr "Month"
  .. .. ..- attr(*, "interval")= interval [1:1] 1M
  .. .. .. ..@ .regular: logi TRUE
  .. ..$ response      :List of 1
  .. .. ..$ : symbol value
  .. ..$ transformation:List of 1
  .. .. ..$ :function (value)  
  .. .. .. ..- attr(*, "class")= chr "transformation"
  .. .. .. ..- attr(*, "inverse")=function (value)  
  .. ..- attr(*, "class")= chr "mdl_ts"
 $ multiplicative: lst_mdl [1:1] 
  ..$ :List of 5
  .. ..$ fit           :List of 2
  .. .. ..$ e1:List of 5
  .. .. .. ..$ fit           :List of 5
  .. .. .. .. ..$ par   : tibble [5 × 2] (S3: tbl_df/tbl/data.frame)
  .. .. .. .. .. ..$ term    : chr [1:5] "alpha" "beta" "phi" "l" ...
  .. .. .. .. .. ..$ estimate: num [1:5] 0.9999 0.6787 0.8334 4.3424 0.0185
  .. .. .. .. ..$ est   : tbl_ts [432 × 4] (S3: tbl_ts/tbl_df/tbl/data.frame)
  .. .. .. .. .. ..$ Month        : mth [1:432] 1980 Jan, 1980 Feb, 1980 Mar, 1980 Apr, ...
  .. .. .. .. .. ..$ season_adjust: num [1:432] 4.36 4.37 4.38 4.39 4.4 ...
  .. .. .. .. .. ..$ .fitted      : num [1:432] 4.36 4.37 4.38 4.4 4.4 ...
  .. .. .. .. .. ..$ .resid       : num [1:432] -5.65e-06 -1.29e-05 8.33e-04 -2.82e-04 2.79e-04 ...
  .. .. .. .. .. ..- attr(*, "key")= tibble [1 × 1] (S3: tbl_df/tbl/data.frame)
  .. .. .. .. .. .. ..$ .rows: list<int> [1:1] 
  .. .. .. .. .. .. .. ..$ : int [1:432] 1 2 3 4 5 6 7 8 9 10 ...
  .. .. .. .. .. .. .. ..@ ptype: int(0) 
  .. .. .. .. .. ..- attr(*, "index")= chr "Month"
  .. .. .. .. .. .. ..- attr(*, "ordered")= logi TRUE
  .. .. .. .. .. ..- attr(*, "index2")= chr "Month"
  .. .. .. .. .. ..- attr(*, "interval")= interval [1:1] 1M
  .. .. .. .. .. .. ..@ .regular: logi TRUE
  .. .. .. .. ..$ fit   : tibble [1 × 8] (S3: tbl_df/tbl/data.frame)
  .. .. .. .. .. ..$ sigma2 : num 2.55e-07
  .. .. .. .. .. ..$ log_lik: num 1273
  .. .. .. .. .. ..$ AIC    : num -2533
  .. .. .. .. .. ..$ AICc   : num -2533
  .. .. .. .. .. ..$ BIC    : num -2509
  .. .. .. .. .. ..$ MSE    : num 6.48e-06
  .. .. .. .. .. ..$ AMSE   : num 2.67e-05
  .. .. .. .. .. ..$ MAE    : num 0.000365
  .. .. .. .. ..$ states: tbl_ts [433 × 3] (S3: tbl_ts/tbl_df/tbl/data.frame)
  .. .. .. .. .. ..$ Month: mth [1:433] 1979 Dec, 1980 Jan, 1980 Feb, 1980 Mar, ...
  .. .. .. .. .. ..$ l    : num [1:433] 4.34 4.36 4.37 4.38 4.39 ...
  .. .. .. .. .. ..$ b    : num [1:433] 0.0185 0.0154 0.0128 0.0131 0.0101 ...
  .. .. .. .. .. ..- attr(*, "key")= tibble [1 × 1] (S3: tbl_df/tbl/data.frame)
  .. .. .. .. .. .. ..$ .rows: list<int> [1:1] 
  .. .. .. .. .. .. .. ..$ : int [1:433] 1 2 3 4 5 6 7 8 9 10 ...
  .. .. .. .. .. .. .. ..@ ptype: int(0) 
  .. .. .. .. .. ..- attr(*, "index")= chr "Month"
  .. .. .. .. .. .. ..- attr(*, "ordered")= logi TRUE
  .. .. .. .. .. ..- attr(*, "index2")= chr "Month"
  .. .. .. .. .. ..- attr(*, "interval")= interval [1:1] 1M
  .. .. .. .. .. .. ..@ .regular: logi TRUE
  .. .. .. .. ..$ spec  : tibble [1 × 5] (S3: tbl_df/tbl/data.frame)
  .. .. .. .. .. ..$ errortype : chr "M"
  .. .. .. .. .. ..$ trendtype : chr "A"
  .. .. .. .. .. ..$ seasontype: chr "N"
  .. .. .. .. .. ..$ damped    : logi TRUE
  .. .. .. .. .. ..$ period    : num 12
  .. .. .. .. .. ..- attr(*, "out.attrs")=List of 2
  .. .. .. .. .. .. ..$ dim     : Named int [1:3] 2 3 3
  .. .. .. .. .. .. .. ..- attr(*, "names")= chr [1:3] "errortype" "trendtype" "seasontype"
  .. .. .. .. .. .. ..$ dimnames:List of 3
  .. .. .. .. .. .. .. ..$ errortype : chr [1:2] "errortype=A" "errortype=M"
  .. .. .. .. .. .. .. ..$ trendtype : chr [1:3] "trendtype=N" "trendtype=A" "trendtype=Ad"
  .. .. .. .. .. .. .. ..$ seasontype: chr [1:3] "seasontype=N" "seasontype=A" "seasontype=M"
  .. .. .. .. ..- attr(*, "class")= chr "ETS"
  .. .. .. ..$ model         :Classes 'mdl_defn', 'R6' <mdl_defn>
  Public:
    add_data: function (.data) 
    check: function (.data) 
    clone: function (deep = FALSE) 
    data: NULL
    env: environment
    extra: list
    formula: name
    initialize: function (formula, ..., .env) 
    model: ETS
    origin: 1980 Jan
    prepare: function (...) 
    print: function (...) 
    recall_lag: function (x, n = 1L, ...) 
    recent_data: NULL
    remove_data: function () 
    specials: environment
    stage: NULL
    train: function (.data, specials, opt_crit, nmse, bounds, ic, restrict = TRUE,  
  .. .. .. ..$ data          : tbl_ts [432 × 2] (S3: tbl_ts/tbl_df/tbl/data.frame)
  .. .. .. .. ..$ Month        : mth [1:432] 1980 Jan, 1980 Feb, 1980 Mar, 1980 Apr, 198...
  .. .. .. .. ..$ season_adjust: num [1:432] 4.36 4.37 4.38 4.39 4.4 ...
  .. .. .. .. ..- attr(*, "key")= tibble [1 × 1] (S3: tbl_df/tbl/data.frame)
  .. .. .. .. .. ..$ .rows: list<int> [1:1] 
  .. .. .. .. .. .. ..$ : int [1:432] 1 2 3 4 5 6 7 8 9 10 ...
  .. .. .. .. .. .. ..@ ptype: int(0) 
  .. .. .. .. ..- attr(*, "index")= chr "Month"
  .. .. .. .. .. ..- attr(*, "ordered")= logi TRUE
  .. .. .. .. ..- attr(*, "index2")= chr "Month"
  .. .. .. .. ..- attr(*, "interval")= interval [1:1] 1M
  .. .. .. .. .. ..@ .regular: logi TRUE
  .. .. .. ..$ response      :List of 1
  .. .. .. .. ..$ : symbol season_adjust
  .. .. .. ..$ transformation:List of 1
  .. .. .. .. ..$ :function (season_adjust)  
  .. .. .. .. .. ..- attr(*, "class")= chr "transformation"
  .. .. .. .. .. ..- attr(*, "inverse")=function (season_adjust)  
  .. .. .. ..- attr(*, "class")= chr "mdl_ts"
  .. .. ..$ e2:List of 5
  .. .. .. ..$ fit           :List of 8
  .. .. .. .. ..$ b      : num(0) 
  .. .. .. .. ..$ b.se   : num(0) 
  .. .. .. .. ..$ lag    : num 12
  .. .. .. .. ..$ sigma2 : num 0
  .. .. .. .. ..$ .fitted: num [1:432] NA NA NA NA NA NA NA NA NA NA ...
  .. .. .. .. ..$ .resid : num [1:432] NA NA NA NA NA NA NA NA NA NA ...
  .. .. .. .. ..$ time   :List of 2
  .. .. .. .. .. ..$ start   : mth [1:1] 1980 Jan
  .. .. .. .. .. ..$ interval: interval [1:1] 1M
  .. .. .. .. .. .. ..@ .regular: logi TRUE
  .. .. .. .. ..$ future : num [1:12] -0.00104 -0.00107 -0.00154 -0.0013 -0.0011 ...
  .. .. .. .. ..- attr(*, "class")= chr "RW"
  .. .. .. ..$ model         :Classes 'mdl_defn', 'R6' <mdl_defn>
  Public:
    add_data: function (.data) 
    check: function (.data) 
    clone: function (deep = FALSE) 
    data: NULL
    env: environment
    extra: list
    formula: formula
    initialize: function (formula, ..., .env) 
    model: RW
    origin: 1980 Jan
    prepare: function (...) 
    print: function (...) 
    recall_lag: function (x, n = 1L, ...) 
    recent_data: NULL
    remove_data: function () 
    specials: environment
    stage: NULL
    train: function (.data, specials, ...)  
  .. .. .. ..$ data          : tbl_ts [432 × 2] (S3: tbl_ts/tbl_df/tbl/data.frame)
  .. .. .. .. ..$ Month      : mth [1:432] 1980 Jan, 1980 Feb, 1980 Mar, 1980 Apr, 198...
  .. .. .. .. ..$ season_year: num [1:432] -0.00104 -0.00107 -0.00154 -0.0013 -0.0011 ...
  .. .. .. .. ..- attr(*, "key")= tibble [1 × 1] (S3: tbl_df/tbl/data.frame)
  .. .. .. .. .. ..$ .rows: list<int> [1:1] 
  .. .. .. .. .. .. ..$ : int [1:432] 1 2 3 4 5 6 7 8 9 10 ...
  .. .. .. .. .. .. ..@ ptype: int(0) 
  .. .. .. .. ..- attr(*, "index")= chr "Month"
  .. .. .. .. .. ..- attr(*, "ordered")= logi TRUE
  .. .. .. .. ..- attr(*, "index2")= chr "Month"
  .. .. .. .. ..- attr(*, "interval")= interval [1:1] 1M
  .. .. .. .. .. ..@ .regular: logi TRUE
  .. .. .. ..$ response      :List of 1
  .. .. .. .. ..$ : symbol season_year
  .. .. .. ..$ transformation:List of 1
  .. .. .. .. ..$ :function (season_year)  
  .. .. .. .. .. ..- attr(*, "class")= chr "transformation"
  .. .. .. .. .. ..- attr(*, "inverse")=function (season_year)  
  .. .. .. ..- attr(*, "class")= chr "mdl_ts"
  .. .. ..- attr(*, "combination")= language e1 + e2
  .. .. ..- attr(*, "class")= chr [1:2] "decomposition_model" "model_combination"
  .. .. ..- attr(*, "dcmp_method")= chr "STL"
  .. ..$ model         :Classes 'mdl_defn', 'R6' <mdl_defn>
  Public:
    add_data: function (.data) 
    check: function (.data) 
    clone: function (deep = FALSE) 
    data: NULL
    env: environment
    extra: list
    formula: formula
    initialize: function (formula, ..., .env) 
    model: dcmp_mdl
    origin: 1980 Jan
    prepare: function (...) 
    print: function (...) 
    recall_lag: function (x, n = 1L, ...) 
    recent_data: NULL
    remove_data: function () 
    specials: environment
    stage: NULL
    train: function (.data, specials, ..., dcmp)  
  .. ..$ data          : tbl_ts [432 × 2] (S3: tbl_ts/tbl_df/tbl/data.frame)
  .. .. ..$ Month     : mth [1:432] 1980 Jan, 1980 Feb, 1980 Mar, 1980 Apr, 1980 May,...
  .. .. ..$ log(value): num [1:432] 4.36 4.37 4.38 4.39 4.4 ...
  .. .. ..- attr(*, "key")= tibble [1 × 1] (S3: tbl_df/tbl/data.frame)
  .. .. .. ..$ .rows:List of 1
  .. .. .. .. ..$ : int [1:432] 1 2 3 4 5 6 7 8 9 10 ...
  .. .. ..- attr(*, "index")= chr "Month"
  .. .. .. ..- attr(*, "ordered")= logi TRUE
  .. .. ..- attr(*, "index2")= chr "Month"
  .. .. ..- attr(*, "interval")= interval [1:1] 1M
  .. .. .. ..@ .regular: logi TRUE
  .. ..$ response      :List of 1
  .. .. ..$ : symbol value
  .. ..$ transformation:List of 1
  .. .. ..$ :function (value)  
  .. .. .. ..- attr(*, "class")= chr "transformation"
  .. .. .. ..- attr(*, "inverse")=function (value)  
  .. ..- attr(*, "class")= chr "mdl_ts"
 - attr(*, "key")= tibble [1 × 1] (S3: tbl_df/tbl/data.frame)
  ..$ .rows: list<int> [1:1] 
  .. ..$ : int 1
  .. ..@ ptype: int(0) 
 - attr(*, "model")= chr [1:2] "additive" "multiplicative"
 - attr(*, "response")= chr "value"

?components()
?components.mdl_df
# ----- Plots -----
p1 <- train |>
  model(STL(value ~ season(window="periodic"))) |>
  fabletools::components() |> autoplot() + ggtitle("Additive STL decomposition")

p2 <- train |>
  model(STL(log(value) ~ season(window="periodic"))) |>
  components() |> autoplot() + ggtitle("Multiplicative STL decomposition (log)")
 
p1/p2

fable

The fable package is the core forecasting engine in the fpp3 framework. It provides a tidy, model-based grammar for time series forecasting — similar in spirit to how ggplot2 provides a grammar of graphics. It is built to work seamlessly with tsibble, dplyr, and other tidyverse tools.

“Fable” stands for Forecasting Tables, and it allows users to fit, evaluate, and forecast time series models in a consistent and scalable way.

Key Features of fable

Feature	Description
Model grammar	Define models using model() and a pipeable grammar (e.g., ARIMA(), ETS())
Tidy forecasts	Forecasts are stored in tidy tibble format and easily visualized
Multiple models	Fit many models at once, either across groups or with multiple specifications
Integration	Works seamlessly with ggplot2, dplyr, tsibble, and other tidy tools
Support for ensembles and decompositions	Use hybrid workflows like STL + ETS models with decomposition_model()

Common fable Functions

Function	Purpose
model()	Fit one or more models to a tsibble object
forecast()	Generate forecasts for future time periods
report()	Print model summaries and parameter estimates
glance()	Return one-row summaries of model metrics (e.g., AIC)
augment()	Add fitted values and residuals to historical data
accuracy()	Compare model performance based on accuracy metrics

fabletools

The fabletools package provides the modeling infrastructure used by fable and other forecasting packages in the fpp3 ecosystem. It defines the internal structure for model fitting, forecasting, and diagnostics.

You don’t typically use fabletools directly unless you are creating custom models or building extensions, but it is automatically loaded when you use fable.

Key Features of fabletools

Feature	Description
Model definition grammar	Enables packages to define and register new model types
Decomposition support	Powers tools like decomposition_model() for combining STL + ETS/ARIMA
Tidy infrastructure	Provides glance(), augment(), report() for consistent model diagnostics
Modular architecture	Supports plug-in models like fable.prophet, fable.ets, etc.

---

Workflow

The core modeling pipeline: declare the tsibble → fit models → generate forecasts → visualize.

# Fit five benchmark forecasting models 

models <- train %>% model( NAIVE  = NAIVE(formula = value), 
                           MEAN   = MEAN(formula = value), 
                           SNAIVE = SNAIVE(formula = value), 
                           AVG    = MEAN(formula = value), # simple average = mean 
                           WAVG   = TSLM(formula = value ~ trend()) # using trend to simulate a weighted linear average 
                           ) 
?forecast
fc <- models %>%
  forecast(h = nrow(test)
           ) # h = 12 if you want to forecast the next 12 months 

# Plot all forecasts 
fc %>% autoplot(train) + 
  labs( title = "Five Benchmark Forecasts: Naive, Mean, SNaive, Average, Weighted",
        y = "Value",
        x = "Month" 
        ) + facet_wrap(~ .model,
                       ncol = 2
                       ) 

report(models)

Warning in report.mdl_df(models): Model reporting is only supported for
individual models, so a glance will be shown. To see the report for a specific
model, use `select()` and `filter()` to identify a single model.

# A tibble: 5 × 15
  .model   sigma2 r_squared adj_r_squared statistic p_value    df log_lik   AIC
  <chr>     <dbl>     <dbl>         <dbl>     <dbl>   <dbl> <int>   <dbl> <dbl>
1 NAIVE     0.228    NA            NA           NA       NA    NA     NA    NA 
2 MEAN   2151.       NA            NA           NA       NA    NA     NA    NA 
3 SNAIVE    4.59     NA            NA           NA       NA    NA     NA    NA 
4 AVG    2151.       NA            NA           NA       NA    NA     NA    NA 
5 WAVG      5.09      0.998         0.998   181694.       0     2   -963.  707.
# ℹ 6 more variables: AICc <dbl>, BIC <dbl>, CV <dbl>, deviance <dbl>,
#   df.residual <int>, rank <int>

Why report(models) Shows Mostly NA

When using the fabletools::report() function in the fpp3 framework, it’s important to understand that not all models return detailed statistical summaries.

Why You’re Seeing NA in report(models)

The output of report(models) shows many NA values for certain models because:

• NAIVE(), MEAN(), SNAIVE(), and your custom AVG (which is just a mean model) are non-parametric or rule-based models.
• These models do not estimate coefficients and therefore do not have:
  • R-squared
  • Adjusted R-squared
  • p-values
  • t-statistics

Since there is no regression formula involved, these statistics simply do not apply, hence the NA values in the summary output.

Why WAVG (Weighted Average) Works

We defined WAVG as:

WAVG = TSLM(formula = value ~ trend())

This is a regression model (TSLM), where:

• trend() is the predictor

• value is the response

Because it’s a linear model, it produces:

• Coefficients

• R-squared and adjusted R-squared

• t-statistics

• p-values

That’s why we get a full report for this model and not for the others.

If you want detailed statistical summaries (e.g., for interpretation), use models like:

• TSLM() (Time Series Linear Models)

• ETS() (Exponential Smoothing)

• These are parametric models that support full diagnostics.

preds <- forecast(mods, new_data = test) |> mutate(.mean = ifelse(.model == "multiplicative", exp(.mean), .mean))

add_preds <- preds |> filter(.model == "additive")
mult_preds <- preds |> filter(.model == "multiplicative")

p_add <- autoplot(myts, value) +
  autolayer(add_preds, colour = "blue") +
  ggtitle("Additive decomposition forecast")

p_mult <- autoplot(myts, value) +
  autolayer(mult_preds, colour = "red") +
  ggtitle("Multiplicative decomposition forecast")


(p_add/p_mult)

Accuracy Metrics

Important

Bias is about direction; variance is about spread.

---

Accuracy Metrics: Definitions and Interpretations

Metric	Formula	Interpretation	Detects Bias?	Penalizes Outliers?
ME (Mean Error)	\[ \frac{1}{n} \sum (y_t - \hat{y}_t) \]	Average signed forecast error. Indicates bias. Positive → underprediction; Negative → overprediction.	Yes	No
MPE (Mean Percentage Error)	\[ \frac{1}{n} \sum \left(\frac{y_t - \hat{y}_t}{y_t}\right)\times 100\% \]	Average signed percentage error. Indicates relative bias, but unstable when (y_t) is near zero.	Yes	No
RMSE (Root Mean Squared Error)	\[ \sqrt{\frac{1}{n} \sum (y_t - \hat{y}_t)^2} \]	Penalizes large errors heavily. Sensitive to outliers; reflects bias² + variance.	Indirect	Yes
MAE (Mean Absolute Error)	\[ \frac{1}{n} \sum \lvert y_t - \hat{y}_t \rvert \]	Average absolute forecast error. Measures typical error magnitude; ignores direction.	No	Mild
MAPE (Mean Absolute Percentage Error)	\[ \frac{1}{n} \sum \left\lvert \frac{y_t - \hat{y}_t}{y_t} \right\rvert \times 100\% \]	Average absolute percentage error. Scale-independent, but undefined if any (y_t = 0).	No	Mild
MASE (Mean Absolute Scaled Error)	\[ \frac{\text{MAE}}{\text{MAE of naïve model}} \]	MAE scaled by naïve benchmark. < 1 = better than naïve; > 1 = worse.	No	Mild
RMSSE (Root Mean Squared Scaled Error)	\[ \frac{\text{RMSE}}{\text{RMSE of naïve model}} \]	RMSE scaled by naïve benchmark. Penalizes large errors more than MASE (errors grow quadratically in RMSE)	Indirect	Yes

#str(fc)
#str(test)

?accuracy
# ----- Accuracy -----
acc <- accuracy(object = fc,  # predicted y
                data = test   # y
                ) |>
  select(.model, ME, MPE, RMSE, MAE, MAPE #, MASE, RMSSE
         )


# Print accuracy table separately
acc

# A tibble: 5 × 6
  .model     ME   MPE  RMSE   MAE  MAPE
  <chr>   <dbl> <dbl> <dbl> <dbl> <dbl>
1 AVG    107.   39.2  111.  107.  39.2 
2 MEAN   107.   39.2  111.  107.  39.2 
3 NAIVE   32.5  11.3   41.4  32.6 11.3 
4 SNAIVE  33.3  11.6   42.0  33.3 11.6 
5 WAVG     7.32  2.25  16.5  11.8  4.05

?kable
# Print with knitr::kable
kable(acc, caption = "Forecast Accuracy Metrics") |>
  kable_styling(bootstrap_options = c("striped", "hover", "condensed"), full_width = FALSE)

Forecast Accuracy Metrics

.model	ME	MPE	RMSE	MAE	MAPE
AVG	107.49958	39.247323	110.51560	107.49958	39.247323
MEAN	107.49958	39.247323	110.51560	107.49958	39.247323
NAIVE	32.54229	11.275871	41.43114	32.55218	11.280036
SNAIVE	33.30154	11.562355	41.98773	33.30154	11.562355
WAVG	7.32000	2.246837	16.51143	11.80397	4.047149

Replicating the values

Extract Forecast Values from SNAIVE

# Forecast using the snaive model only
fc_snaive <- models %>%
  select(SNAIVE) %>%
  forecast(h = nrow(test))

Join Forecasts to Actuals

# Step 1: Fit SNAIVE model
snaive_model <- train %>%
  model(SNAIVE = SNAIVE(value))

# Step 2: Forecast same length as test
fc_snaive <- snaive_model %>%
  forecast(h = nrow(test))

# Step 3: Join forecasts with test data
# test$value is the actual column — make sure it exists
compare <- fc_snaive %>%
  left_join(test %>% rename(actual = value), by = "Month") %>%
  rename(forecast = .mean) %>%
  select(Month, actual, forecast)

# Step 4: Compute metrics
actual <- compare$actual
forecast <- compare$forecast

ME    <- mean(actual - forecast)                        # Mean Error (bias)
MPE   <- mean((actual - forecast) / actual) * 100       # Mean Percentage Error
RMSE  <- sqrt(mean((actual - forecast)^2))              # Root Mean Squared Error
MAE   <- mean(abs(actual - forecast))                   # Mean Absolute Error
MAPE  <- mean(abs((actual - forecast) / actual)) * 100  # Mean Absolute Percentage Error
#MASE  <- MAE / mean(abs(diff(actual)))                  # Mean Absolute Scaled Error (vs. naive)
#RMSSE <- RMSE / sqrt(mean(diff(actual)^2))              # Root Mean Squared Scaled Error


# Step 5: Show results
tibble::tibble(
  Model = "SNAIVE",
  ME = ME,
  MPE = MPE,
  RMSE = RMSE,
  MAE = MAE,
  MAPE = MAPE
#  MASE = MASE,
#  RMSSE = RMSSE
)

# A tibble: 1 × 6
  Model     ME   MPE  RMSE   MAE  MAPE
  <chr>  <dbl> <dbl> <dbl> <dbl> <dbl>
1 SNAIVE  33.3  11.6  42.0  33.3  11.6

Export

?model
# Step 1: Fit multiple models on training data
models <- train %>% model( NAIVE  = NAIVE(formula = value), 
                           MEAN   = MEAN(formula = value), 
                           SNAIVE = SNAIVE(formula = value), 
                           AVG    = MEAN(formula = value), # simple average = mean 
                           WAVG   = TSLM(formula = value ~ trend()) # using trend to simulate a weighted linear average 
                           ) 
?forecast
# Step 2: Forecast from all models for test set horizon
fc_all <- models %>% fabletools::forecast(h = nrow(test))

# Step 3: Reshape forecasts into wide format
fc_wide <- fc_all %>%
  as_tibble() %>%  # Converts fable to a normal tibble
  select(Month, .model, .mean) %>%
  pivot_wider(names_from = .model, values_from = .mean)

# Step 4: Add actual test values for comparison
df_forecast_all <- test %>%
  rename(actual = value) %>%
  left_join(fc_wide, by = "Month")  %>%
  mutate(Month = as.Date(Month))

# Step 5: Preview the final dataframe
print(df_forecast_all)

# A tsibble: 108 x 7 [1D]
   Month      actual NAIVE  MEAN SNAIVE   AVG  WAVG
   <date>      <dbl> <dbl> <dbl>  <dbl> <dbl> <dbl>
 1 2016-01-01   238.  238.  163.   235.  163.  243.
 2 2016-02-01   237.  238.  163.   235.  163.  244.
 3 2016-03-01   238.  238.  163.   236.  163.  244.
 4 2016-04-01   239.  238.  163.   236.  163.  244.
 5 2016-05-01   240.  238.  163.   237.  163.  245.
 6 2016-06-01   240.  238.  163.   238.  163.  245.
 7 2016-07-01   240.  238.  163.   238.  163.  245.
 8 2016-08-01   241.  238.  163.   238.  163.  246.
 9 2016-09-01   241.  238.  163.   237.  163.  246.
10 2016-10-01   242.  238.  163.   238.  163.  246.
# ℹ 98 more rows

Appendix

Subsetting and Indexing Basics in R: Lists

In R, lists are flexible data structures that can hold elements of different types — such as numbers, characters, vectors, data frames, functions, or even other lists. Because of this, lists are extremely useful in modeling pipelines, complex data wrangling, and nested object storage.

Creating a List

You can create a list using the list() function. Here’s an example of a nested list:

my_list <- list( name = "Arvind", 
                 scores = c(90, 85, 88), 
                 passed = TRUE, 
                 details = list(age = 32,
                                city = "Boston"
                                )
                 )

This creates a named list with 4 elements.

Subsetting a List in R

There are three main ways to access elements from a list in R:

Operator	Returns	Description
$	Single element	Access by name (only top-level, no quotes needed)
[[ ]]	Single element	Access by name or index, returns the object itself
[ ]	Sublist	Returns a list (even if length 1)

Using $ — Direct Access by Name

my_list$scores

[1] 90 85 88

• $ is a shorthand for accessing top-level named elements.

• Cannot be used for dynamic indexing or nested structures.

Using [[ ]] — Element Extraction

my_list[["scores"]]

[1] 90 85 88

my_list[[2]]

[1] 90 85 88

• Extracts the value itself (not wrapped in a list).

• Can use a name or an index.

• Supports dynamic referencing:

  element_name <- "scores"
  my_list[[element_name]]

  [1] 90 85 88

Using [ ] — Sublist Extraction

my_list["scores"]

$scores
[1] 90 85 88

my_list[2]

$scores
[1] 90 85 88

typeof(my_list[2])

[1] "list"

• Returns a list of length 1.

• Useful when you want to keep the list structure intact.

str(my_list["scores"])

List of 1
 $ scores: num [1:3] 90 85 88

Accessing Nested Lists

You can chain access using $ or multiple [[ ]] calls:

my_list$details$city

[1] "Boston"

my_list[["details"]][["city"]]

[1] "Boston"

This allows you to drill down into hierarchical data structures.

Goal	Code	Output Type
Get vector of scores	my_list[["scores"]]	numeric vector
Get scores sublist	my_list["scores"]	list
Dynamic name access	my_list[[varname]]	element
Nested city value	my_list$details$city	character string

Footnotes

1. A tibble is a more user-friendly and consistent type of data frame used in modern R programming. It behaves like a data.frame, but with improvements that make it easier to use, especially for data analysis and visualization.

   Feature	data.frame	tibble
   Printing behavior	Prints all rows and columns	Prints only first 10 rows and as many columns as fit
   Row names	Uses row names by default	Does not use row names
   Partial matching	Allows partial matching of column names (df$val works)	Does not allow partial matching — avoids accidental bugs
   String handling	Converts strings to factors by default	Keeps character vectors as character (no surprise factors)
   Subsetting behavior	df[x] may return a vector or a data.frame	tibble[x] always returns a tibble
   Integration	Works well in base R	Fully integrated with tidyverse tools (dplyr, ggplot2)