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

autogluon/multimodal/utils/precision.py

@@ -0,0 +1,130 @@
+import contextlib
+import logging
+import warnings
+from typing import Dict, List, Optional, Tuple, Union
+
+import torch
+
+logger = logging.getLogger(__name__)
+
+
+def convert_to_torch_precision(precision: Union[int, str]):
+    """
+    Convert a precision integer or string to the corresponding torch precision.
+
+    Parameters
+    ----------
+    precision
+    a precision integer or string from the config.
+
+    Returns
+    -------
+    A torch precision object.
+    """
+    precision_mapping = {
+        16: torch.half,
+        "16": torch.half,
+        "16-mixed": torch.half,
+        "16-true": torch.half,
+        "bf16": torch.bfloat16,
+        "bf16-mixed": torch.bfloat16,
+        "bf16-true": torch.bfloat16,
+        32: torch.float32,
+        "32": torch.float32,
+        "32-true": torch.float32,
+        64: torch.float64,
+        "64": torch.float64,
+        "64-true": torch.float64,
+    }
+
+    if precision in precision_mapping:
+        precision = precision_mapping[precision]
+    else:
+        raise ValueError(f"Unknown precision: {precision}")
+
+    return precision
+
+
+def infer_precision(
+    num_gpus: int, precision: Union[int, str], as_torch: Optional[bool] = False, cpu_only_warning: bool = True
+):
+    """
+    Infer the proper precision based on the environment setup and the provided precision.
+
+    Parameters
+    ----------
+    num_gpus
+        GPU number.
+    precision
+        The precision provided in config.
+    as_torch
+        Whether to convert the precision to the Pytorch format.
+    cpu_only_warning
+        Whether to turn on warning if the instance has only CPU.
+
+    Returns
+    -------
+    The inferred precision.
+    """
+    if num_gpus == 0:  # CPU only prediction
+        if cpu_only_warning:
+            warnings.warn(
+                "Only CPU is detected in the instance. "
+                "This may result in slow speed for MultiModalPredictor. "
+                "Consider using an instance with GPU support.",
+                UserWarning,
+            )
+        precision = 32  # Force to use fp32 for training since 16-mixed is not available in CPU
+    else:
+        if isinstance(precision, str) and "bf16" in precision and not torch.cuda.is_bf16_supported():
+            warnings.warn(
+                f"{precision} is not supported by the GPU device / cuda version. "
+                "Consider using GPU devices with versions after Amphere or upgrading cuda to be >=11.0. "
+                f"MultiModalPredictor is switching precision from {precision} to 32.",
+                UserWarning,
+            )
+            precision = 32
+
+    if as_torch:
+        precision = convert_to_torch_precision(precision=precision)
+
+    return precision
+
+
+@contextlib.contextmanager
+def double_precision_context():
+    """
+    Double precision context manager.
+    """
+    default_dtype = torch.get_default_dtype()
+    torch.set_default_dtype(torch.float64)
+    yield
+    torch.set_default_dtype(default_dtype)
+
+
+def get_precision_context(precision: Union[int, str], device_type: Optional[str] = None):
+    """
+    Choose the proper context manager based on the precision.
+
+    Parameters
+    ----------
+    precision
+        The precision.
+    device_type
+        gpu or cpu.
+
+    Returns
+    -------
+    A precision context manager.
+    """
+    precision = convert_to_torch_precision(precision=precision)
+
+    if precision in [torch.half, torch.float16, torch.bfloat16]:
+        return torch.autocast(device_type=device_type, dtype=precision)
+    if precision == torch.float32:
+        assert torch.get_default_dtype() == torch.float32
+        return contextlib.nullcontext()
+    elif precision == torch.float64:
+        return double_precision_context()
+    else:
+        raise ValueError(f"Unknown precision: {precision}")

autogluon/multimodal/{presets.py → utils/presets.py}

@@ -2,17 +2,17 @@ from typing import List, Optional
 
 from autogluon.common.utils.try_import import try_import_ray
 
