In this chapter, you will apply your knowledge of **ARIMA modeling** to a real-world time series dataset. You will load a dataset, fit an **ARIMA model**, and evaluate its forecasting performance using metrics such as **mean absolute error (MAE)** and **mean squared error (MSE)**. The process involves:

- Preparing the data;
- Splitting it into training and testing sets;
- Fitting the ARIMA model;
- Generating forecasts;
- Computing the evaluation metrics.

This hands-on challenge will reinforce your understanding of how **ARIMA models** are used in practice and how to interpret their performance.

import unittest
import ast
import re   
import importlib
import pandas as pd
import numpy as np

class TestTask(unittest.TestCase):
    def setUp(self):
        # Відключаємо print, щоб вивід студента не засмічував логи тестів
        def fake_print(*args, **kwargs):
            pass
        self.orig_print = __builtins__["print"]
        __builtins__["print"] = fake_print
        
        # Ініціалізуємо тестові дані
        self.dates = pd.date_range(start="2020-01-01", periods=50, freq="D")
        self.data = pd.Series(np.arange(50, dtype=float), index=self.dates)
        self.order = (1, 1, 1)
        self.test_size = 5
        
        # Перезавантажуємо модуль перед кожним тестом
        self.module = importlib.import_module("user_code")
        importlib.reload(self.module)

    def tearDown(self):
        # Повертаємо print
        __builtins__["print"] = self.orig_print

    def test_1_function_exists(self):
        func = getattr(self.module, "arima_forecast_and_evaluate", None)
        _dynamic_test(
            self,
            callable(func),
            "Function arima_forecast_and_evaluate is defined.",
            "Function arima_forecast_and_evaluate is missing or not a function."
        )

    def test_2_returns_three_values(self):
        func = getattr(self.module, "arima_forecast_and_evaluate", None)
        if not func:
             _dynamic_test(self, False, "Function returns forecast, MAE, and MSE.", "Function is missing.")
             return
             
        try:
            result = func(self.data, self.order, self.test_size)
            is_valid_tuple = isinstance(result, tuple) and len(result) == 3
            _dynamic_test(
                self,
                is_valid_tuple,
                "Function returns exactly three values (forecast, MAE, MSE).",
                f"Expected 3 return values, got {len(result) if isinstance(result, tuple) else type(result)}."
            )
        except Exception as e:
            _dynamic_test(self, False, "Function returns exactly three values.", f"Function raised an error: {e}")

    def test_3_forecast_validity(self):
        func = getattr(self.module, "arima_forecast_and_evaluate", None)
        try:
            forecast, mae, mse = func(self.data, self.order, self.test_size)
            # Перевіряємо, чи forecast має атрибут shape (Series/Array) і правильну довжину
            is_valid_forecast = hasattr(forecast, "shape") and len(forecast) == self.test_size
            _dynamic_test(
                self,
                is_valid_forecast,
                "Forecast matches the expected test set length.",
                f"Expected forecast length {self.test_size}, got {len(forecast) if hasattr(forecast, '__len__') else 'invalid object'}."
            )
        except Exception as e:
            _dynamic_test(self, False, "Forecast matches the expected test set length.", f"Function raised an error: {e}")

    def test_4_metrics_validity(self):
        func = getattr(self.module, "arima_forecast_and_evaluate", None)
        try:
            forecast, mae, mse = func(self.data, self.order, self.test_size)
            # sklearn може повертати np.float64, тому isinstance(x, float) може не спрацювати. Використовуємо np.number.
            mae_valid = isinstance(mae, (float, int, np.number)) and mae >= 0
            mse_valid = isinstance(mse, (float, int, np.number)) and mse >= 0
            
            _dynamic_test(
                self,
                mae_valid and mse_valid,
                "MAE and MSE are calculated correctly as non-negative numbers.",
                f"Invalid metrics calculated. MAE: {mae}, MSE: {mse}."
            )
        except Exception as e:
            _dynamic_test(self, False, "MAE and MSE are calculated correctly.", f"Function raised an error: {e}")


def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    if not assign_nodes:
        return code

    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()

test_main.py

Dive into the core statistical methods for time series forecasting. This course guides you through moving averages, autoregressive models, and ARIMA, equipping you with the skills to implement, tune, and evaluate classical forecasting models using Python.

Explore the foundational and advanced classical models for time series forecasting, from moving averages to ARIMA, with hands-on Python implementation and evaluation.

Challenge: ARIMA Forecasting on Real Data

Oplossing