autogluon.multimodal 1.2.1b20250303__py3-none-any.whl → 1.2.1b20250305__py3-none-any.whl

autogluon/multimodal/predictor.py

@@ -8,6 +8,7 @@ import os
 import warnings
 from typing import Dict, List, Optional, Union
 
+import numpy as np
 import pandas as pd
 import transformers
 
@@ -17,14 +18,15 @@ from autogluon.core.metrics import Scorer
 from .constants import AUTOMM_TUTORIAL_MODE, FEW_SHOT_CLASSIFICATION, NER, OBJECT_DETECTION, SEMANTIC_SEGMENTATION
 from .learners import (
     BaseLearner,
+    EnsembleLearner,
     FewShotSVMLearner,
-    MultiModalMatcher,
+    MatchingLearner,
     NERLearner,
     ObjectDetectionLearner,
     SemanticSegmentationLearner,
 )
-from .problem_types import PROBLEM_TYPES_REG
 from .utils import get_dir_ckpt_paths
+from .utils.problem_types import PROBLEM_TYPES_REG
 
 pl_logger = logging.getLogger("lightning")
 pl_logger.propagate = False  # https://github.com/Lightning-AI/lightning/issues/4621
@@ -64,6 +66,9 @@ class MultiModalPredictor:
         pretrained: Optional[bool] = True,
         validation_metric: Optional[str] = None,
         sample_data_path: Optional[str] = None,
+        use_ensemble: Optional[bool] = False,
+        ensemble_size: Optional[int] = 2,
+        ensemble_mode: Optional[str] = "one_shot",
     ):
         """
         Parameters
@@ -164,6 +169,15 @@ class MultiModalPredictor:
             If not provided, it would be automatically chosen based on the problem type.
         sample_data_path
             The path to sample data from which we can infer num_classes or classes used for object detection.
+        use_ensemble
+            Whether to use ensembling when fitting the predictor (Default False).
+            Currently, it works only on multimodal data (image+text, image+tabular, text+tabular, image+text+tabular) with classification or regression tasks.
+        ensemble_size
+            A multiple of number of models in the ensembling pool (Default 2). The actual ensemble size = ensemble_size * the model number
+        ensemble_mode
+            The mode of conducting ensembling:
+            - `one_shot`: the classic ensemble selection
+            - `sequential`: iteratively calling the classic ensemble selection with each time growing the model zoo by the best next model.
         """
         if problem_type is not None:
             problem_type = problem_type.lower()
@@ -192,7 +206,7 @@ class MultiModalPredictor:
         self._verbosity = verbosity
 
         if problem_property and problem_property.is_matching:
-            learner_class = MultiModalMatcher
+            learner_class = MatchingLearner
         elif problem_type == OBJECT_DETECTION:
             learner_class = ObjectDetectionLearner
         elif problem_type == NER:
@@ -204,6 +218,9 @@ class MultiModalPredictor:
         else:
             learner_class = BaseLearner
 
+        if use_ensemble:
+            learner_class = EnsembleLearner
+
         self._learner = learner_class(
             label=label,
             problem_type=problem_type,
@@ -222,6 +239,8 @@ class MultiModalPredictor:
             query=query,
             response=response,
             match_label=match_label,
+            ensemble_size=ensemble_size,
+            ensemble_mode=ensemble_mode,
         )
 
     @property
@@ -413,6 +432,9 @@ class MultiModalPredictor:
         standalone: Optional[bool] = True,
         hyperparameter_tune_kwargs: Optional[dict] = None,
         clean_ckpts: Optional[bool] = True,