-from .constants import (
+from ..constants import (
     BEST_QUALITY,
     BINARY,
     DATA,
     DEFAULT,
-    ENVIRONMENT,
+    ENV,
     HIGH_QUALITY,
     MEDIUM_QUALITY,
     MODEL,
     MULTICLASS,
-    OPTIMIZATION,
+    OPTIM,
     REGRESSION,
 )
 from .registry import Registry
@@ -32,9 +32,9 @@ def get_default_hpo_setup():
     }
 
     default_tunable_hyperparameters = {
-        "optimization.learning_rate": tune.loguniform(1e-5, 1e-2),
-        "optimization.optim_type": tune.choice(["adamw", "sgd"]),
-        "optimization.max_epochs": tune.choice(list(range(5, 31))),
+        "optim.lr": tune.loguniform(1e-5, 1e-2),
+        "optim.optim_type": tune.choice(["adamw", "sgd"]),
+        "optim.max_epochs": tune.choice(list(range(5, 31))),
         "env.batch_size": tune.choice([16, 32, 64, 128, 256]),
     }
 
@@ -146,7 +146,7 @@ def default(presets: str = DEFAULT):
                     "model.hf_text.checkpoint_name": "google/electra-small-discriminator",
                     "model.timm_image.checkpoint_name": "mobilenetv3_large_100",
                     "model.document_transformer.checkpoint_name": "microsoft/layoutlmv2-base-uncased",
-                    "optimization.learning_rate": 4e-4,
+                    "optim.lr": 4e-4,
                 }
             )
     elif presets == BEST_QUALITY:
@@ -186,7 +186,7 @@ def default(presets: str = DEFAULT):
         hyperparameters.update(
             {
                 "model.hf_text.checkpoint_name": "microsoft/mdeberta-v3-base",
-                "optimization.top_k": 1,
+                "optim.top_k": 1,
                 "env.precision": "bf16-mixed",
                 "env.per_gpu_batch_size": 4,
             }
@@ -222,7 +222,7 @@ def few_shot_classification(presets: str = DEFAULT):
             "model.names": ["hf_text", "clip"],
             "model.clip.checkpoint_name": "openai/clip-vit-large-patch14-336",
             "model.clip.image_size": 336,
-            "env.eval_batch_size_ratio": 1,
+            "env.inference_batch_size_ratio": 1,
         }
     )
     hyperparameter_tune_kwargs = {}
@@ -258,14 +258,14 @@ def zero_shot_image_classification(presets: str = DEFAULT):
             {
                 "model.clip.checkpoint_name": "openai/clip-vit-large-patch14-336",
                 "model.clip.image_size": 336,
-                "env.eval_batch_size_ratio": 1,
+                "env.inference_batch_size_ratio": 1,
             }
         )
     elif presets == HIGH_QUALITY:
         hyperparameters.update(
             {
                 "model.clip.checkpoint_name": "openai/clip-vit-large-patch14",
-                "env.eval_batch_size_ratio": 1,
+                "env.inference_batch_size_ratio": 1,
             }
         )
     elif presets == MEDIUM_QUALITY:
