autogluon.tabular 1.2.1b20250225__tar.gz → 1.2.1b20250226__tar.gz

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.tabular
-Version: 1.2.1b20250225
+Version: 1.2.1b20250226
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/src/autogluon/tabular/models/automm/automm_model.py

@@ -26,6 +26,8 @@ logger = logging.getLogger(__name__)
 
 
 class MultiModalPredictorModel(AbstractModel):
+    ag_key = "AG_AUTOMM"
+    ag_name = "MultiModalPredictor"
     _NN_MODEL_NAME = "automm_model"
 
     def __init__(self, **kwargs):

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/src/autogluon/tabular/models/automm/ft_transformer.py

@@ -12,6 +12,9 @@ logger = logging.getLogger(__name__)
 
 # TODO: Add unit tests
 class FTTransformerModel(MultiModalPredictorModel):
+    ag_key = "FT_TRANSFORMER"
+    ag_name = "FTTransformer"
+
     def __init__(self, **kwargs):
         """Wrapper of autogluon.multimodal.MultiModalPredictor.
 

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/src/autogluon/tabular/models/catboost/catboost_model.py

@@ -2,6 +2,7 @@ import logging
 import math
 import os
 import time
+from types import MappingProxyType
 
 import numpy as np
 import pandas as pd
@@ -30,6 +31,12 @@ class CatBoostModel(AbstractModel):
 
     Hyperparameter options: https://catboost.ai/en/docs/references/training-parameters
     """
+    ag_key = "CAT"
+    ag_name = "CatBoost"
+    ag_priority = 70
+    ag_priority_by_problem_type = MappingProxyType({
+        SOFTCLASS: 60
+    })
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/src/autogluon/tabular/models/fastainn/tabular_nn_fastai.py

@@ -8,6 +8,7 @@ import warnings
 from builtins import classmethod
 from functools import partial
 from pathlib import Path
+from types import MappingProxyType
 from typing import Union
 
 import numpy as np
