diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0217f5bd80..26df25012b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -22,6 +22,7 @@ but cannot always guarantee backwards compatibility. Changes that may **break co
   - Includes automatic downsampling for large series (configurable via `downsample_threshold` parameter) to avoid crashes when plotting large series
   - Integrates seamlessly with `plotting.use_darts_style` which now affects both `TimeSeries.plot()` and `TimeSeries.plotly()`
   - Plotly remains an optional dependency and can be installed with `pip install plotly`
+- Added support for full and partial fine-tuning of foundation models with integrated layer freezing and `PeftCallback` for LoRA integration. [#2964](https://github.com/unit8co/darts/issues/2964) by [Alain Gysi](https://github.com/Kurokabe)
 
 **Fixed**
 
diff --git a/darts/models/components/huggingface_connector.py b/darts/models/components/huggingface_connector.py
index 41fb1d1065..4006ec6085 100644
--- a/darts/models/components/huggingface_connector.py
+++ b/darts/models/components/huggingface_connector.py
@@ -13,12 +13,12 @@
 from safetensors.torch import load_file
 
 from darts.logging import get_logger, raise_log
-from darts.models.forecasting.pl_forecasting_module import (
-    PLForecastingModule,
-)
+from darts.models.forecasting.pl_forecasting_module import PLForecastingModule
 
 logger = get_logger(__name__)
 
+from darts.models.forecasting.foundation_model import FoundationPLModule
+
 
 class HuggingFaceConnector:
     def __init__(
@@ -109,10 +109,10 @@ def load_model_weights(
 
     def load_model(
         self,
-        module_class: type[PLForecastingModule],
+        module_class: type[FoundationPLModule],
         pl_module_params: dict,
         additional_params: Optional[dict] = None,
-    ) -> PLForecastingModule:
+    ) -> FoundationPLModule:
         """Load the model by creating an instance of the given module class and loading
         the weights. Some configuration files might contain external parameters that
         are not part of the module class constructor like `architectures`. They are filtered
@@ -140,7 +140,7 @@ def load_model(
             **pl_module_params,
             **additional_params,
         )
-        self.load_model_weights(module)
+        self.load_model_weights(module.model)
         return module
 
     def _get_file_path(
diff --git a/darts/models/forecasting/chronos2_model.py b/darts/models/forecasting/chronos2_model.py
index f6267c7484..04630f0ffe 100644
--- a/darts/models/forecasting/chronos2_model.py
+++ b/darts/models/forecasting/chronos2_model.py
@@ -23,14 +23,10 @@
     _Patch,
     _ResidualBlock,
 )
-from darts.models.components.huggingface_connector import (
-    HuggingFaceConnector,
-)
+from darts.models.components.huggingface_connector import HuggingFaceConnector
 from darts.models.forecasting.foundation_model import (
     FoundationModel,
-)
-from darts.models.forecasting.pl_forecasting_module import (
-    PLForecastingModule,
+    FoundationPLModule,
 )
 from darts.utils.data.torch_datasets.utils import PLModuleInput, TorchTrainingSample
 from darts.utils.likelihood_models.torch import QuantileRegression
@@ -51,7 +47,7 @@ class _Chronos2ForecastingConfig:
     time_encoding_scale: int | None = None
 
 
-class _Chronos2Module(PLForecastingModule):
+class _Chronos2Module(nn.Module):
     def __init__(
         self,
         d_model: int = 512,
@@ -65,11 +61,10 @@ def __init__(
         rope_theta: float = 10000.0,
         attn_implementation: Literal["eager", "sdpa"] | None = None,
         chronos_config: Optional[dict[str, Any]] = None,
+        quantiles: list[float] = None,
         **kwargs,
     ):
-        """PyTorch module implementing the Chronos-2 model, ported from
-        `amazon-science/chronos-forecasting <https://github.com/amazon-science/chronos-forecasting>`_ and
-        adapted for Darts :class:`PLForecastingModule` interface.
+        """Core Chronos-2 model containing all the modules and forward logic.
 
         Parameters
         ----------
@@ -95,12 +90,12 @@ def __init__(
             Attention implementation to use. If None, defaults to "sdpa".
         chronos_config
             Configuration parameters for Chronos-2 model. See :class:`_Chronos2ForecastingConfig` for details.
+        quantiles
+            List of quantiles for probabilistic forecasting.
         **kwargs
-            all parameters required for :class:`darts.models.forecasting.pl_forecasting_module.PLForecastingModule`
-            base class.
+            Additional keyword arguments.
         """
-
-        super().__init__(**kwargs)
+        super().__init__()
         self.d_model = d_model
         self.d_kv = d_kv
         self.d_ff = d_ff
@@ -187,19 +182,11 @@ def __init__(
             num_layers=self.num_layers,
         )
 
-        quantiles = self.chronos_config.quantiles
+        quantiles = quantiles or self.chronos_config.quantiles
         self.num_quantiles = len(quantiles)
         quantiles_tensor = torch.tensor(quantiles)
         self.register_buffer("quantiles", quantiles_tensor, persistent=False)
 
-        # gather indices of user-specified quantiles
-        user_quantiles: list[float] = (
-            self.likelihood.quantiles
-            if isinstance(self.likelihood, QuantileRegression)
-            else [0.5]
-        )
-        self.user_quantile_indices = [quantiles.index(q) for q in user_quantiles]
-
         self.output_patch_embedding = _ResidualBlock(
             in_dim=self.d_model,
             h_dim=self.d_ff,
@@ -208,6 +195,14 @@ def __init__(
             dropout_p=self.dropout_rate,
         )
 
+    @property
+    def device(self) -> torch.device:
+        return next(self.parameters()).device
+
+    @property
+    def dtype(self) -> torch.dtype:
+        return next(self.parameters()).dtype
+
     def _prepare_patched_context(
         self,
         context: torch.Tensor,
@@ -334,14 +329,14 @@ def _prepare_patched_future(
 
         return patched_future, patched_future_covariates_mask
 
-    def _forward(
+    def forward(
         self,
         context: torch.Tensor,
         group_ids: torch.Tensor,
         future_covariates: torch.Tensor,
         num_output_patches: int = 1,
     ) -> torch.Tensor:
-        """Original forward pass of the Chronos-2 model.
+        """Forward pass of the Chronos-2 model.
 
         Parameters
         ----------
@@ -454,6 +449,86 @@ def _forward(
 
         return quantile_preds
 
+
+class _Chronos2PLModule(FoundationPLModule):
+    def __init__(
+        self,
+        d_model: int = 512,
+        d_kv: int = 64,
+        d_ff: int = 2048,
+        num_layers: int = 6,
+        num_heads: int = 8,
+        dropout_rate: float = 0.1,
+        layer_norm_epsilon: float = 1e-6,
+        feed_forward_proj: str = "relu",
+        rope_theta: float = 10000.0,
+        attn_implementation: Literal["eager", "sdpa"] | None = None,
+        chronos_config: Optional[dict[str, Any]] = None,
+        **kwargs,
+    ):
+        """PyTorch Lightning module wrapper for the Chronos-2 model, adapted for
+        Darts :class:`PLForecastingModule` interface.
+
+        Parameters
+        ----------
+        d_model
+            Dimension of the model embeddings, also called "model size" in Transformer.
+        d_kv
+            Dimension of the key and value projections in multi-head attention.
+        d_ff
+            Dimension of the feed-forward network hidden layer.
+        num_layers
+            Number of Chronos-2 encoder layers.
+        num_heads
+            Number of attention heads in each encoder block.
+        dropout_rate
+            Dropout rate of the model.
+        layer_norm_epsilon
+            Epsilon value for layer normalization layers.
+        feed_forward_proj
+            Activation of feed-forward network.
+        rope_theta
+            Base period for Rotary Position Embeddings (RoPE).
+        attn_implementation
+            Attention implementation to use. If None, defaults to "sdpa".
+        chronos_config
+            Configuration parameters for Chronos-2 model. See :class:`_Chronos2ForecastingConfig` for details.
+        **kwargs
+            all parameters required for :class:`darts.models.forecasting.pl_forecasting_module.PLForecastingModule`
+            base class.
+        """
+
+        super().__init__(**kwargs)
+
+        # Get quantiles for model initialization
+        chronos_config = chronos_config or {}
+        chronos_config_obj = _Chronos2ForecastingConfig(**chronos_config)
+        quantiles = chronos_config_obj.quantiles
+
+        # gather indices of user-specified quantiles
+        user_quantiles: list[float] = (
+            self.likelihood.quantiles
+            if isinstance(self.likelihood, QuantileRegression)
+            else [0.5]
+        )
+        self.user_quantile_indices = [quantiles.index(q) for q in user_quantiles]
+
+        # Create the core Chronos-2 model
+        self.model = _Chronos2Module(
+            d_model=d_model,
+            d_kv=d_kv,
+            d_ff=d_ff,
+            num_layers=num_layers,
+            num_heads=num_heads,
+            dropout_rate=dropout_rate,
+            layer_norm_epsilon=layer_norm_epsilon,
+            feed_forward_proj=feed_forward_proj,
+            rope_theta=rope_theta,
+            attn_implementation=attn_implementation,
+            chronos_config=chronos_config,
+            quantiles=quantiles,
+        )
+
     # TODO: fine-tuning support w/ normalized loss
     # Currently, Darts own `RINorm` is not used as Chronos-2 has its own implementation. Major differences
     # 1. Chronos-2 `RINorm` normalizes both target and covariates, while Darts normalizes target only.
@@ -508,16 +583,16 @@ def forward(self, x_in: PLModuleInput, *args, **kwargs) -> Any:
 
         # determine minimum number of patches to cover future_length
         num_output_patches = math.ceil(
-            future_length / self.chronos_config.output_patch_size
+            future_length / self.model.chronos_config.output_patch_size
         )
 
-        # call original Chronos-2 forward pass
+        # call the core model's forward pass
         # Unlike the original, we remove `context_mask`, `future_covariates_mask`, `future_target`,
         # `future_target_mask`, and `output_attentions` parameters. They are not needed for Darts'
         # implementation.
         # We also remove `einops` rearrange operation at the end so the raw output tensor is returned,
         # in shape of `(batch, vars * patches * quantiles * patch_size)`
-        quantile_preds = self._forward(
+        quantile_preds = self.model.forward(
             context=context,
             group_ids=group_ids,
             future_covariates=future_covariates,
@@ -532,15 +607,15 @@ def forward(self, x_in: PLModuleInput, *args, **kwargs) -> Any:
             batch_size,
             n_variables,
             num_output_patches,
-            self.num_quantiles,
-            self.chronos_config.output_patch_size,
+            self.model.num_quantiles,
+            self.model.chronos_config.output_patch_size,
         )
         # permute and reshape to (batch, time, vars, quantiles)
         quantile_preds = quantile_preds.permute(0, 2, 4, 1, 3).reshape(
             batch_size,
-            num_output_patches * self.chronos_config.output_patch_size,
+            num_output_patches * self.model.chronos_config.output_patch_size,
             n_variables,
-            self.num_quantiles,
+            self.model.num_quantiles,
         )
 
         # truncate to output_chunk_length
@@ -558,7 +633,7 @@ def forward(self, x_in: PLModuleInput, *args, **kwargs) -> Any:
 class Chronos2Model(FoundationModel):
     # Fine-tuning is turned off for now pending proper fine-tuning support
     # and configuration.
-    _allows_finetuning = False
+    _allows_finetuning = True
 
     def __init__(
         self,
@@ -881,11 +956,13 @@ def encode_year(idx):
                 )
 
         self.hf_connector = hf_connector
-        super().__init__(enable_finetuning=False, **kwargs)
+        super().__init__(**kwargs)
 
-    def _create_model(self, train_sample: TorchTrainingSample) -> PLForecastingModule:
+    def _create_model(self, train_sample: TorchTrainingSample) -> FoundationPLModule:
         pl_module_params = self.pl_module_params or {}
-        return self.hf_connector.load_model(
-            module_class=_Chronos2Module,
+        model = self.hf_connector.load_model(
+            module_class=_Chronos2PLModule,
             pl_module_params=pl_module_params,
         )
+
+        return model
diff --git a/darts/models/forecasting/foundation_model.py b/darts/models/forecasting/foundation_model.py
index 4c92b7e992..3a24e65435 100644
--- a/darts/models/forecasting/foundation_model.py
+++ b/darts/models/forecasting/foundation_model.py
@@ -10,11 +10,14 @@
 """
 
 from abc import ABC
+from typing import Any
+
+from torch import nn
 
 from darts.logging import get_logger, raise_log
-from darts.models.forecasting.torch_forecasting_model import (
-    MixedCovariatesTorchModel,
-)
+from darts.models.forecasting.pl_forecasting_module import PLForecastingModule
+from darts.models.forecasting.torch_forecasting_model import MixedCovariatesTorchModel
+from darts.utils.callbacks.fine_tuning import LayerFreezeCallback
 
 logger = get_logger(__name__)
 
@@ -25,6 +28,8 @@ class FoundationModel(MixedCovariatesTorchModel, ABC):
     def __init__(
         self,
         enable_finetuning: bool = False,
+        freeze_patterns: list[str] | None = None,
+        unfreeze_patterns: list[str] | None = None,
         **kwargs,
     ):
         """Foundation Forecasting Model with PyTorch Lightning backend.
@@ -52,6 +57,13 @@ def __init__(
         enable_finetuning
             Whether to enable fine-tuning of the foundation model. If set to ``True``, calling :func:`fit()` will
             update the model weights. Default: ``False``.
+        freeze_patterns
+            A list of strings. Parameters whose names start with any of these patterns will be frozen
+            (``requires_grad=False``). This is only used if ``enable_finetuning=True``. Default: ``None``.
+        unfreeze_patterns
+            A list of strings. Parameters whose names start with any of these patterns will be unfrozen
+            (``requires_grad=True``). This is applied after ``freeze_patterns``. This is only used if
+            ``enable_finetuning=True``. Default: ``None``.
         batch_size
             Number of time series (input and output sequences) used in each fine-tuning pass. Default: ``32``.
         n_epochs
@@ -158,13 +170,7 @@ def encode_year(idx):
             whether to show warnings raised from PyTorch Lightning. Useful to detect potential issues of
             your forecasting use case. Default: ``False``.
         """
-        # initialize `TorchForecastingModel` base class
-        super().__init__(**self._extract_torch_model_params(**self.model_params))
-
-        # extract pytorch lightning module kwargs
-        self.pl_module_params = self._extract_pl_module_params(**self.model_params)
-
-        # validate and set fine-tuning flag
+        # validate fine-tuning flag
         if enable_finetuning and not self._allows_finetuning:
             raise_log(
                 ValueError(
@@ -174,8 +180,83 @@ def encode_year(idx):
                 logger,
             )
 
+        if not enable_finetuning and (freeze_patterns or unfreeze_patterns):
+            logger.warning(
+                "`freeze_patterns` or `unfreeze_patterns` are specified, but `enable_finetuning` is False. "
+                "These patterns will be ignored."
+            )
+
+        if enable_finetuning and (freeze_patterns or unfreeze_patterns):
+            pl_trainer_kwargs = self.model_params.get("pl_trainer_kwargs")
+            if pl_trainer_kwargs is None:
+                pl_trainer_kwargs = {}
+            else:
+                pl_trainer_kwargs = dict(pl_trainer_kwargs)
+
+            callbacks = pl_trainer_kwargs.get("callbacks")
+            if callbacks is None:
+                callbacks = []
+            else:
+                callbacks = list(callbacks)
+
+            callbacks.append(
+                LayerFreezeCallback(
+                    freeze_patterns=freeze_patterns or [],
+                    unfreeze_patterns=unfreeze_patterns or [],
+                )
+            )
+            pl_trainer_kwargs["callbacks"] = callbacks
+            # we must update model_params to be picked up by super().__init__()
+            self.model_params["pl_trainer_kwargs"] = pl_trainer_kwargs
+
+        # initialize `TorchForecastingModel` base class
+        super().__init__(**self._extract_torch_model_params(**self.model_params))
+
+        # extract pytorch lightning module kwargs
+        self.pl_module_params = self._extract_pl_module_params(**self.model_params)
+
         self._enable_finetuning = enable_finetuning
 
     @property
     def _requires_training(self) -> bool:
         return self._enable_finetuning
+
+    @property
+    def internal_model(self) -> Any:
+        """
+        Returns the underlying PyTorch model (nn.Module).
+        This gives access to the actual internal mechanics of the model, which can be useful
+        for advanced usage like accessing PEFT adapters, inspecting weights or custom saving/loading.
+
+        If the model has not been initialized yet, returns None.
+        """
+        if hasattr(self, "model") and hasattr(self.model, "model"):
+            return self.model.model
+        return None
+
+    @internal_model.setter
+    def internal_model(self, model: nn.Module):
+        """
+        Sets the underlying PyTorch model (nn.Module).
+        This allows replacing the internal model, which can be useful for advanced usage like loading PEFT adapters.
+
+        Parameters
+        ----------
+        model
+            The new PyTorch nn.Module to set as the internal model.
+        """
+        if hasattr(self, "model"):
+            self.model.model = model
+        else:
+            raise_log(
+                AttributeError(
+                    "The internal model cannot be set because the outer model is not initialized yet."
+                ),
+                logger,
+            )
+
+
+class FoundationPLModule(PLForecastingModule):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.model: nn.Module
diff --git a/darts/tests/models/forecasting/test_foundation.py b/darts/tests/models/forecasting/test_foundation.py
index 0e2d55625d..c3f4a43c22 100644
--- a/darts/tests/models/forecasting/test_foundation.py
+++ b/darts/tests/models/forecasting/test_foundation.py
@@ -1,10 +1,12 @@
 import logging
+import os
 import shutil
 from pathlib import Path
 from unittest.mock import patch
 
 import numpy as np
 import pytest
+import torch
 
 from darts import TimeSeries, concatenate
 from darts.tests.conftest import TORCH_AVAILABLE, tfm_kwargs
@@ -17,6 +19,7 @@
     )
 
 from darts.models import Chronos2Model
+from darts.utils.callbacks.fine_tuning import LayerFreezeCallback, PeftCallback
 
 
 def generate_series(n_variables: int, length: int, prefix: str):
@@ -180,3 +183,153 @@ def test_local_dir(self, mock_method, caplog):
             )
         config_path.rmdir()
         test_local_dir.rmdir()
+
+    @patch(
+        "darts.models.components.huggingface_connector.hf_hub_download",
+        side_effect=mock_download,
+    )
+    def test_full_finetuning(self, mock_method, tmpdir):
+        # 1. Training activation
+        model = Chronos2Model(
+            input_chunk_length=12,
+            output_chunk_length=6,
+            enable_finetuning=True,
+            n_epochs=5,
+            **tfm_kwargs,
+        )
+        assert model._requires_training is True
+
+        # Capture initial weights
+        model.fit(self.series)
+        initial_params = {
+            n: p.clone() for n, p in model.internal_model.named_parameters()
+        }
+
+        # 2. Weight update
+        # We need to actually train for 1 epoch. tfm_kwargs usually has "accelerator": "cpu"
+        model.fit(self.series, epochs=1)
+
+        # Check if at least some weights changed
+        any_changed = False
+        for n, p in model.internal_model.named_parameters():
+            if not torch.equal(initial_params[n], p):
+                any_changed = True
+                break
+        assert any_changed, "The weights should be updated after fine-tuning"
+
+        # 3. Persistence (Save/Load)
+        save_path = os.path.join(tmpdir, "model.pt")
+        model.save(save_path)
+        loaded_model = Chronos2Model.load(save_path)
+
+        pred_orig = model.predict(n=6, series=self.series)
+        pred_loaded = loaded_model.predict(n=6, series=self.series)
+        assert np.allclose(pred_orig.values(), pred_loaded.values()), (
+            "Prediction of the fine-tuned model and the saved/loaded fine-tuned model should be the same"
+        )
+
+    @patch(
+        "darts.models.components.huggingface_connector.hf_hub_download",
+        side_effect=mock_download,
+    )
+    def test_partial_finetuning(self, mock_method):
+        # 1. Callback injection
+        model = Chronos2Model(
+            input_chunk_length=12,
+            output_chunk_length=6,
+            enable_finetuning=True,
+            freeze_patterns=["encoder.block.0"],
+            unfreeze_patterns=["encoder.block.0.layer.0"],  # Example unfreeze
+            **tfm_kwargs,
+        )
+        assert any(
+            isinstance(c, LayerFreezeCallback)
+            for c in model.trainer_params["callbacks"]
+        )
+
+        # 2. Freezing logic
+        # We call fit to initialize the model and trigger the callback setup automatically
+        model.fit(self.series, epochs=5)
+
+        # Check requires_grad status.
+        found_any = False
+        for name, param in model.internal_model.named_parameters():
+            if name.startswith("encoder.block.0"):
+                found_any = True
+                if name.startswith("encoder.block.0.layer.0"):
+                    assert param.requires_grad is True, (
+                        f"Parameter {name} should be trainable"
+                    )
+                else:
+                    assert param.requires_grad is False, (
+                        f"Parameter {name} should be frozen"
+                    )
+        assert found_any, "No parameters matched the freeze patterns, test is invalid"
+
+    @patch(
+        "darts.models.components.huggingface_connector.hf_hub_download",
+        side_effect=mock_download,
+    )
+    def test_finetuning_misconfiguration(self, mock_method):
+        # Warning if freeze_patterns assigned but enable_finetuning is False
+        with patch(
+            "darts.models.forecasting.foundation_model.logger.warning"
+        ) as mock_warning:
+            _ = Chronos2Model(
+                input_chunk_length=12,
+                output_chunk_length=6,
+                enable_finetuning=False,
+                freeze_patterns=["some_pattern"],
+                **tfm_kwargs,
+            )
+            mock_warning.assert_called_once()
+            assert "enable_finetuning` is False" in mock_warning.call_args[0][0]
+
+    @patch(
+        "darts.models.components.huggingface_connector.hf_hub_download",
+        side_effect=mock_download,
+    )
+    def test_lora_callback(self, mock_method, tmpdir):
+        pytest.importorskip("peft")
+        from peft import LoraConfig, PeftModel
+
+        lora_config = LoraConfig(target_modules=["q", "v"])
+        callback = PeftCallback(peft_config=lora_config)
+
+        # Avoid duplicate pl_trainer_kwargs
+        kwargs = {k: v for k, v in tfm_kwargs.items() if k != "pl_trainer_kwargs"}
+        pl_trainer_kwargs = tfm_kwargs.get("pl_trainer_kwargs", {}).copy()
+        pl_trainer_kwargs["callbacks"] = [callback]
+
+        model = Chronos2Model(
+            input_chunk_length=12,
+            output_chunk_length=6,
+            enable_finetuning=True,
+            pl_trainer_kwargs=pl_trainer_kwargs,
+            **kwargs,
+        )
+
+        # 1. Initialize and fit
+        model.fit(self.series, epochs=5)
+
+        # Verify transformation happened
+        assert isinstance(model.internal_model, PeftModel), (
+            "Internal model should be a PeftModel after fit"
+        )
+
+        # 2. Checkpoint merging test (via save/load)
+        save_path = os.path.join(tmpdir, "lora_model.pt")
+        model.save(save_path)
+
+        # Loading back should yield a standard model (weights merged)
+        loaded_model = Chronos2Model.load(save_path)
+        assert not isinstance(loaded_model.internal_model, PeftModel), (
+            "Loaded model should have merged weights and not be a PeftModel"
+        )
+
+        # Verify predictions match
+        pred_orig = model.predict(n=6, series=self.series)
+        pred_loaded = loaded_model.predict(n=6, series=self.series)
+        assert np.allclose(pred_orig.values(), pred_loaded.values()), (
+            "Prediction of the fine-tuned model and the saved/loaded fine-tuned model should be the same"
+        )
diff --git a/darts/utils/callbacks/__init__.py b/darts/utils/callbacks/__init__.py
new file mode 100644
index 0000000000..5e0391b415
--- /dev/null
+++ b/darts/utils/callbacks/__init__.py
@@ -0,0 +1,5 @@
+from darts.utils.callbacks.progress_bar import TFMProgressBar
+
+__all__ = [
+    "TFMProgressBar",
+]
diff --git a/darts/utils/callbacks/fine_tuning.py b/darts/utils/callbacks/fine_tuning.py
new file mode 100644
index 0000000000..3c904f3824
--- /dev/null
+++ b/darts/utils/callbacks/fine_tuning.py
@@ -0,0 +1,239 @@
+from functools import partial
+from typing import Any, Callable, Optional
+
+import pytorch_lightning as pl
+from pytorch_lightning.callbacks import Callback
+from torch import nn
+
+from darts.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class ModelTransformCallback(Callback):
+    def __init__(
+        self,
+        transform_fn: Callable[[nn.Module], nn.Module],
+        model_attribute: str = "model",
+        verbose: Optional[bool] = None,
+    ):
+        """
+        A PyTorch Lightning callback that applies a transformation function to an internal model
+        within a LightningModule.
+
+        This is useful for modifying model architectures (e.g., applying PEFT or freezing layers)
+        just before the training starts, while ensuring the transformation is correctly handled
+        during checkpoint saving and loading.
+
+        Parameters
+        ----------
+        transform_fn
+            A function that takes an ``nn.Module`` and returns a transformed ``nn.Module``.
+        model_attribute
+            The attribute name of the model within the LightningModule. Default: ``"model"``.
+        verbose
+            Whether to log information about the model transformation, such as the number of
+            trainable parameters. If ``None``, it will be set to ``True`` if the trainer has a
+            progress bar callback enabled (e.g. when ``model.fit(..., verbose=True)``).
+            Default: ``None``.
+        """
+        super().__init__()
+        self.transform_fn = transform_fn
+        self.model_attribute = model_attribute
+        self.verbose = verbose
+        self._transformed = False
+
+    def _get_inner_model(self, pl_module: pl.LightningModule) -> nn.Module:
+        """Get the inner model from the Lightning module."""
+        return getattr(pl_module, self.model_attribute)
+
+    def _set_inner_model(self, pl_module: pl.LightningModule, model: nn.Module):
+        """Set the inner model on the Lightning module."""
+        setattr(pl_module, self.model_attribute, model)
+
+    def setup(self, trainer: pl.Trainer, pl_module: pl.LightningModule, stage: str):
+        """Apply transformation before training begins (before optimizer setup)."""
+        if not self._transformed:
+            inner_model = self._get_inner_model(pl_module)
+            transformed_model = self.transform_fn(inner_model)
+            self._set_inner_model(pl_module, transformed_model)
+            self._transformed = True
+
+            verbose = self.verbose
+            if verbose is None:
+                verbose = trainer.progress_bar_callback is not None
+
+            if verbose:
+                # Log trainable parameters
+                trainable = sum(
+                    p.numel() for p in pl_module.parameters() if p.requires_grad
+                )
+                total = sum(p.numel() for p in pl_module.parameters())
+                logger.info(
+                    f"Model transformed. Trainable: {trainable:,}/{total:,} ({100 * trainable / total:.2f}%)"
+                )
+
+    def on_save_checkpoint(
+        self,
+        trainer: pl.Trainer,
+        pl_module: pl.LightningModule,
+        checkpoint: dict[str, Any],
+    ):
+        """
+        Handle checkpoint saving for transformed models.
+
+        For PEFT models, we could optionally save just the adapter weights
+        or mark the checkpoint as requiring transformation on load.
+        """
+        # Mark that this checkpoint was saved with a transformed model
+        checkpoint["model_transform_applied"] = True
+
+    def on_load_checkpoint(
+        self,
+        trainer: pl.Trainer,
+        pl_module: pl.LightningModule,
+        checkpoint: dict[str, Any],
+    ):
+        """
+        Apply transformation before loading checkpoint weights.
+
+        This ensures the model structure matches the saved weights.
+        """
+        if checkpoint.get("model_transform_applied", False) and not self._transformed:
+            inner_model = self._get_inner_model(pl_module)
+            transformed_model = self.transform_fn(inner_model)
+            self._set_inner_model(pl_module, transformed_model)
+            self._transformed = True
+
+
+class LayerFreezeCallback(ModelTransformCallback):
+    @classmethod
+    def _freeze_layers(
+        cls, model: nn.Module, freeze_patterns: list[str], unfreeze_patterns: list[str]
+    ) -> nn.Module:
+        for name, param in model.named_parameters():
+            if any(name.startswith(layer) for layer in freeze_patterns):
+                param.requires_grad = False
+            if any(name.startswith(layer) for layer in unfreeze_patterns):
+                param.requires_grad = True
+        return model
+
+    def __init__(
+        self,
+        freeze_patterns: list[str],
+        unfreeze_patterns: list[str] = None,
+        model_attribute: str = "model",
+        verbose: Optional[bool] = None,
+    ):
+        """
+        A callback to freeze or unfreeze specific layers of a model based on name patterns.
+
+        Parameters
+        ----------
+        freeze_patterns
+            A list of strings. Parameters whose names start with any of these patterns will be frozen
+            (``requires_grad=False``).
+        unfreeze_patterns
+            A list of strings. Parameters whose names start with any of these patterns will be unfrozen
+            (``requires_grad=True``). This is applied after ``freeze_patterns``. Default: ``None``.
+        model_attribute
+            The attribute name of the model within the LightningModule. Default: ``"model"``.
+        verbose
+            Whether to log the trainable parameter count after freezing. If ``None``, it will be
+            set to ``True`` if the trainer has a progress bar callback enabled
+            (e.g. when ``model.fit(..., verbose=True)``). Default: ``None``.
+        """
+        unfreeze_patterns = unfreeze_patterns or []
+
+        super().__init__(
+            transform_fn=partial(
+                self._freeze_layers,
+                freeze_patterns=freeze_patterns,
+                unfreeze_patterns=unfreeze_patterns,
+            ),
+            model_attribute=model_attribute,
+            verbose=verbose,
+        )
+
+
+class PeftCallback(ModelTransformCallback):
+    @classmethod
+    def _apply_peft(cls, model: nn.Module, peft_config) -> nn.Module:
+        try:
+            from peft import get_peft_model
+        except ImportError:
+            raise ImportError(
+                "Please install the `peft` package to use PeftCallback: `pip install peft`."
+            )
+        peft_model = get_peft_model(model, peft_config)
+        return peft_model
+
+    def __init__(
+        self,
+        peft_config=None,
+        model_attribute: str = "model",
+        verbose: Optional[bool] = None,
+    ):
+        """
+        A callback to apply Parameter-Efficient Fine-Tuning (PEFT) to a model using the ``peft`` library.
+
+        It wraps the internal model with a PEFT adapter (e.g., LoRA) and manages the merging of
+        weights during checkpointing so that the saved state can be loaded as a standard model.
+
+        Parameters
+        ----------
+        peft_config
+            A PEFT configuration object (e.g., ``LoraConfig``) from the ``peft`` library.
+        model_attribute
+            The attribute name of the model within the LightningModule. Default: ``"model"``.
+        verbose
+            Whether to log the trainable parameter count after applying PEFT. If ``None``, it will be
+            set to ``True`` if the trainer has a progress bar callback enabled
+            (e.g. when ``model.fit(..., verbose=True)``). Default: ``None``.
+        """
+        super().__init__(
+            transform_fn=partial(self._apply_peft, peft_config=peft_config),
+            model_attribute=model_attribute,
+            verbose=verbose,
+        )
+        self.peft_config = peft_config
+
+    def on_save_checkpoint(self, trainer, pl_module, checkpoint):
+        # We replace the state_dict in the checkpoint with the one from the base model
+        # (with adapters merged), so that the model can be loaded as a regular model.
+        super().on_save_checkpoint(trainer, pl_module, checkpoint)
+        peft_model = getattr(pl_module, self.model_attribute, None)
+        try:
+            from peft import PeftModel
+        except ImportError:
+            return
+
+        if isinstance(peft_model, PeftModel):
+            # In-place merge of adapters into the base model weights.
+            # This is memory-efficient as it avoids a full deepcopy and works on GPU.
+            peft_model.merge_adapter()
+            try:
+                # Obtain the state_dict of the base model (which now has merged weights).
+                # We filter out the adapter-specific keys (e.g. lora_A, lora_B)
+                # and restore the original key names by removing PEFT wrapper prefixes (e.g. base_layer).
+                # This allows the model to be loaded back as a standard (non-PEFT) model.
+                prefix = self.model_attribute + "."
+                new_state_dict = {}
+                # IMPORTANT: We move merged weights to CPU. This avoids GPU OOM
+                # (holding two copies of the parameters on GPU) and ensures we have
+                # a 'snapshot' that won't be changed by the subsequent unmerge.
+                for k, v in peft_model.get_base_model().state_dict().items():
+                    if any(sub in k for sub in ["lora_", "modules_to_save"]):
+                        continue
+
+                    # PEFT wraps layers and adds a ".base_layer" to the key path
+                    # We only replace if it's followed by a dot to avoid partial matches
+                    clean_key = k.replace(".base_layer.", ".")
+                    new_state_dict[prefix + clean_key] = v.cpu().clone()
+
+                # Update the checkpoint
+                checkpoint["state_dict"] = new_state_dict
+
+            finally:
+                # Restore the adapters (unmerge from base weights) to allow training to continue.
+                peft_model.unmerge_adapter()
diff --git a/darts/utils/callbacks.py b/darts/utils/callbacks/progress_bar.py
similarity index 100%
rename from darts/utils/callbacks.py
rename to darts/utils/callbacks/progress_bar.py
diff --git a/examples/26-Chronos-2-finetuning-examples.ipynb b/examples/26-Chronos-2-finetuning-examples.ipynb
new file mode 100644
index 0000000000..09554b97d5
--- /dev/null
+++ b/examples/26-Chronos-2-finetuning-examples.ipynb
@@ -0,0 +1,957 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "da55dd6c",
+   "metadata": {},
+   "source": [
+    "# Chronos-2 Foundation Model Fine-Tuning\n",
+    "This example notebook presents how fine-tuning can be applied to the Chronos-2 model using both built-in Darts features and external libraries.\n",
+    "\n",
+    "The following fine-tuning methods will be shown:\n",
+    "1) **Full fine-tuning**: All model weights are retrained. This is natively supported by setting `enable_finetuning=True`.\n",
+    "2) **Partial fine-tuning**: Specific layers are frozen via name patterns. This is natively supported using `freeze_patterns` and `unfreeze_patterns`.\n",
+    "3) **PEFT fine-tuning**: The HuggingFace `peft` library is used via a custom Darts callback (`PeftCallback`) to apply LoRA. This shows how to extend Darts with external specialized libraries.\n",
+    "\n",
+    "To be useful, a fine-tuned model should be easily saved and loaded. For each method, we will demonstrate how to persist the model weights.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bfa59f65",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "310fa52a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# fix python path if working locally\n",
+    "from utils import fix_pythonpath_if_working_locally\n",
+    "\n",
+    "fix_pythonpath_if_working_locally()\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "d510b54b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import warnings\n",
+    "\n",
+    "import numpy as np\n",
+    "\n",
+    "from darts.datasets import AirPassengersDataset\n",
+    "from darts.models import Chronos2Model\n",
+    "\n",
+    "warnings.filterwarnings(\"ignore\")\n",
+    "import logging\n",
+    "\n",
+    "logging.disable(logging.CRITICAL)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6b82a07a",
+   "metadata": {},
+   "source": [
+    "## Data Preparation\n",
+    "Here we just load an example dataset with 144 samples as a fast demo. The data is split between train and validation, with the 2 last years (24 samples) for validation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "2f87bcc5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# convert to float32 as Chronos-2 works with float32 input\n",
+    "data = AirPassengersDataset().load().astype(np.float32)\n",
+    "train_passengers, val_passengers = data.split_before(\n",
+    "    len(data) - 2 * 12\n",
+    ")  # last 2 years for validation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b9251561",
+   "metadata": {},
+   "source": [
+    "# Model prediction out-of-the-box\n",
+    "Let's see how the model behaves on the validation data without any fine-tuning. For that we:\n",
+    "- Create the model\n",
+    "- Call fit to load the model internally (no training is done)\n",
+    "- Predict on the validation set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "ea8456ae",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d269fe29e6ab4b0faa9ca063fc607f74",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Predicting: |          | 0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: title={'center': 'Base model (not finetuned yet)'}, xlabel='Month'>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "model = Chronos2Model(\n",
+    "    input_chunk_length=24,\n",
+    "    output_chunk_length=6,\n",
+    ")\n",
+    "model.fit(train_passengers, verbose=True)\n",
+    "\n",
+    "prediction = model.predict(\n",
+    "    n=len(val_passengers),\n",
+    "    series=train_passengers,\n",
+    ")\n",
+    "val_passengers.plot(label=\"Ground truth\")\n",
+    "prediction.plot(label=\"Forecast\", title=\"Base model (not finetuned yet)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1313019f",
+   "metadata": {},
+   "source": [
+    "# 1. Full fine-tuning\n",
+    "\n",
+    "In this method, all the model weights are retrained. This is simply enabled by passing `enable_finetuning=True` to the model constructor. \n",
+    "\n",
+    "When fine-tuning is enabled, Darts will treat the foundation model like a standard trainable model during `fit()`. Saving and loading follows the standard Darts API via the `save()` and `load()` methods.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "72832dff",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "45bbf43f117543b7a171e399527dce2d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Training: |          | 0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "full_finetuned_model = Chronos2Model(\n",
+    "    input_chunk_length=24,\n",
+    "    output_chunk_length=6,\n",
+    "    enable_finetuning=True,\n",
+    "    n_epochs=100,\n",
+    "    pl_trainer_kwargs={\"accelerator\": \"gpu\"},\n",
+    ")\n",
+    "full_finetuned_model.fit(train_passengers, verbose=True)\n",
+    "full_finetuned_model.save(\"full_finetuned.pt\")\n",
+    "\n",
+    "# Load\n",
+    "full_finetuned_loaded_model = Chronos2Model.load(\"full_finetuned.pt\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ba806d95",
+   "metadata": {},
+   "source": [
+    "We can compare the prediction with the ground truth, as well as checking that the loaded model behaves similarly to the fine-tuned model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "9bbd219e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5c258dd1f466442ba7f0d7ffa12fe5fb",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Predicting: |          | 0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "cd4bb0d55fd94fb48bffd7428f22e10c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Predicting: |          | 0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: title={'center': 'Full finetuning'}, xlabel='Month'>"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pred_full_finetuned = full_finetuned_model.predict(\n",
+    "    n=len(val_passengers),\n",
+    "    series=train_passengers,\n",
+    ")\n",
+    "pred_full_finetuned_loaded = full_finetuned_loaded_model.predict(\n",
+    "    n=len(val_passengers),\n",
+    "    series=train_passengers,\n",
+    ")\n",
+    "val_passengers.plot(label=\"Ground truth\")\n",
+    "pred_full_finetuned.plot(label=\"Forecast of the full finetuned model\", linestyle=\"-.\")\n",
+    "pred_full_finetuned_loaded.plot(\n",
+    "    label=\"Forecast of the loaded full finetuned model\",\n",
+    "    linestyle=\"--\",\n",
+    "    title=\"Full finetuning\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d3dc22f4",
+   "metadata": {},
+   "source": [
+    "We can also verify numericaly that the prediction of the trained model is identical to the prediction of the loaded model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "599402d3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.allclose(pred_full_finetuned.values(), pred_full_finetuned_loaded.values())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3cabab8a",
+   "metadata": {},
+   "source": [
+    "# 2. Partial fine-tuning with layer freezing\n",
+    "\n",
+    "Partial fine-tuning allows you to update only a subset of the model's parameters, which is useful for preserving general knowledge while adapting to specific patterns. \n",
+    "\n",
+    "Darts foundation models natively support this via:\n",
+    "- `freeze_patterns`: A list of parameter name prefixes to freeze (`requires_grad=False`).\n",
+    "- `unfreeze_patterns`: A list of prefixes to unfreeze (applied after freezing).\n",
+    "\n",
+    "This mechanism automatically injects a `LayerFreezeCallback` into the training process."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "33fa7fc4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "50dfcff23af64611b005b9875ed3209f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Training: |          | 0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "partial_finetuned_model = Chronos2Model(\n",
+    "    input_chunk_length=12,\n",
+    "    output_chunk_length=6,\n",
+    "    enable_finetuning=True,\n",
+    "    freeze_patterns=[\"encoder.block.0\", \"encoder.block.1\", \"encoder.block.2\"],\n",
+    "    unfreeze_patterns=[\"output_patch_embedding\"],\n",
+    "    n_epochs=100,\n",
+    "    pl_trainer_kwargs={\"accelerator\": \"gpu\"},\n",
+    ")\n",
+    "partial_finetuned_model.fit(train_passengers, verbose=True)\n",
+    "partial_finetuned_model.save(\"partial_finetuned.pt\")\n",
+    "\n",
+    "# Load - no callback needed, structure unchanged\n",
+    "partial_finetuned_loaded_model = Chronos2Model.load(\"partial_finetuned.pt\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "50830283",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "aaec2192041d44fa99aedae592c73a9d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Predicting: |          | 0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "72100e6de88e44fe904f1ced2c4189dc",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Predicting: |          | 0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: title={'center': 'Partial finetuning'}, xlabel='Month'>"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pred_partial_finetuned = partial_finetuned_model.predict(\n",
+    "    n=len(val_passengers),\n",
+    "    series=train_passengers,\n",
+    "    random_state=42,\n",
+    ")\n",
+    "pred_partial_finetuned_loaded = partial_finetuned_loaded_model.predict(\n",
+    "    n=len(val_passengers),\n",
+    "    series=train_passengers,\n",
+    "    random_state=42,\n",
+    ")\n",
+    "val_passengers.plot(label=\"Ground truth\")\n",
+    "pred_partial_finetuned.plot(\n",
+    "    label=\"Forecast of the partial finetuned model\", linestyle=\"-.\"\n",
+    ")\n",
+    "pred_partial_finetuned_loaded.plot(\n",
+    "    label=\"Forecast of the loaded partial finetuned model\",\n",
+    "    linestyle=\"--\",\n",
+    "    title=\"Partial finetuning\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3c01daaa",
+   "metadata": {},
+   "source": [
+    "Again, we verify that the prediction of the fine-tuned model is the same as the loaded model to make sure that saving/load works correctly"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "01717b70",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.allclose(pred_partial_finetuned.values(), pred_partial_finetuned_loaded.values())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b0d126dc",
+   "metadata": {},
+   "source": [
+    "# 3. LoRA fine-tuning (PEFT)\n",
+    "\n",
+    "This method uses the HuggingFace `peft` library for **P**arameter **E**fficient **F**ine-**T**uning. \n",
+    "\n",
+    "Darts provides a `PeftCallback` that wraps the internal model with adapters (like LoRA) before training. One major advantage of this callback is that it automatically handles **weight merging** during checkpointing, allowing the saved model to be loaded back as a standard model without needing the `peft` library at inference time.\n",
+    "\n",
+    "More information about peft can be found in the [official documentation](https://github.com/huggingface/peft)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "6981052c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2fb40bbee4d246c4aac9d8c63d6dcec6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Training: |          | 0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Chronos2Model(output_chunk_shift=0, likelihood=None, hub_model_name=amazon/chronos-2, hub_model_revision=None, local_dir=None, input_chunk_length=24, output_chunk_length=6, enable_finetuning=True, n_epochs=100, pl_trainer_kwargs={'accelerator': 'gpu', 'callbacks': [<darts.utils.callbacks.fine_tuning.PeftCallback object at 0x000002148C680740>]})"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from peft import LoraConfig\n",
+    "\n",
+    "from darts.utils.callbacks.fine_tuning import PeftCallback\n",
+    "\n",
+    "lora_config = LoraConfig(\n",
+    "    r=32,\n",
+    "    lora_alpha=64,\n",
+    "    target_modules=[\n",
+    "        \"q\",\n",
+    "        \"v\",\n",
+    "        \"k\",\n",
+    "        \"o\",\n",
+    "        \"output_patch_embedding.output_layer\",\n",
+    "    ],\n",
+    ")\n",
+    "peft_callback = PeftCallback(peft_config=lora_config)\n",
+    "\n",
+    "model_lora = Chronos2Model(\n",
+    "    input_chunk_length=24,\n",
+    "    output_chunk_length=6,\n",
+    "    enable_finetuning=True,\n",
+    "    n_epochs=100,\n",
+    "    pl_trainer_kwargs={\"accelerator\": \"gpu\", \"callbacks\": [peft_callback]},\n",
+    ")\n",
+    "model_lora.fit(train_passengers, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e86085e3",
+   "metadata": {},
+   "source": [
+    "## 3.1 Full-model saving\n",
+    "Darts `save` and `load` methods can be used to save the full model weights."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "49b2c2e8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Fully save the model including adapters\n",
+    "model_lora.save(\"chronos2_lora_finetuned.pt\")\n",
+    "model_lora_loaded = Chronos2Model.load(\"chronos2_lora_finetuned.pt\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "41e8a82f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "32bc596de3864391bc0544b8850eef53",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Predicting: |          | 0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "67cf8731f2b149be8e37ac2a426256f8",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Predicting: |          | 0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: title={'center': 'LoRA finetuning - Save all'}, xlabel='Month'>"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pred_lora_trained = model_lora.predict(\n",
+    "    n=len(val_passengers),\n",
+    "    series=train_passengers,\n",
+    "    random_state=42,\n",
+    ")\n",
+    "pred_lora_loaded = model_lora_loaded.predict(\n",
+    "    n=len(val_passengers),\n",
+    "    series=train_passengers,\n",
+    "    random_state=42,\n",
+    ")\n",
+    "val_passengers.plot(label=\"Ground truth\")\n",
+    "pred_lora_trained.plot(label=\"Forecast of the LoRA trained model\", linestyle=\"-.\")\n",
+    "pred_lora_loaded.plot(\n",
+    "    label=\"Forecast of the loaded LoRA model\",\n",
+    "    linestyle=\"--\",\n",
+    "    title=\"LoRA finetuning - Save all\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "32cef0b5",
+   "metadata": {},
+   "source": [
+    "Again, we verify that the prediction of the fine-tuned model is the same as the loaded model to make sure that saving/load works correctly"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "9a96ca55",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.allclose(pred_lora_loaded.values(), pred_lora_trained.values())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c633f2ad",
+   "metadata": {},
+   "source": [
+    "## 3.2 Adapter saving\n",
+    "\n",
+    "Alternatively, you may want to save *only* the lightweight adapters rather than the full model weights.\n",
+    "\n",
+    "Foundation models in Darts provide an `internal_model` property that gives direct access to the underlying PyTorch `nn.Module`. We can use this to interact with the `peft` API directly for saving and loading.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "ce2fcd82",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_lora.internal_model.save_pretrained(\"chronos2_lora_adapters/\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6e2f159a",
+   "metadata": {},
+   "source": [
+    "Then, a new model can be created, and the internal model can be replaced with the loaded adapter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "630bb5bc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from peft import PeftModel\n",
+    "\n",
+    "model_new = Chronos2Model(\n",
+    "    input_chunk_length=24,\n",
+    "    output_chunk_length=6,\n",
+    ")\n",
+    "model_new.fit(train_passengers)  # Initialize model\n",
+    "\n",
+    "# Replace _Chronos2Module with PeftModel containing _Chronos2Module + adapters\n",
+    "model_new.internal_model = PeftModel.from_pretrained(\n",
+    "    model_new.internal_model, \"chronos2_lora_adapters/\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "c1fddf83",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "975912059afa49ffb2f73ed18de29fc1",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Predicting: |          | 0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7e4af30c12834bf29a072214857d1bc1",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Predicting: |          | 0/? [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: title={'center': 'LoRA finetuning - Save adapters only'}, xlabel='Month'>"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pred_lora_trained = model_lora.predict(\n",
+    "    n=len(val_passengers),\n",
+    "    series=train_passengers,\n",
+    "    random_state=42,\n",
+    ")\n",
+    "pred_new = model_new.predict(\n",
+    "    n=len(val_passengers),\n",
+    "    series=train_passengers,\n",
+    "    random_state=42,\n",
+    ")\n",
+    "val_passengers.plot(label=\"Ground truth\")\n",
+    "pred_lora_trained.plot(label=\"Forecast of the trained model\", linestyle=\"-.\")\n",
+    "pred_new.plot(\n",
+    "    label=\"Forecast of the loaded model\",\n",
+    "    linestyle=\"--\",\n",
+    "    title=\"LoRA finetuning - Save adapters only\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "022127ca",
+   "metadata": {},
+   "source": [
+    "# 4. Performance Evaluation\n",
+    "\n",
+    "Finally, let's compare the performance of all four models (Base, Full Fine-tuning, Partial Fine-tuning, and LoRA) on the validation set using standard metrics like **MAPE** (Mean Absolute Percentage Error) and **MAE** (Mean Absolute Error).\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "3b81f2e2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Model</th>\n",
+       "      <th>MAPE (%)</th>\n",
+       "      <th>MAE</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Base Model</td>\n",
+       "      <td>15.254518</td>\n",
+       "      <td>70.704819</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Full Fine-tuning</td>\n",
+       "      <td>4.550051</td>\n",
+       "      <td>20.350664</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Partial Fine-tuning</td>\n",
+       "      <td>4.891376</td>\n",
+       "      <td>21.527288</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>LoRA (PEFT)</td>\n",
+       "      <td>5.457223</td>\n",
+       "      <td>23.800879</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                 Model   MAPE (%)        MAE\n",
+       "0           Base Model  15.254518  70.704819\n",
+       "1     Full Fine-tuning   4.550051  20.350664\n",
+       "2  Partial Fine-tuning   4.891376  21.527288\n",
+       "3          LoRA (PEFT)   5.457223  23.800879"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "from darts.metrics import mae, mape\n",
+    "\n",
+    "results = []\n",
+    "all_predictions = {\n",
+    "    \"Base Model\": prediction,\n",
+    "    \"Full Fine-tuning\": pred_full_finetuned,\n",
+    "    \"Partial Fine-tuning\": pred_partial_finetuned,\n",
+    "    \"LoRA (PEFT)\": pred_lora_trained,\n",
+    "}\n",
+    "\n",
+    "for name, pred in all_predictions.items():\n",
+    "    results.append({\n",
+    "        \"Model\": name,\n",
+    "        \"MAPE (%)\": mape(val_passengers, pred),\n",
+    "        \"MAE\": mae(val_passengers, pred),\n",
+    "    })\n",
+    "\n",
+    "df_results = pd.DataFrame(results)\n",
+    "df_results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "996456e0",
+   "metadata": {},
+   "source": [
+    "### Observations\n",
+    "\n",
+    "While the results on this small \"toy\" dataset (Air Passengers) may vary depending on the random seed and hyperparameters, they demonstrate the flexibility of the fine-tuning API.\n",
+    "\n",
+    "In real-world scenarios with larger datasets:\n",
+    "- **Full Fine-tuning** offers the most flexibility but is computationally expensive and prone to \"catastrophic forgetting\".\n",
+    "- **Partial Fine-tuning** provides a good middle ground by updating only the most relevant layers (like the output head).\n",
+    "- **LoRA (PEFT)** is often the most effective strategy. It typically matches or exceeds full fine-tuning performance while only training a tiny fraction (often <1%) of the parameters. This makes it faster, more memory-efficient, and allows for much easier deployment of multiple task-specific \"adapters\" on top of a single base model.\n",
+    "\n",
+    "### Summary\n",
+    "In this notebook, we have seen:\n",
+    "1. How to enable **native full fine-tuning** in Darts foundation models.\n",
+    "2. How to use **layer freezing patterns** to perform partial fine-tuning without manual weight manipulation.\n",
+    "3. How to extend Darts foundation models with **custom callbacks** to leverage external libraries like `peft`.\n",
+    "4. How to use the `internal_model` property to gain low-level access to the underlying PyTorch module for advanced operations.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2286828a",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "darts",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}