@@ -300,27 +300,27 @@ def object_detection(presets: str = DEFAULT):
     hyperparameters = {
         "model.names": ["mmdet_image"],
         "model.mmdet_image.frozen_layers": [],
-        "optimization.patience": 20,
-        "optimization.val_check_interval": 1.0,
-        "optimization.check_val_every_n_epoch": 1,
+        "optim.patience": 20,
+        "optim.val_check_interval": 1.0,
+        "optim.check_val_every_n_epoch": 1,
         "env.batch_size": 32,
         "env.per_gpu_batch_size": 1,
         "env.num_workers": 2,
-        "optimization.learning_rate": 1e-5,
-        "optimization.weight_decay": 1e-4,
-        "optimization.lr_mult": 10,
-        "optimization.lr_choice": "two_stages",
-        "optimization.lr_schedule": "multi_step",
-        "optimization.gradient_clip_val": 0.1,
-        "optimization.max_epochs": 60,
-        "optimization.warmup_steps": 0.0,
-        "optimization.top_k": 1,
-        "optimization.top_k_average_method": "best",
-        "env.eval_batch_size_ratio": 1,
+        "optim.lr": 1e-5,
+        "optim.weight_decay": 1e-4,
+        "optim.lr_mult": 10,
+        "optim.lr_choice": "two_stages",
+        "optim.lr_schedule": "multi_step",
+        "optim.gradient_clip_val": 0.1,
+        "optim.max_epochs": 60,
+        "optim.warmup_steps": 0.0,
+        "optim.top_k": 1,
+        "optim.top_k_average_method": "best",
+        "env.inference_batch_size_ratio": 1,
         "env.strategy": "ddp",
         "env.auto_select_gpus": True,  # Turn on for detection to return devices in a list, TODO: fix the extra GPU usage bug
         "env.num_gpus": -1,
-        "optimization.lr_decay": 0.9,
+        "optim.lr_decay": 0.9,
     }
     hyperparameter_tune_kwargs = {}
 
@@ -335,15 +335,15 @@ def object_detection(presets: str = DEFAULT):
             {
                 "model.mmdet_image.checkpoint_name": "yolox_l",
                 "env.per_gpu_batch_size": 2,  # Works on 8G GPU
-                "optimization.learning_rate": 5e-5,
-                "optimization.patience": 5,
-                "optimization.max_epochs": 50,
-                "optimization.val_check_interval": 1.0,
-                "optimization.check_val_every_n_epoch": 3,
-                "optimization.lr_mult": 100,
-                "optimization.weight_decay": 1e-3,
-                "optimization.lr_schedule": "cosine_decay",
-                "optimization.gradient_clip_val": 1,
+                "optim.lr": 5e-5,
+                "optim.patience": 5,
+                "optim.max_epochs": 50,
+                "optim.val_check_interval": 1.0,
+                "optim.check_val_every_n_epoch": 3,
+                "optim.lr_mult": 100,
+                "optim.weight_decay": 1e-3,
+                "optim.lr_schedule": "cosine_decay",
+                "optim.gradient_clip_val": 1,
             }
         )
     elif presets in [DEFAULT, HIGH_QUALITY]:
@@ -386,32 +386,32 @@ def semantic_segmentation(presets: str = DEFAULT):
         "model.sam.checkpoint_name": "facebook/sam-vit-huge",
         "env.batch_size": 4,
         "env.per_gpu_batch_size": 1,
-        "env.eval_batch_size_ratio": 1,
+        "env.inference_batch_size_ratio": 1,
         "env.strategy": "ddp_find_unused_parameters_true",
         "env.auto_select_gpus": False,
         "env.num_gpus": -1,
         "env.num_workers": 4,
         "env.precision": "16-mixed",
-        "optimization.learning_rate": 1e-4,
-        "optimization.loss_function": "structure_loss",
-        "optimization.lr_decay": 0,
-        "optimization.lr_mult": 1,
-        "optimization.lr_choice": "single_stage",
-        "optimization.lr_schedule": "polynomial_decay",
-        "optimization.max_epochs": 30,
-        "optimization.top_k": 3,
-        "optimization.top_k_average_method": "best",
-        "optimization.warmup_steps": 0.0,
-        "optimization.weight_decay": 0.0001,
-        "optimization.patience": 10,
-        "optimization.val_check_interval": 1.0,
-        "optimization.check_val_every_n_epoch": 1,
-        "optimization.efficient_finetune": "lora",
-        "optimization.lora.module_filter": [".*vision_encoder.*attn"],
-        "optimization.lora.filter": ["q", "v"],
-        "optimization.extra_trainable_params": [".*mask_decoder"],
-        "optimization.lora.r": 3,
-        "optimization.lora.alpha": 32,
+        "optim.lr": 1e-4,
+        "optim.loss_func": "structure_loss",
+        "optim.lr_decay": 0,
+        "optim.lr_mult": 1,
+        "optim.lr_choice": "single_stage",
+        "optim.lr_schedule": "polynomial_decay",
+        "optim.max_epochs": 30,
+        "optim.top_k": 3,
+        "optim.top_k_average_method": "best",
+        "optim.warmup_steps": 0.0,
+        "optim.weight_decay": 0.0001,
+        "optim.patience": 10,
+        "optim.val_check_interval": 1.0,
+        "optim.check_val_every_n_epoch": 1,
+        "optim.peft": "lora",
+        "optim.lora.module_filter": [".*vision_encoder.*attn"],
+        "optim.lora.filter": ["q", "v"],
+        "optim.extra_trainable_params": [".*mask_decoder"],
+        "optim.lora.r": 3,
+        "optim.lora.alpha": 32,
     }
     hyperparameter_tune_kwargs = {}
 