@@ -28,7 +29,7 @@ from autogluon.common.features.types import (
 from autogluon.common.utils.pandas_utils import get_approximate_df_mem_usage
 from autogluon.common.utils.resource_utils import ResourceManager
 from autogluon.common.utils.try_import import try_import_fastai
-from autogluon.core.constants import BINARY, QUANTILE, REGRESSION
+from autogluon.core.constants import BINARY, MULTICLASS, QUANTILE, REGRESSION
 from autogluon.core.hpo.constants import RAY_BACKEND
 from autogluon.core.models import AbstractModel
 from autogluon.core.utils.exceptions import TimeLimitExceeded
@@ -92,6 +93,14 @@ class NNFastAiTabularModel(AbstractModel):
         'early.stopping.min_delta': 0.0001,
         'early.stopping.patience': 10,
     """
+    ag_key = "FASTAI"
+    ag_name = "NeuralNetFastAI"
+    ag_priority = 50
+    # Increase priority for multiclass since neural networks
+    # scale better than trees as a function of n_classes.
+    ag_priority_by_problem_type = MappingProxyType({
+        MULTICLASS: 95,
+    })
 
     model_internals_file_name = "model-internals.pkl"
 

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/src/autogluon/tabular/models/fasttext/fasttext_model.py

@@ -21,6 +21,9 @@ logger = logging.getLogger(__name__)
 
 
 class FastTextModel(AbstractModel):
+    ag_key = "FASTTEXT"
+    ag_name = "FastText"
+
     model_bin_file_name = "fasttext.ftz"
 
     def __init__(self, **kwargs):

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/src/autogluon/tabular/models/image_prediction/image_predictor.py

@@ -22,6 +22,8 @@ class ImagePredictorModel(MultiModalPredictorModel):
     Additionally has special null image handling to improve performance in the presence of null images (aka image path of '')
         Note: null handling has not been compared to the built-in null handling of MultimodalPredictor yet.
     """
+    ag_key = "AG_IMAGE_NN"
+    ag_name = "ImagePredictor"
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/src/autogluon/tabular/models/imodels/imodels_models.py

@@ -75,6 +75,9 @@ class _IModelsModel(AbstractModel):
 
 
 class RuleFitModel(_IModelsModel):
+    ag_key = "IM_RULEFIT"
+    ag_name = "RuleFit"
+
     def get_model(self):
         try_import_imodels()
         from imodels import RuleFitClassifier, RuleFitRegressor
@@ -86,6 +89,9 @@ class RuleFitModel(_IModelsModel):
 
 
 class GreedyTreeModel(_IModelsModel):
+    ag_key = "IM_GREEDYTREE"
+    ag_name = "GreedyTree"
+
     def get_model(self):
         try_import_imodels()
         from imodels import GreedyTreeClassifier
@@ -98,6 +104,9 @@ class GreedyTreeModel(_IModelsModel):
 
 
 class BoostedRulesModel(_IModelsModel):
+    ag_key = "IM_BOOSTEDRULES"
+    ag_name = "BoostedRules"
+
     def get_model(self):
         try_import_imodels()
         from imodels import BoostedRulesClassifier
@@ -109,6 +118,9 @@ class BoostedRulesModel(_IModelsModel):
 
 
 class HSTreeModel(_IModelsModel):
+    ag_key = "IM_HSTREE"
+    ag_name = "HierarchicalShrinkageTree"
+
     def get_model(self):
         try_import_imodels()
         from imodels import HSTreeClassifierCV, HSTreeRegressorCV
@@ -120,6 +132,9 @@ class HSTreeModel(_IModelsModel):
 
 
 class FigsModel(_IModelsModel):
+    ag_key = "IM_FIGS"
+    ag_name = "Figs"
+
     def get_model(self):
         try_import_imodels()
         from imodels import FIGSClassifier, FIGSRegressor

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/src/autogluon/tabular/models/knn/knn_model.py

@@ -22,6 +22,9 @@ class KNNModel(AbstractModel):
     """
     KNearestNeighbors model (scikit-learn): https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html
     """
+    ag_key = "KNN"
+    ag_name = "KNeighbors"
+    ag_priority = 100
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/src/autogluon/tabular/models/lgb/lgb_model.py

@@ -7,6 +7,7 @@ import random
 import re
 import time
 import warnings
+from types import MappingProxyType
 
 import numpy as np
 import pandas as pd
@@ -40,6 +41,12 @@ class LGBModel(AbstractModel):
     Extra hyperparameter options:
         ag.early_stop : int, specifies the early stopping rounds. Defaults to an adaptive strategy. Recommended to keep default.
     """
+    ag_key = "GBM"
+    ag_name = "LightGBM"
+    ag_priority = 90
+    ag_priority_by_problem_type = MappingProxyType({
+        SOFTCLASS: 100
+    })
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/src/autogluon/tabular/models/lr/lr_model.py

@@ -38,6 +38,9 @@ class LinearModel(AbstractModel):
 
         'regression': https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Ridge.html#sklearn.linear_model.Ridge
     """
+    ag_key = "LR"
+    ag_name = "LinearModel"
+    ag_priority = 30
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/src/autogluon/tabular/models/rf/rf_model.py

@@ -27,6 +27,9 @@ class RFModel(AbstractModel):
     """
     Random Forest model (scikit-learn): https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html
     """
+    ag_key = "RF"
+    ag_name = "RandomForest"
+    ag_priority = 80
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/src/autogluon/tabular/models/tab_transformer/tab_transformer_model.py

@@ -40,6 +40,8 @@ class TabTransformerModel(AbstractNeuralNetworkModel):
     and applies them to the use case of tabular data. Specifically, this makes TabTransformer suitable for unsupervised
     training of Tabular data with a subsequent fine-tuning step on labeled data.
     """
+    ag_key = "TRANSF"
+    ag_name = "Transformer"
 
     params_file_name = "tab_trans_params.pth"
 

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/src/autogluon/tabular/models/tabpfn/tabpfn_model.py

@@ -22,6 +22,9 @@ class TabPFNModel(AbstractModel):
     To use this model, `tabpfn` must be installed.
     To install TabPFN, you can run `pip install autogluon.tabular[tabpfn]` or `pip install tabpfn`.
     """
+    ag_key = "TABPFN"
+    ag_name = "TabPFN"
+    ag_priority = 110
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/src/autogluon/tabular/models/tabpfnmix/tabpfnmix_model.py

@@ -35,6 +35,10 @@ class TabPFNMixModel(AbstractModel):
 
     For more information, refer to the `./_internals/README.md` file.
     """
+    ag_key = "TABPFNMIX"
+    ag_name = "TabPFNMix"
+    ag_priority = 45
+
     weights_file_name = "model.pt"
 
     def __init__(self, **kwargs):

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/src/autogluon/tabular/models/tabular_nn/torch/tabular_nn_torch.py

@@ -47,6 +47,9 @@ class TabularNeuralNetTorchModel(AbstractNeuralNetworkModel):
         ag.early_stop : int | str, default = "default"
             Specifies the early stopping rounds. Defaults to an adaptive strategy. Recommended to keep default.
     """
+    ag_key = "NN_TORCH"
+    ag_name = "NeuralNetTorch"
+    ag_priority = 25
 
     # Constants used throughout this class:
     unique_category_str = np.nan  # string used to represent missing values and unknown categories for categorical features.

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/src/autogluon/tabular/models/text_prediction/text_prediction_v1_model.py

@@ -19,6 +19,9 @@ logger = logging.getLogger(__name__)
 class TextPredictorModel(MultiModalPredictorModel):
     """MultimodalPredictor that doesn't use image features"""
 
+    ag_key = "AG_TEXT_NN"
+    ag_name = "TextPredictor"
+
     def _get_default_auxiliary_params(self) -> dict:
         default_auxiliary_params = super()._get_default_auxiliary_params()
         extra_auxiliary_params = dict(

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/src/autogluon/tabular/models/vowpalwabbit/vowpalwabbit_model.py

@@ -38,6 +38,9 @@ class VowpalWabbitModel(AbstractModel):
     VowpalWabbit Command Line args: https://github.com/VowpalWabbit/vowpal_wabbit/wiki/Command-line-arguments
 
     """
+    ag_key = "VW"
+    ag_name = "VowpalWabbit"
+    ag_priority = 10
 
     model_internals_file_name = "model-internals.pkl"
 

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/src/autogluon/tabular/models/xgboost/xgboost_model.py

@@ -27,6 +27,9 @@ class XGBoostModel(AbstractModel):
 
     Hyperparameter options: https://xgboost.readthedocs.io/en/latest/parameter.html
     """
+    ag_key = "XGB"
+    ag_name = "XGBoost"
+    ag_priority = 40
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/src/autogluon/tabular/models/xt/xt_model.py

@@ -7,6 +7,9 @@ class XTModel(RFModel):
     """
     Extra Trees model (scikit-learn): https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.ExtraTreesClassifier.html#sklearn.ensemble.ExtraTreesClassifier
     """
+    ag_key = "XT"
+    ag_name = "ExtraTrees"
+    ag_priority = 60
 
     def _get_model_type(self):
         if self.problem_type == REGRESSION:

{autogluon.tabular-1.2.1b20250225 → autogluon.tabular-1.2.1b20250226}/src/autogluon/tabular/predictor/predictor.py

@@ -4330,7 +4330,14 @@ class TabularPredictor:
             reduce_children=reduce_children,
         )
 
-    def delete_models(self, models_to_keep=None, models_to_delete=None, allow_delete_cascade=False, delete_from_disk=True, dry_run=True):
+    def delete_models(
+        self,
+        models_to_keep: str | list[str] | None = None,
+        models_to_delete: str | list[str] | None = None,
+        allow_delete_cascade: bool = False,
+        delete_from_disk: bool = True,
+        dry_run: bool | None = None,
+    ):
         """
         Deletes models from `predictor`.
         This can be helpful to minimize memory usage and disk usage, particularly for model deployment.
@@ -4341,13 +4348,13 @@ class TabularPredictor:
 
         Parameters
         ----------
-        models_to_keep : str or list, default = None
+        models_to_keep : str or list[str], default = None
             Name of model or models to not delete.
             All models that are not specified and are also not required as a dependency of any model in `models_to_keep` will be deleted.
             Specify `models_to_keep='best'` to keep only the best model and its model dependencies.
             `models_to_delete` must be None if `models_to_keep` is set.
             To see the list of possible model names, use: `predictor.model_names()` or `predictor.leaderboard()`.
-        models_to_delete : str or list, default = None
+        models_to_delete : str or list[str], default = None
             Name of model or models to delete.
             All models that are not specified but depend on a model in `models_to_delete` will also be deleted.
             `models_to_keep` must be None if `models_to_delete` is set.
@@ -4361,10 +4368,19 @@ class TabularPredictor:
             WARNING: This deletes the entire directory for the deleted models, and ALL FILES located there.
                 It is highly recommended to first run with `dry_run=True` to understand which directories will be deleted.
         dry_run : bool, default = True
+            WARNING: Starting in v1.4.0 dry_run will default to False.
             If `True`, then deletions don't occur, and logging statements are printed describing what would have occurred.
             Set `dry_run=False` to perform the deletions.
 
         """
+        if dry_run is None:
+            warnings.warn(
+                f"dry_run was not specified for `TabularPredictor.delete_models`. dry_run prior to version 1.4.0 defaults to True. "
+                f"Starting in version 1.4, AutoGluon will default dry_run to False. "
+                f"If you want to maintain the current logic in future versions, explicitly specify `dry_run=True`.",
+                category=FutureWarning,
+            )
+            dry_run = True
         self._assert_is_fit("delete_models")
         if models_to_keep == "best":
             models_to_keep = self.model_best

autogluon.tabular-1.2.1b20250226/src/autogluon/tabular/register/__init__.py

@@ -0,0 +1,2 @@
+from ._model_register import ModelRegister
+from ._ag_model_register import ag_model_register

autogluon.tabular-1.2.1b20250226/src/autogluon/tabular/register/_ag_model_register.py

@@ -0,0 +1,66 @@
+from autogluon.core.models import (
+    DummyModel,
+    GreedyWeightedEnsembleModel,
+    SimpleWeightedEnsembleModel,
+)
+
+from . import ModelRegister
+from ..models import (
+    BoostedRulesModel,
+    CatBoostModel,
+    FastTextModel,
+    FigsModel,
+    FTTransformerModel,
+    GreedyTreeModel,
+    HSTreeModel,
+    ImagePredictorModel,
+    KNNModel,
+    LGBModel,
+    LinearModel,
+    MultiModalPredictorModel,
+    NNFastAiTabularModel,
+    RFModel,
+    RuleFitModel,
+    TabPFNMixModel,
+    TabPFNModel,
+    TabularNeuralNetTorchModel,
+    TextPredictorModel,
+    VowpalWabbitModel,
+    XGBoostModel,
+    XTModel,
+)
+from ..models.tab_transformer.tab_transformer_model import TabTransformerModel
+
+
+# When adding a new model officially to AutoGluon, the model class should be added to the bottom of this list.
+REGISTERED_MODEL_CLS_LST = [
+    RFModel,
+    XTModel,
+    KNNModel,
+    LGBModel,
+    CatBoostModel,
+    XGBoostModel,
+    TabularNeuralNetTorchModel,
+    LinearModel,
+    NNFastAiTabularModel,
+    TabTransformerModel,
+    TextPredictorModel,
+    ImagePredictorModel,
+    MultiModalPredictorModel,
+    FTTransformerModel,
+    TabPFNModel,
+    TabPFNMixModel,
+    FastTextModel,
+    VowpalWabbitModel,
+    GreedyWeightedEnsembleModel,
+    SimpleWeightedEnsembleModel,
+    RuleFitModel,
+    GreedyTreeModel,
+    FigsModel,
+    HSTreeModel,
+    BoostedRulesModel,
+    DummyModel,
+]
+
+# TODO: Replace logic in `autogluon.tabular.trainer.model_presets.presets` with `ag_model_register`
+ag_model_register = ModelRegister(model_cls_list=REGISTERED_MODEL_CLS_LST)

autogluon.tabular-1.2.1b20250226/src/autogluon/tabular/register/_model_register.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from typing import Type
+
+import pandas as pd
+
+from autogluon.core.models import AbstractModel
+
+
+# TODO: Move to core? Maybe TimeSeries can reuse?
+# TODO: Use this / refer to this in the custom model tutorial
+# TODO: Add to documentation website
+# TODO: Test register logic in AG
+class ModelRegister:
+    """
+    ModelRegister keeps track of all known model classes to AutoGluon.
+    It can provide information such as:
+        What model classes and keys are valid to specify in an AutoGluon predictor fit call.
+        What a model's name is.
+        What a model's key is (such as the key specified by the user in `hyperparameters` to refer to a specific model type).
+        What a model's priority is (aka which order to fit a list of models).
+
+    Additionally, users can register custom models to AutoGluon so the key is recognized in `hyperparameters` and is treated with the proper priority and name.
+    They can register new models via `ModelRegister.add(model_cls)`.
+
+    Therefore, if a user creates a custom model `MyCustomModel` that inherits from `AbstractModel`, they can set the class attributes in `MyCustomModel`:
+        ag_key: The string key that can be specified in `hyperparameters`. Example: "GBM" for LGBModel
+        ag_name: The string name that is used in logging and accessing the model. Example: "LightGBM" for LGBModel
+        ag_priority: The int priority that is used to order the fitting of models. Higher values will be fit before lower values. Default 0. Example: 90 for LGBModel
+        ag_priority_to_problem_type: A dictionary of problem_type to priority that overrides `ag_priority` if specified for a given problem_type. Optional.
+
+    Then they can say `ag_model_register.add(MyCustomModel)`.
+    Assuming MyCustomModel.ag_key = "MY_MODEL", they can now do:
+    ```
+    predictor.fit(..., hyperparameters={"MY_MODEL": ...})
+    ```
+    """
+    def __init__(self, model_cls_list: list[Type[AbstractModel]] | None = None):
+        if model_cls_list is None:
+            model_cls_list = []
+        assert isinstance(model_cls_list, list)
+        self._model_cls_list = []
+        self._key_to_cls_map = dict()
+        for model_cls in model_cls_list:
+            self.add(model_cls)
+
+    def exists(self, model_cls: Type[AbstractModel]) -> bool:
+        return model_cls in self._model_cls_list
+
+    def add(self, model_cls: Type[AbstractModel]):
+        """
+        Adds `model_cls` to the model register
+        """
+        assert not self.exists(model_cls), f"Cannot add model_cls that is already registered: {model_cls}"
+        if model_cls.ag_key is None:
+            raise AssertionError(
+                f"Cannot add model_cls with `ag_key=None`. "
+                f"Ensure you set class attribute `ag_key` to a string for your model_cls: {model_cls}"
+                f'\n\tFor example, LightGBModel sets `ag_key = "GBM"`'
+            )
+        if model_cls.ag_name is None:
+            raise AssertionError(
+                f"Cannot add model_cls with `ag_name=None`. "
+                f"Ensure you set class attribute `ag_name` to a string for your model_cls: {model_cls}"
+                f'\n\tFor example, LightGBModel sets `ag_name = "LightGBM"`'
+            )
+        assert isinstance(model_cls.ag_key, str)
+        assert isinstance(model_cls.ag_name, str)
+        assert isinstance(model_cls.ag_priority, int)
+        if model_cls.ag_key in self._key_to_cls_map:
+            raise AssertionError(
+                f"Cannot register a model class that shares a model key with an already registered model class."
+                f"\n`model_cls.ag_key` must be unique among registered models:"
+                f"\n\t        New  Class: {model_cls}"
+                f"\n\tConflicting  Class: {self._key_to_cls_map[model_cls.ag_key]}"
+                f"\n\tConflicting ag_key: {model_cls.ag_key}"
+            )
+        self._model_cls_list.append(model_cls)
+        self._key_to_cls_map[model_cls.ag_key] = model_cls
+
+    def remove(self, model_cls: Type[AbstractModel]):
+        """
+        Removes `model_cls` from the model register
+        """
+        assert self.exists(model_cls), f"Cannot remove model_cls that isn't registered: {model_cls}"
+        self._model_cls_list = [m for m in self._model_cls_list if m != model_cls]
+        self._key_to_cls_map.pop(model_cls.ag_key)
+
+    @property
+    def model_cls_list(self) -> list[Type[AbstractModel]]:
+        return self._model_cls_list
+
+    @property
+    def keys(self) -> list[str]:
+        return [self.key(model_cls) for model_cls in self.model_cls_list]
+
+    def key_to_cls_map(self) -> dict[str, Type[AbstractModel]]:
+        return self._key_to_cls_map
+
+    def key_to_cls(self, key: str) -> Type[AbstractModel]:
+        if key not in self._key_to_cls_map:
+            raise ValueError(
+                f"No registered model exists with provided key: {key}"
+                f"\n\tValid keys: {list(self.key_to_cls_map().keys())}"
+            )
+        return self.key_to_cls_map()[key]
+
+    def priority_map(self, problem_type: str | None = None) -> dict[Type[AbstractModel], int]:
+        return {model_cls: self.priority(model_cls, problem_type=problem_type) for model_cls in self._model_cls_list}
+
+    def key(self, model_cls: Type[AbstractModel]) -> str:
+        assert self.exists(model_cls), f"Model class must be registered: {model_cls}"
+        return model_cls.ag_key
+
+    def name_map(self) -> dict[Type[AbstractModel], str]:
+        return {model_cls: model_cls.ag_name for model_cls in self._model_cls_list}
+
+    def name(self, model_cls: Type[AbstractModel]) -> str:
+        assert self.exists(model_cls), f"Model class must be registered: {model_cls}"
+        return model_cls.ag_name
+
+    def priority(self, model_cls: Type[AbstractModel], problem_type: str | None = None) -> int:
+        assert self.exists(model_cls), f"Model class must be registered: {model_cls}"
+        return model_cls.get_ag_priority(problem_type=problem_type)
+
+    def docstring(self, model_cls: Type[AbstractModel]) -> str:
+        assert self.exists(model_cls), f"Model class must be registered: {model_cls}"
+        return model_cls.__doc__
+
+    # TODO: Could add a lot of information here to track which features are supported for each model:
+    #  ag.early_stop support
+    #  refit_full support
+    #  GPU support
+    #  etc.
+    def to_frame(self) -> pd.DataFrame:
+        model_classes = self.model_cls_list
+        cls_dict = {}
+        for model_cls in model_classes:
+            cls_dict[self.key(model_cls)] = {
+                "model_cls": model_cls.__name__,
+                "ag_name": self.name(model_cls),
+                "ag_priority": self.priority(model_cls),
+            }
+        df = pd.DataFrame(cls_dict).T
+        df.index.name = "ag_key"
+        return df