+        predictions: Optional[List[np.ndarray]] = None,
+        labels: Optional[np.ndarray] = None,
+        predictors: Optional[List[Union[str, MultiModalPredictor]]] = None,
     ):
         """
         Fit models to predict a column of a data table (label) based on the other columns (features).
@@ -435,6 +457,8 @@ class MultiModalPredictor:
         time_limit
             How long `fit()` should run for (wall clock time in seconds).
             If not specified, `fit()` will run until the model has completed training.
+            Note that, if use_ensemble=True, the total running time would be time_limit * N,
+            where N is the number of models in the ensemble.
         save_path
             Path to directory where models and artifacts should be saved.
         hyperparameters
@@ -506,6 +530,13 @@ class MultiModalPredictor:
             teacher_learner = teacher_predictor
         else:
             teacher_learner = teacher_predictor._learner
+
+        if predictors is None:
+            learners = None
+        else:
+            assert isinstance(predictors, list)
+            learners = [ele if isinstance(ele, str) else ele._learner for ele in predictors]
+
         self._learner.fit(
             train_data=train_data,
             presets=presets,
@@ -522,6 +553,9 @@ class MultiModalPredictor:
             hyperparameter_tune_kwargs=hyperparameter_tune_kwargs,
             clean_ckpts=clean_ckpts,
             id_mappings=id_mappings,
+            predictions=predictions,
+            labels=labels,
+            learners=learners,
         )
 
         return self
@@ -540,6 +574,8 @@ class MultiModalPredictor:
         return_pred: Optional[bool] = False,
         realtime: Optional[bool] = False,
         eval_tool: Optional[str] = None,
+        predictions: Optional[List[np.ndarray]] = None,
+        labels: Optional[np.ndarray] = None,
     ):
         """
         Evaluate the model on a given dataset.
@@ -595,6 +631,8 @@ class MultiModalPredictor:
             similarity_type=similarity_type,
             cutoffs=cutoffs,
             label=label,