@@ -444,7 +444,7 @@ def ocr_text_detection(presets: str = DEFAULT):
     hyperparameters = {
         "model.names": ["mmocr_text_detection"],
         "model.mmocr_text_detection.checkpoint_name": "TextSnake",
-        "env.eval_batch_size_ratio": 1,
+        "env.inference_batch_size_ratio": 1,
         "env.num_gpus": 1,
         "env.precision": 32,
     }
@@ -479,7 +479,7 @@ def ocr_text_recognition(presets: str = DEFAULT):
     hyperparameters = {
         "model.names": ["mmocr_text_recognition"],
         "model.mmocr_text_recognition.checkpoint_name": "ABINet",
-        "env.eval_batch_size_ratio": 1,
+        "env.inference_batch_size_ratio": 1,
         "env.num_gpus": 1,
         "env.precision": 32,
     }
@@ -514,7 +514,7 @@ def feature_extraction(presets: str = DEFAULT):  # TODO: rename the problem type
         "model.names": ["hf_text"],
         "model.hf_text.checkpoint_name": "sentence-transformers/msmarco-MiniLM-L-12-v3",
         "model.hf_text.pooling_mode": "mean",
-        "env.eval_batch_size_ratio": 1,
+        "env.inference_batch_size_ratio": 1,
     }
     hyperparameter_tune_kwargs = {}
 
@@ -651,7 +651,7 @@ def image_text_similarity(presets: str = DEFAULT):
     hyperparameters = {
         "model.names": ["clip"],
         "matcher.loss.type": "multi_negatives_softmax_loss",
-        "optimization.learning_rate": 1e-5,
+        "optim.lr": 1e-5,
     }
     hyperparameter_tune_kwargs = {}
 
@@ -747,9 +747,196 @@ def ner(presets: str = DEFAULT):
     return hyperparameters, hyperparameter_tune_kwargs
 
 
-def list_automm_presets(verbose: bool = False):
+@automm_presets.register()
+def ensemble(presets: str = DEFAULT):
+    hyperparameters = {
+        "lf_mlp": {
+            "model.names": ["ft_transformer", "timm_image", "hf_text", "fusion_mlp"],
+            "model.timm_image.train_transforms": ["resize_shorter_side", "center_crop"],
+            "model.hf_text.text_trivial_aug_maxscale": 0,
+            "data.categorical.convert_to_text": False,
+            "data.numerical.convert_to_text": False,
+            "optim.cross_modal_align": "null",
+            "data.modality_dropout": 0,
+            "model.timm_image.use_learnable_image": False,
+            "optim.lemda.turn_on": False,
+        },
+        "lf_transformer": {
+            "model.names": ["ft_transformer", "timm_image", "hf_text", "fusion_transformer"],
+            "model.timm_image.train_transforms": ["resize_shorter_side", "center_crop"],
+            "model.hf_text.text_trivial_aug_maxscale": 0,
+            "data.categorical.convert_to_text": False,
+            "data.numerical.convert_to_text": False,
+            "optim.cross_modal_align": "null",
+            "data.modality_dropout": 0,
+            "model.timm_image.use_learnable_image": False,
+            "optim.lemda.turn_on": False,
+        },
+        "lf_clip": {
+            "model.names": ["ft_transformer", "clip_image", "clip_text", "fusion_mlp"],
+            "model.clip_image.data_types": ["image"],
+            "model.clip_text.data_types": ["text"],
+            "model.clip_image.train_transforms": ["resize_shorter_side", "center_crop"],
+            "model.clip_text.text_trivial_aug_maxscale": 0,
+            "data.categorical.convert_to_text": False,
+            "data.numerical.convert_to_text": False,
+            "optim.cross_modal_align": "null",
+            "data.modality_dropout": 0,
+            "model.clip_image.use_learnable_image": False,
+            "optim.lemda.turn_on": False,
+        },
+        "early_fusion": {
+            "model.names": ["meta_transformer"],
+            "model.meta_transformer.checkpoint_path": "null",
+            "model.meta_transformer.train_transforms": ["resize_shorter_side", "center_crop"],
+            "model.meta_transformer.text_trivial_aug_maxscale": 0,
+            "data.categorical.convert_to_text": False,
+            "data.numerical.convert_to_text": False,
+            "optim.cross_modal_align": "null",
+            "data.modality_dropout": 0,
+            "model.meta_transformer.use_learnable_image": False,
+            "optim.lemda.turn_on": False,
+        },
+        "convert_categorical_to_text": {
+            "model.names": ["ft_transformer", "timm_image", "hf_text", "fusion_mlp"],
+            "model.timm_image.train_transforms": ["resize_shorter_side", "center_crop"],
+            "model.hf_text.text_trivial_aug_maxscale": 0,
+            "data.categorical.convert_to_text": True,
+            "data.categorical.convert_to_text_template": "latex",
+            "data.numerical.convert_to_text": False,
+            "optim.cross_modal_align": "null",
+            "data.modality_dropout": 0,
+            "model.timm_image.use_learnable_image": False,
+            "optim.lemda.turn_on": False,
+        },
+        "convert_numeric_to_text": {
+            "model.names": ["ft_transformer", "timm_image", "hf_text", "fusion_mlp"],
+            "model.timm_image.train_transforms": ["resize_shorter_side", "center_crop"],
+            "model.hf_text.text_trivial_aug_maxscale": 0,
+            "data.categorical.convert_to_text": False,
+            "data.numerical.convert_to_text": True,
+            "optim.cross_modal_align": "null",
+            "data.modality_dropout": 0,
+            "model.timm_image.use_learnable_image": False,
+            "optim.lemda.turn_on": False,
+        },
+        "cross_modal_align_pos_only": {
+            "model.names": ["ft_transformer", "timm_image", "hf_text", "fusion_mlp"],
+            "model.timm_image.train_transforms": ["resize_shorter_side", "center_crop"],
+            "model.hf_text.text_trivial_aug_maxscale": 0,
+            "data.categorical.convert_to_text": False,
+            "data.numerical.convert_to_text": False,
+            "optim.cross_modal_align": "positive_only",
+            "optim.cross_modal_align_weight": 1,
+            "data.modality_dropout": 0,
+            "model.timm_image.use_learnable_image": False,
+            "optim.lemda.turn_on": False,
+        },
+        "input_aug": {
+            "model.names": ["ft_transformer", "timm_image", "hf_text", "fusion_mlp"],
+            "model.timm_image.train_transforms": ["resize_shorter_side", "center_crop", "trivial_augment"],
+            "model.hf_text.text_trivial_aug_maxscale": 0.1,
+            "data.categorical.convert_to_text": False,
+            "data.numerical.convert_to_text": False,
+            "optim.cross_modal_align": "null",
+            "data.modality_dropout": 0,
+            "model.timm_image.use_learnable_image": False,
+            "optim.lemda.turn_on": False,
+        },
+        "feature_aug_lemda": {
+            "model.names": ["ft_transformer", "timm_image", "hf_text", "fusion_mlp"],
+            "model.timm_image.train_transforms": ["resize_shorter_side", "center_crop"],
+            "model.hf_text.text_trivial_aug_maxscale": 0,
+            "data.categorical.convert_to_text": False,
+            "data.numerical.convert_to_text": False,
+            "optim.cross_modal_align": "null",
+            "data.modality_dropout": 0,
+            "model.timm_image.use_learnable_image": False,
+            "optim.lemda.turn_on": True,
+            "optim.automatic_optimization": False,
+        },
+        "modality_dropout": {
+            "model.names": ["ft_transformer", "timm_image", "hf_text", "fusion_mlp"],
+            "model.timm_image.train_transforms": ["resize_shorter_side", "center_crop"],
+            "model.hf_text.text_trivial_aug_maxscale": 0,
+            "data.categorical.convert_to_text": False,
+            "data.numerical.convert_to_text": False,
+            "optim.cross_modal_align": "null",
+            "data.modality_dropout": 0.2,
+            "model.timm_image.use_learnable_image": False,
+            "optim.lemda.turn_on": False,
+        },
+        "learnable_image": {
+            "model.names": ["ft_transformer", "timm_image", "hf_text", "fusion_mlp"],
+            "model.timm_image.train_transforms": ["resize_shorter_side", "center_crop"],
+            "model.hf_text.text_trivial_aug_maxscale": 0,
+            "data.categorical.convert_to_text": False,
+            "data.numerical.convert_to_text": False,
+            "optim.cross_modal_align": "null",
+            "data.modality_dropout": 0,
+            "model.timm_image.use_learnable_image": True,
+            "optim.lemda.turn_on": False,
+        },
+        "modality_dropout_and_learnable_image": {
+            "model.names": ["ft_transformer", "timm_image", "hf_text", "fusion_mlp"],
+            "model.timm_image.train_transforms": ["resize_shorter_side", "center_crop"],
+            "model.hf_text.text_trivial_aug_maxscale": 0,
+            "data.categorical.convert_to_text": False,
+            "data.numerical.convert_to_text": False,
+            "optim.cross_modal_align": "null",
+            "data.modality_dropout": 0.2,
+            "model.timm_image.use_learnable_image": True,
+            "optim.lemda.turn_on": False,
+        },
+    }
+
+    if presets in [DEFAULT, HIGH_QUALITY]:
+        for v in hyperparameters.values():
+            if "timm_image" in v["model.names"]:
+                v["model.timm_image.checkpoint_name"] = "caformer_b36.sail_in22k_ft_in1k"
+            if "hf_text" in v["model.names"]:
+                v["model.hf_text.checkpoint_name"] = "google/electra-base-discriminator"
+            if "meta_transformer" in v["model.names"]:
+                v["model.meta_transformer.model_version"] = "base"
+            if "clip_image" in v["model.names"]:
+                v["model.clip_image.checkpoint_name"] = "openai/clip-vit-base-patch32"
+            if "clip_text" in v["model.names"]:
+                v["model.clip_text.checkpoint_name"] = "openai/clip-vit-base-patch32"
+
+    elif presets == MEDIUM_QUALITY:
+        for v in hyperparameters.values():
+            if "timm_image" in v["model.names"]:
+                v["model.timm_image.checkpoint_name"] = "mobilenetv3_large_100"
+            if "hf_text" in v["model.names"]:
+                v["model.hf_text.checkpoint_name"] = "google/electra-small-discriminator"
+            if "meta_transformer" in v["model.names"]:
+                v["model.meta_transformer.model_version"] = "base"
+            if "clip_image" in v["model.names"]:
+                v["model.clip_image.checkpoint_name"] = "openai/clip-vit-base-patch32"
+            if "clip_text" in v["model.names"]:
+                v["model.clip_text.checkpoint_name"] = "openai/clip-vit-base-patch32"
+    elif presets == BEST_QUALITY:
+        for v in hyperparameters.values():
+            if "timm_image" in v["model.names"]:
+                v["model.timm_image.checkpoint_name"] = "swin_large_patch4_window7_224"
+            if "hf_text" in v["model.names"]:
+                v["model.hf_text.checkpoint_name"] = "microsoft/deberta-v3-base"
+            if "meta_transformer" in v["model.names"]:
+                v["model.meta_transformer.model_version"] = "large"
+            if "clip_image" in v["model.names"]:
+                v["model.clip_image.checkpoint_name"] = "openai/clip-vit-large-patch14"
+            if "clip_text" in v["model.names"]:
+                v["model.clip_text.checkpoint_name"] = "openai/clip-vit-large-patch14"
+    else:
+        raise ValueError(f"Unknown preset type: {presets}")
+
+    return hyperparameters, None
+
+
+def list_presets(verbose: bool = False):
     """
     List all available presets.
+
     Returns
     -------
     A list of presets.
@@ -765,7 +952,7 @@ def list_automm_presets(verbose: bool = False):
     return preset_details
 
 
-def get_basic_automm_config(extra: Optional[List[str]] = None):
+def get_basic_config(extra: Optional[List[str]] = None):
     """
     Get the basic config of AutoMM.
 