+            predictions=predictions,
+            labels=labels,
         )
 
     def predict(
@@ -807,18 +845,19 @@ class MultiModalPredictor:
 
         with open(os.path.join(dir_path, "assets.json"), "r") as fp:
             assets = json.load(fp)
-        if "class_name" in assets and assets["class_name"] == "MultiModalMatcher":
-            learner_class = MultiModalMatcher
-        elif assets["problem_type"] == OBJECT_DETECTION:
+        learner_class = BaseLearner
+        if assets["learner_class"] == "MatchingLearner":
+            learner_class = MatchingLearner
+        elif assets["learner_class"] == "EnsembleLearner":
+            learner_class = EnsembleLearner
+        elif assets["learner_class"] == "FewShotSVMLearner":
+            learner_class = FewShotSVMLearner
+        elif assets["learner_class"] == "ObjectDetectionLearner":
             learner_class = ObjectDetectionLearner
-        elif assets["problem_type"] == NER:
+        elif assets["learner_class"] == "NERLearner":
             learner_class = NERLearner
-        elif assets["problem_type"] == FEW_SHOT_CLASSIFICATION:
-            learner_class = FewShotSVMLearner
-        elif assets["problem_type"] == SEMANTIC_SEGMENTATION:
+        elif assets["learner_class"] == "SemanticSegmentationLearner":
             learner_class = SemanticSegmentationLearner
-        else:
-            learner_class = BaseLearner
 
         predictor._learner = learner_class.load(path=path, resume=resume, verbosity=verbosity)
         return predictor

autogluon/multimodal/utils/__init__.py

@@ -16,66 +16,34 @@ from .config import (
     update_config_by_rules,
     update_hyperparameters,
     update_tabular_config_by_resources,
-    upgrade_config,
-)
-from .data import (
-    assign_feature_column_names,
-    create_data_processor,
-    create_fusion_data_processors,
-    data_to_df,
-    get_mixup,
-    infer_dtypes_by_model_names,
-    infer_scarcity_mode_by_data_size,
-    init_df_preprocessor,
-    split_train_tuning_data,
-    turn_on_off_feature_column_info,
+    update_ensemble_hyperparameters,
 )
+from .device import compute_num_gpus, get_available_devices, move_to_device
 from .distillation import DistillationMixin
 from .download import download, is_url
-from .environment import (
-    check_if_packages_installed,
-    compute_inference_batch_size,
-    compute_num_gpus,
-    get_available_devices,
-    get_precision_context,
-    infer_precision,
-    is_interactive_env,
-    is_interactive_strategy,
-    move_to_device,
-    run_ddp_only_once,
-)
 from .export import ExportMixin
 from .hpo import hyperparameter_tune
-from .inference import RealtimeMixin, extract_from_output
-from .load import CustomUnpickler, get_dir_ckpt_paths, get_load_ckpt_paths, load_text_tokenizers
+from .inference import RealtimeMixin, compute_inference_batch_size, extract_from_output
+from .load import CustomUnpickler, protected_zip_extraction, get_dir_ckpt_paths, get_load_ckpt_paths
 from .log import (
     LogFilter,
     apply_log_filter,
     get_gpu_message,
-    make_exp_dir,
     on_fit_end_message,
     on_fit_per_run_start_message,
     on_fit_start_message,
 )
 from .matcher import compute_semantic_similarity, convert_data_for_ranking, create_siamese_model, semantic_search
-from .metric import (
-    compute_ranking_score,
-    compute_score,
-    get_minmax_mode,
-    get_stopping_threshold,
-    infer_metrics,
-    infer_problem_type_by_eval_metric,
+from .misc import (
+    logits_to_prob,
+    path_expander,
+    path_to_base64str_expander,
+    path_to_bytearray_expander,
+    shopee_dataset,
+    tensor_to_ndarray,
+    merge_bio_format,
 )
-from .misc import logits_to_prob, merge_bio_format, shopee_dataset, tensor_to_ndarray
 from .mmcv import CollateMMDet, CollateMMOcr
-from .model import (
-    create_fusion_model,
-    create_model,
-    is_lazy_weight_tensor,
-    list_timm_models,
-    modify_duplicate_model_names,
-    select_model,
-)
 from .object_detection import (
     COCODataset,
     bbox_ratio_xywh_to_index_xyxy,
@@ -94,5 +62,11 @@ from .object_detection import (
     save_result_voc_format,
     visualize_detection,
 )
-from .save import process_save_path, save_text_tokenizers, setup_save_path
+from .precision import get_precision_context, infer_precision
+from .presets import get_basic_config, get_ensemble_presets, get_presets, list_presets, matcher_presets
+from .problem_types import PROBLEM_TYPES_REG, infer_problem_type_by_eval_metric
+from .save import process_save_path, setup_save_path, make_exp_dir
+from .strategy import is_interactive_strategy, run_ddp_only_once
+from .env import is_interactive_env
 from .visualizer import NERVisualizer, ObjectDetectionVisualizer, SemanticSegmentationVisualizer, visualize_ner
+from .install import check_if_packages_installed

autogluon/multimodal/utils/cache.py

@@ -10,7 +10,18 @@ import lightning.pytorch as pl
 import torch
 from lightning.pytorch.callbacks import BasePredictionWriter
 
-from ..constants import BBOX, LM_TARGET, LOGIT_SCALE, LOGITS, TEMPLATE_LOGITS, WEIGHT
+from ..constants import (
+    AUG_LOGITS,
+    BBOX,
+    LOGIT_SCALE,
+    MULTIMODAL_FEATURES,
+    MULTIMODAL_FEATURES_POST_AUG,
+    MULTIMODAL_FEATURES_PRE_AUG,
+    ORI_LOGITS,
+    VAE_MEAN,
+    VAE_VAR,
+    WEIGHT,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -146,7 +157,17 @@ class DDPPredictionWriter(BasePredictionWriter):
             return dict()
 
         for k, v in x[0].items():
-            if k in [WEIGHT, LOGIT_SCALE]:  # ignore the keys
+            if k in [
+                WEIGHT,
+                LOGIT_SCALE,
+                MULTIMODAL_FEATURES,
+                MULTIMODAL_FEATURES_PRE_AUG,
+                MULTIMODAL_FEATURES_POST_AUG,
+                ORI_LOGITS,
+                AUG_LOGITS,
+                VAE_MEAN,
+                VAE_VAR,
+            ]:  # ignore the keys
                 continue
             elif isinstance(v, dict):
                 results[k] = self.collate([i[k] for i in x])

autogluon/multimodal/utils/checkpoint.py

@@ -1,16 +1,30 @@
+"""
+Some utilities are copied from
+https://github.com/Lightning-AI/lightning/blob/master/src/lightning/fabric/utilities/cloud_io.py
+to address warnings:
+LightningDeprecationWarning: lightning.pytorch.utilities.cloud_io.atomic_save has been
+deprecated in v1.8.0 and will be removed in v1.10.0. This function is internal but you
+can copy over its implementation.
+"""
+
+import io
 import logging
 import os
 import re
 import shutil
-from typing import Any, Dict, List, Optional, Tuple, Union
+from pathlib import Path
+from typing import IO, Any, Callable, Dict, List, Optional, Tuple, Union
 
+import fsspec
 import lightning.pytorch as pl
 import torch
 from lightning.pytorch.strategies import DeepSpeedStrategy
 from lightning.pytorch.utilities.rank_zero import rank_zero_warn
 
-from .cloud_io import _atomic_save, get_filesystem
-from .cloud_io import _load as pl_load
+from .env import get_filesystem
+
+_DEVICE = Union[torch.device, str, int]
+_MAP_LOCATION_TYPE = Optional[Union[_DEVICE, Callable[[_DEVICE], _DEVICE], Dict[_DEVICE, _DEVICE]]]
 
 logger = logging.getLogger(__name__)
 
@@ -65,6 +79,45 @@ def average_checkpoints(
     return avg_state_dict
 
 
+def pl_load(
+    path_or_url: Union[IO, str, Path],
+    map_location: _MAP_LOCATION_TYPE = None,
+) -> Any:
+    """Loads a checkpoint.
+
+    Args:
+        path_or_url: Path or URL of the checkpoint.
+        map_location: a function, ``torch.device``, string or a dict specifying how to remap storage locations.
+    """
+    if not isinstance(path_or_url, (str, Path)):
+        # any sort of BytesIO or similar
+        return torch.load(path_or_url, map_location=map_location)  # nosec B614
+    if str(path_or_url).startswith("http"):
+        return torch.hub.load_state_dict_from_url(
+            str(path_or_url),
+            map_location=map_location,  # type: ignore[arg-type] # upstream annotation is not correct
+        )
+    fs = get_filesystem(path_or_url)
+    with fs.open(path_or_url, "rb") as f:
+        return torch.load(f, map_location=map_location)  # nosec B614
+
+
+def pl_save(checkpoint: Dict[str, Any], filepath: Union[str, Path]) -> None:
+    """Saves a checkpoint atomically, avoiding the creation of incomplete checkpoints.
+
+    Args:
+        checkpoint: The object to save.
+            Built to be used with the ``dump_checkpoint`` method, but can deal with anything which ``torch.save``
+            accepts.
+        filepath: The path to which the checkpoint will be saved.
+            This points to the file that the checkpoint will be stored in.
+    """
+    bytesbuffer = io.BytesIO()
+    torch.save(checkpoint, bytesbuffer)  # nosec B614
+    with fsspec.open(filepath, "wb") as f:
+        f.write(bytesbuffer.getvalue())
+
+
 class AutoMMModelCheckpointIO(pl.plugins.CheckpointIO):
     """
     Class that customizes how checkpoints are saved. Saves either the entire model or only parameters that have been explicitly updated during training. The latter reduces memory footprint substantially when training very large models with parameter-efficient finetuning methods.
@@ -124,14 +177,14 @@ class AutoMMModelCheckpointIO(pl.plugins.CheckpointIO):
         fs.makedirs(os.path.dirname(path), exist_ok=True)
         try:
             # write the checkpoint dictionary on the file
-            _atomic_save(checkpoint, path)
+            pl_save(checkpoint, path)
         except AttributeError as err:
             # todo (sean): is this try catch necessary still?
             # https://github.com/Lightning-AI/lightning/pull/431
             key = pl.LightningModule.CHECKPOINT_HYPER_PARAMS_KEY
             checkpoint.pop(key, None)
             rank_zero_warn(f"Warning, `{key}` dropped from checkpoint. An attribute is not picklable: {err}")
-            _atomic_save(checkpoint, path)
+            pl_save(checkpoint, path)
 
     def load_checkpoint(self, path, map_location: Optional[Any] = None) -> Dict[str, Any]:
         """

autogluon/multimodal/utils/config.py

@@ -5,22 +5,11 @@ import re
 import warnings
 from typing import Callable, Dict, List, Optional, Tuple, Union
 
-from omegaconf import DictConfig, OmegaConf
-from packaging import version
+from omegaconf import DictConfig, ListConfig, OmegaConf
 from torch import nn
 
-from ..constants import (
-    AUTOMM,
-    DATA,
-    FT_TRANSFORMER,
-    FUSION_TRANSFORMER,
-    HF_MODELS,
-    MODEL,
-    REGRESSION,
-    VALID_CONFIG_KEYS,
-)
-from ..presets import get_automm_presets, get_basic_automm_config
-from .data import get_detected_data_types
+from ..constants import DATA, FT_TRANSFORMER, FUSION_TRANSFORMER, HF_MODELS, MODEL, REGRESSION, VALID_CONFIG_KEYS
+from .presets import get_basic_config, get_ensemble_presets, get_presets
 
 logger = logging.getLogger(__name__)
 
@@ -68,7 +57,7 @@ def get_default_config(config: Optional[Union[Dict, DictConfig]] = None, extra:
     Parameters
     ----------
     config
-        A dictionary including four keys: "model", "data", "optimization", and "environment".
+        A dictionary including four keys: "model", "data", "optim", and "env".
         If any key is not given, we will fill in with the default value.
     extra
         A list of extra config keys.
@@ -83,7 +72,7 @@ def get_default_config(config: Optional[Union[Dict, DictConfig]] = None, extra:
     if config is None:
         config = {}
 
-    basic_config = get_basic_automm_config(extra=extra)
+    basic_config = get_basic_config(extra=extra)
     for k, default_value in basic_config.items():
         if k not in config:
             config[k] = default_value
@@ -119,7 +108,7 @@ def get_config(
     extra: Optional[List[str]] = None,
 ):
     """
-    Construct configurations for model, data, optimization, and environment.
+    Construct configurations for model, data, optim, and env.
     It supports to overrides some default configurations.
 
     Parameters
@@ -129,29 +118,29 @@ def get_config(
     presets
         Presets regarding model quality, e.g., best_quality, high_quality, and medium_quality.
     config
-        A dictionary including four keys: "model", "data", "optimization", and "environment".
+        A dictionary including four keys: "model", "data", "optim", and "env".
         If any key is not given, we will fill in with the default value.
 
         The value of each key can be a string, yaml path, or DictConfig object. For example:
         config = {
                         "model": "default",
                         "data": "default",
-                        "optimization": "default",
-                        "environment": "default",
+                        "optim": "default",
+                        "env": "default",
                     }
             or
             config = {
                         "model": "/path/to/model/config.yaml",
                         "data": "/path/to/data/config.yaml",
-                        "optimization": "/path/to/optimization/config.yaml",
-                        "environment": "/path/to/environment/config.yaml",
+                        "optim": "/path/to/optim/config.yaml",
+                        "env": "/path/to/env/config.yaml",
                     }
             or
             config = {
                         "model": OmegaConf.load("/path/to/model/config.yaml"),
                         "data": OmegaConf.load("/path/to/data/config.yaml"),
-                        "optimization": OmegaConf.load("/path/to/optimization/config.yaml"),
-                        "environment": OmegaConf.load("/path/to/environment/config.yaml"),
+                        "optim": OmegaConf.load("/path/to/optim/config.yaml"),
+                        "env": OmegaConf.load("/path/to/env/config.yaml"),
                     }
     overrides
         This is to override some default configurations.
@@ -185,7 +174,7 @@ def get_config(
         if presets is None:
             preset_overrides = None
         else:
-            preset_overrides, _ = get_automm_presets(problem_type=problem_type, presets=presets)
+            preset_overrides, _ = get_presets(problem_type=problem_type, presets=presets)
 
         config = get_default_config(config, extra=extra)
         # apply the preset's overrides
@@ -404,33 +393,6 @@ def get_local_pretrained_config_paths(config: DictConfig, path: str) -> DictConf
     return config
 
 
-def upgrade_config(config, loaded_version):
-    """Upgrade outdated configurations
-
-    Parameters
-    ----------
-    config
-        The configuration
-    loaded_version
-        The version of the config that has been loaded
-
-    Returns
-    -------
-    config
-        The upgraded configuration
-    """
-    # backward compatibility for variable image size.
-    if version.parse(loaded_version) <= version.parse("0.6.2"):
-        logger.info(f"Start to upgrade the previous configuration trained by AutoMM version={loaded_version}.")
-        if OmegaConf.select(config, "model.timm_image") is not None:
-            logger.warning(
-                "Loading a model that has been trained via AutoGluon Multimodal<=0.6.2. "
-                "Setting config.model.timm_image.image_size = None."
-            )
-            config.model.timm_image.image_size = None
-    return config
-
-
 def parse_dotlist_conf(conf):
     """
     Parse the config files that is potentially in the dotlist format to a dictionary.
@@ -499,6 +461,7 @@ def apply_omegaconf_overrides(
         The updated configuration.
     """
     overrides = parse_dotlist_conf(overrides)
+    overrides = make_overrides_backward_compatible(overrides)
 
     def _check_exist_dotlist(C, key_in_dotlist):
         if not isinstance(key_in_dotlist, list):
@@ -519,10 +482,34 @@ def apply_omegaconf_overrides(
                     f"overrides={overrides}"
                 )
     override_conf = OmegaConf.from_dotlist([f"{ele[0]}={ele[1]}" for ele in overrides.items()])
+    replace_none_str(override_conf)
     conf = OmegaConf.merge(conf, override_conf)
     return conf
 
 
+def replace_none_str(config: Union[DictConfig, ListConfig, dict, list]):
+    """
+    In-place replace "None" and "none" strings in the config with None.
+
+    Parameters
+    ----------
+    config
+        A config of type DictConfig, ListConfig, dict, or list.
+    """
+    if isinstance(config, (dict, DictConfig)):
+        for key, value in config.items():
+            if isinstance(value, str) and value.lower() == "none":
+                config[key] = None
+            elif isinstance(value, (dict, list, DictConfig, ListConfig)):
+                replace_none_str(value)
+    elif isinstance(config, (list, ListConfig)):
+        for i, value in enumerate(config):
+            if isinstance(value, str) and value.lower() == "none":
+                config[i] = None
+            elif isinstance(value, (dict, list, DictConfig, ListConfig)):
+                replace_none_str(value)
+
+
 def update_config_by_rules(
     problem_type: str,
     config: DictConfig,
@@ -542,11 +529,11 @@ def update_config_by_rules(
     -------
     The modified config.
     """
-    loss_func = OmegaConf.select(config, "optimization.loss_function")
+    loss_func = config.optim.loss_func
     if loss_func is not None:
         if problem_type == REGRESSION and "bce" in loss_func.lower():
             # To use BCELoss for regression problems, need to first scale the labels.
-            config.data.label.numerical_label_preprocessing = "minmaxscaler"
+            config.data.label.numerical_preprocessing = "minmaxscaler"
 
     return config
 
@@ -658,7 +645,7 @@ def update_hyperparameters(
     -------
     The updated hyperparameters and hyperparameter_tune_kwargs.
     """
-    hyperparameters, hyperparameter_tune_kwargs = get_automm_presets(problem_type=problem_type, presets=presets)
+    hyperparameters, hyperparameter_tune_kwargs = get_presets(problem_type=problem_type, presets=presets)
 
     if hyperparameter_tune_kwargs and provided_hyperparameter_tune_kwargs:
         hyperparameter_tune_kwargs.update(provided_hyperparameter_tune_kwargs)
@@ -732,6 +719,8 @@ def filter_hyperparameters(
         # Filter models whose data types are not detected.
         # Avoid sampling unused checkpoints, e.g., hf_text models for image classification, to run jobs,
         # which wastes resources and time.
+        from ..data.utils import get_detected_data_types
+
         detected_data_types = get_detected_data_types(column_types)
         selected_model_names = []
         for model_name in hyperparameters[model_names_key]:
@@ -796,3 +785,86 @@ def split_hyperparameters(hyperparameters: Dict):
                 raise ValueError(f"transform_types {v} contain neither all strings nor all callable objects.")
 
     return hyperparameters, advanced_hyperparameters
+
+
+def update_ensemble_hyperparameters(
+    presets,
+    provided_hyperparameters,
+):
+    presets_hyperparameters, _ = get_ensemble_presets(presets=presets)
+    if provided_hyperparameters:
+        learner_names = provided_hyperparameters.pop("learner_names", None)
+        if learner_names:
+            assert isinstance(
+                learner_names, list
+            ), f"learner_names should be a list, but got type {type(learner_names)}"
+            presets_hyperparameters = {k: v for k, v in presets_hyperparameters.items() if k in learner_names}
+            provided_hyperparameters = {k: v for k, v in provided_hyperparameters.items() if k in learner_names}
+
+        hyperparameters = copy.deepcopy(provided_hyperparameters)
+        for k, v in presets_hyperparameters.items():
+            if k not in hyperparameters:
+                hyperparameters[k] = v
+            else:
+                for kk, vv in presets_hyperparameters[k].items():
+                    if kk not in hyperparameters[k]:  # don't use presets to overwrite user-provided
+                        hyperparameters[k][kk] = vv
+    else:
+        hyperparameters = presets_hyperparameters
+
+    return hyperparameters
+
+
+def make_overrides_backward_compatible(overrides: Dict):
+    """
+    Some config keys were changed in PR https://github.com/autogluon/autogluon/pull/4737
+    This function is to make the changes backward compatible.
+
+    Parameters
+    ----------
+    overrides
+        A dictionary containing the user-provided hyperparameters,
+        which may contain old config keys.
+
+    Returns
+    -------
+    Overrides with up-to-date config keys.
+    """
+    key_pairs = {
+        "optim.learning_rate": "optim.lr",
+        "optim.efficient_finetune": "optim.peft",
+        "optim.loss_function": "optim.loss_func",
+        "env.num_workers_evaluation": "env.num_workers_inference",
+        "env.eval_batch_size_ratio": "env.inference_batch_size_ratio",
+        "data.label.numerical_label_preprocessing": "data.label.numerical_preprocessing",
+        "model.categorical_mlp.drop_rate": "model.categorical_mlp.dropout",
+        "model.numerical_mlp.drop_rate": "model.numerical_mlp.dropout",
+        "model.numerical_mlp.d_token": "model.numerical_mlp.token_dim",
+        "model.timm_image.max_img_num_per_col": "model.timm_image.max_image_num_per_column",
+        "model.clip.max_img_num_per_col": "model.clip.max_image_num_per_column",
+        "model.clip_image.max_img_num_per_col": "model.clip_image.max_image_num_per_column",
+        "model.fusion_mlp.weight": "model.fusion_mlp.aux_loss_weight",
+        "model.fusion_mlp.drop_rate": "model.fusion_mlp.dropout",
+        "model.fusion_transformer.n_blocks": "model.fusion_transformer.num_blocks",
+        "model.fusion_transformer.attention_n_heads": "model.fusion_transformer.attention_num_heads",
+        "model.fusion_transformer.ffn_d_hidden": "model.fusion_transformer.ffn_hidden_size",
+        "model.ft_transformer.attention_n_heads": "model.ft_transformer.attention_num_heads",
+    }
+    for k in list(overrides.keys()):
+        provided_k = k
+        if k.startswith("optimization."):
+            k = "optim." + k[len("optimization.") :]
+            logger.warning(
+                f"The provided hyperparameter name {provided_k} contains a deprecated key `optimization.`. "
+                f"Please replace `optimization.` with `optim.` when customizing the optimization hyperparameters."
+            )
+
+        if k in key_pairs:
+            overrides[key_pairs[k]] = overrides.pop(provided_k)
+            logger.warning(
+                f"The hyperparameter name {provided_k} is depreciated. "
+                f"We recommend using the new name {key_pairs[k]} instead."
+                f"The deprecated hyperparameter will raise an exception starting in AutoGluon 1.4.0"
+            )
+
+    return overrides