@@ -776,13 +963,13 @@ def get_basic_automm_config(extra: Optional[List[str]] = None):
 
     Returns
     -------
-    A dict config with keys: MODEL, DATA, OPTIMIZATION, ENVIRONMENT, and their default values.
+    A dict config with keys: MODEL, DATA, OPTIM, ENV, and their default values.
     """
     config = {
         MODEL: DEFAULT,
         DATA: DEFAULT,
-        OPTIMIZATION: DEFAULT,
-        ENVIRONMENT: DEFAULT,
+        OPTIM: DEFAULT,
+        ENV: DEFAULT,
     }
     if extra:
         for k in extra:
@@ -791,7 +978,7 @@ def get_basic_automm_config(extra: Optional[List[str]] = None):
     return config
 
 
-def get_automm_presets(problem_type: str, presets: str):
+def get_presets(problem_type: str, presets: str):
     """
     Get the default hyperparameters and hyperparameter_tune_kwargs given problem type and presets.
 
@@ -831,3 +1018,9 @@ def get_automm_presets(problem_type: str, presets: str):
         )
 
     return hyperparameters, hyperparameter_tune_kwargs
+
+
+def get_ensemble_presets(presets):
+    if not presets:
+        presets = DEFAULT
+    return automm_presets.create("ensemble", presets)

autogluon/multimodal/{problem_types.py → utils/problem_types.py}

@@ -1,9 +1,10 @@
 """Problem types supported in MultiModalPredictor"""
 
+import logging
 from dataclasses import dataclass, field
 from typing import List, Optional, Set
 
-from .constants import (
+from ..constants import (
     ACCURACY,
     BINARY,
     CATEGORICAL,
@@ -38,6 +39,8 @@ from .constants import (
 )
 from .registry import Registry
 
+logger = logging.getLogger(__name__)
+
 PROBLEM_TYPES_REG = Registry("problem_type_properties")
 
 
@@ -277,3 +280,29 @@ PROBLEM_TYPES_REG.register(
         _fallback_validation_metric=ACCURACY,
     ),
 )
+
+
+def infer_problem_type_by_eval_metric(eval_metric_name: str, problem_type: str):
+    if eval_metric_name is not None and eval_metric_name.lower() in [
+        "rmse",
+        "r2",
+        "pearsonr",
+        "spearmanr",
+    ]:
+        if problem_type is None:
+            logger.debug(
+                f"Infer problem type to be a regression problem "
+                f"since the evaluation metric is set as {eval_metric_name}."
+            )
+            problem_type = REGRESSION
+        else:
+            problem_prop = PROBLEM_TYPES_REG.get(problem_type)
+            if NUMERICAL not in problem_prop.supported_label_type:
+                raise ValueError(
+                    f"The provided evaluation metric will require the problem "
+                    f"to support label type = {NUMERICAL}. However, "
+                    f"the provided problem type = {problem_type} only "
+                    f"supports label type = {problem_prop.supported_label_type}."
+                )
+
+    return problem_type