maxframe 1.3.0__cp311-cp311-win32.whl → 2.0.0__cp311-cp311-win32.whl

maxframe/learn/contrib/llm/multi_modal.py

@@ -34,6 +34,98 @@ def generate(
     prompt_template: Dict[str, Any],
     params: Dict[str, Any] = None,
 ):
+    """
+    Generate text with multi model llm based on given data and prompt template.
+
+    Parameters
+    ----------
+    data : DataFrame or Series
+        Input data used for generation. Can be maxframe DataFrame, Series that contain text to be processed.
+    model : MultiModalLLM
+        Language model instance support **MultiModal** inputs used for text generation.
+    prompt_template : List[Dict[str, List[Dict[str, str]]]]
+        List of message with column names as placeholders. Each message contains a role and content. Content is a list of dict, each dict contains a text or image, the value can reference column data from input.
+
+        Here is an example of prompt template.
+
+        .. code-block:: python
+
+            [
+                {
+                    "role": "<role>",  # e.g. "user" or "assistant"
+                    "content": [
+                        {
+                            # At least one of these fields is required
+                            "image": "<image_data_url>",  # optional
+                            "text": "<prompt_text_template>"  # optional
+                        },
+                        ...
+                    ]
+                }
+            ]
+
+        Where:
+
+        - ``text`` can be a Python format string using column names from input data as parameters (e.g. ``"{column_name}"``)
+        - ``image`` should be a DataURL string following `RFC2397 <https://en.wikipedia.org/wiki/Data_URI_scheme>`_ standard with format.
+
+        .. code-block:: none
+
+            data:<mime_type>[;base64],<column_name>
+
+
+    params : Dict[str, Any], optional
+        Additional parameters for generation configuration, by default None.
+        Can include settings like temperature, max_tokens, etc.
+
+    Returns
+    -------
+    DataFrame
+        Generated text raw response and success status. If the success is False, the generated text will return the
+        error message.
+
+    Notes
+    -----
+    - The ``api_key_resource`` parameter should reference a text file resource in MaxCompute that contains only your DashScope API key.
+
+    - Using DashScope services requires enabling public network access for your MaxCompute project. This can be configured through the MaxCompute console by `enabling the Internet access feature <https://help.aliyun.com/zh/maxcompute/user-guide/network-connection-process>`_ for your project. Without this configuration, the API calls to DashScope will fail due to network connectivity issues.
+
+    Examples
+    --------
+    You can initialize a DashScope multi-modal model (such as qwen-vl-max) by providing a model name and an ``api_key_resource``.
+    The ``api_key_resource`` is a MaxCompute resource name that points to a text file containing a `DashScope <https://dashscope.aliyun.com/>`_ API key.
+
+    >>> from maxframe.learn.contrib.llm.models.dashscope import DashScopeMultiModalLLM
+    >>> import maxframe.dataframe as md
+    >>>
+    >>> model = DashScopeMultiModalLLM(
+    ...     name="qwen-vl-max",
+    ...     api_key_resource="<api-key-resource-name>"
+    ... )
+
+    We use Data Url Schema to provide multi modal input in prompt template, here is an example to fill in the image from table.
+
+    Assuming you have a MaxCompute table with two columns: ``image_id`` (as the index) and ``encoded_image_data_base64`` (containing Base64 encoded image data),
+    you can construct a prompt message template as follows:
+
+    >>> df = md.read_odps_table("image_content", index_col="image_id")
+
+    >>> prompt_template = [
+    ...     {
+    ...         "role": "user",
+    ...         "content": [
+    ...             {
+    ...                 "image": "data:image/png;base64,encoded_image_data_base64",
+    ...             },
+    ...             {
+    ...                 "text": "Analyze this image in detail",
+    ...             },
+    ...         ],
+    ...     },
+    ... ]
+    >>> result = model.generate(df, prompt_template)
+    >>> result.execute()
+    """
     if not isinstance(data, DATAFRAME_TYPE) and not isinstance(data, SERIES_TYPE):
         raise ValueError("data must be a maxframe dataframe or series object")
     if not isinstance(model, MultiModalLLM):

maxframe/learn/contrib/llm/text.py

@@ -145,16 +145,16 @@ def generate(
     >>> import maxframe.dataframe as md
     >>>
     >>> # Initialize the model
-    >>> llm = ManagedTextLLM(name="Qwen2.5-1.5B")
+    >>> llm = ManagedTextLLM(name="Qwen2.5-0.5B-instruct")
     >>>
     >>> # Prepare prompt template
     >>> messages = [
     ...     {
     ...         "role": "user",
-    ...         "content": "{query}",
+    ...         "content": "Help answer following question: {query}",
     ...     },
     ... ]
-    >>>
+
     >>> # Create sample data
     >>> df = md.DataFrame({"query": ["What is machine learning?"]})
     >>>
@@ -177,7 +177,7 @@ def summary(series, model: TextLLM, index=None):
 
     Parameters
     ----------
-    series : pandas.Series
+    series : Series
         A maxframe Series containing text data to be summarized.
         Each element should be a text string.
     model : TextLLM
@@ -189,6 +189,11 @@ def summary(series, model: TextLLM, index=None):
     -------
     maxframe.Series
         A pandas Series containing the generated summaries and success status.
+
+    Notes
+    -----
+      **Preview:** This API is in preview state and may be unstable.
+      The interface may change in future releases.
     """
     if not isinstance(series, Series):
         raise ValueError("series must be a maxframe series object")
@@ -208,7 +213,7 @@ def translate(
     Parameters
     ----------
     series : pandas.Series
-        A maxframe Series containing text data to be translate.
+        A maxframe Series containing text data to translate.
         Each element should be a text string.
     model : TextLLM
         Language model instance used for text summarization.
@@ -223,6 +228,12 @@ def translate(
     -------
     maxframe.Series
         A pandas Series containing the generated translation and success status.
+
+    Notes
+    -----
+      **Preview:** This API is in preview state and may be unstable.
+      The interface may change in future releases.
+
     """
     if not isinstance(series, Series):
         raise ValueError("series must be a maxframe series object")
@@ -268,6 +279,11 @@ def classify(
     -------
     maxframe.Series
         A pandas Series containing the generated classification results and success status.
+
+    Notes
+    -----
+      **Preview:** This API is in preview state and may be unstable.
+      The interface may change in future releases.
     """
     if not isinstance(series, Series):
         raise ValueError("series must be a maxframe series object")

maxframe/learn/contrib/models.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import Type
+
 from ... import opcodes
 from ...core import ENTITY_TYPE, OutputType
 from ...core.operator import ObjectOperator, ObjectOperatorMixin
@@ -21,7 +23,30 @@ from ...serialization.serializables import (
     FunctionField,
     TupleField,
 )
+from ...udf import BuiltinFunction
 from ...utils import find_objects, replace_objects
+from ..core import Model, ModelData
+
+
+class ModelWithEvalData(ModelData):
+    __slots__ = ("_evals_result",)
+
+    _evals_result: dict
+
+    def __init__(self, *args, evals_result=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._evals_result = evals_result if evals_result is not None else dict()
+
+    def execute(self, session=None, **kw):
+        # The evals_result should be fetched when BoosterData.execute() is called.
+        result = super().execute(session=session, **kw)
+        if self.op.has_evals_result and self.key == self.op.outputs[0].key:
+            self._evals_result.update(self.op.outputs[1].fetch(session=session))
+        return result
+
+
+class ModelWithEval(Model):
+    pass
 
 
 class ModelDataSource(ObjectOperator, ObjectOperatorMixin):
@@ -29,7 +54,7 @@ class ModelDataSource(ObjectOperator, ObjectOperatorMixin):
 
     data = AnyField("data")
 
-    def __call__(self, model_cls):
+    def __call__(self, model_cls: Type[ModelWithEval]):
         self._output_types = [OutputType.object]
         return self.new_tileable(None, object_class=model_cls)
 
@@ -48,14 +73,18 @@ class ModelApplyChunk(ObjectOperator, ObjectOperatorMixin):
         self._output_types = list(output_types)
         super().__init__(**kwargs)
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        old_inputs = find_objects(self.args, ENTITY_TYPE) + find_objects(
-            self.kwargs, ENTITY_TYPE
+    def has_custom_code(self) -> bool:
+        return not isinstance(self.func, BuiltinFunction)
+
+    @classmethod
+    def _set_inputs(cls, op: "ModelApplyChunk", inputs):
+        super()._set_inputs(op, inputs)
+        old_inputs = find_objects(op.args, ENTITY_TYPE) + find_objects(
+            op.kwargs, ENTITY_TYPE
         )
-        mapping = {o: n for o, n in zip(old_inputs, self._inputs[1:])}
-        self.args = replace_objects(self.args, mapping)
-        self.kwargs = replace_objects(self.kwargs, mapping)
+        mapping = {o: n for o, n in zip(old_inputs, op._inputs[1:])}
+        op.args = replace_objects(op.args, mapping)
+        op.kwargs = replace_objects(op.kwargs, mapping)
 
     @property
     def output_limit(self) -> int:
@@ -72,6 +101,6 @@ class ModelApplyChunk(ObjectOperator, ObjectOperatorMixin):
         return self.new_tileables(inputs, kws=output_kws)
 
 
-def to_remote_model(model, model_cls):
+def to_remote_model(model, model_cls: Type[ModelWithEval]) -> ModelWithEval:
     op = ModelDataSource(data=model)
     return op(model_cls)

maxframe/learn/contrib/utils.py

@@ -14,6 +14,8 @@
 
 import sys
 
+from ...serialization.serializables import Serializable
+
 
 def make_import_error_func(package_name):
     def _func(*_, **__):  # pragma: no cover
@@ -51,3 +53,56 @@ def config_mod_getattr(mod_dict, globals_):
             "__warningregistry__": dict(),
         }
     )
+
+
+class TrainingCallback(Serializable):
+    _local_cls = None
+
+    @classmethod
+    def _load_local_to_remote_mapping(cls, globals_dict):
+        if cls._local_to_remote:
+            return
+        for v in globals_dict.values():
+            if isinstance(v, type) and issubclass(v, cls) and v._local_cls is not None:
+                cls._local_to_remote[v._local_cls] = v
+
+    @classmethod
+    def from_local(cls, callback_obj):
+        if isinstance(callback_obj, (list, tuple)):
+            return [cls.from_local(x) for x in callback_obj]
+        if not type(callback_obj) in cls._local_to_remote:
+            return callback_obj
+
+        kw = {}
+        remote_cls = cls._local_to_remote[type(callback_obj)]
+        for attr in remote_cls._FIELDS:
+            try:
+                kw[attr] = getattr(callback_obj, attr)
+            except AttributeError:
+                pass
+        return remote_cls(**kw)
+
+    def has_custom_code(self) -> bool:
+        return False
+
+    @classmethod
+    def remote_to_local(cls, remote_obj):
+        if isinstance(remote_obj, (list, tuple)):
+            return [cls.remote_to_local(x) for x in remote_obj]
+        if not isinstance(remote_obj, TrainingCallback):
+            return remote_obj
+        return remote_obj.to_local()
+
+    def _extract_kw(self) -> dict:
+        kw = {}
+        for attr in type(self)._FIELDS:
+            val = getattr(self, attr, None)
+            if val is not None:
+                kw[attr] = val
+        return kw
+
+    def to_local(self):
+        return type(self)._local_cls(**self._extract_kw())
+
+    def __call__(self, *args, **kwargs):
+        return self.to_local()(*args, **kwargs)

maxframe/learn/contrib/xgboost/callback.py

@@ -0,0 +1,86 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Callable, Optional, Sequence, Union
+
+from ....serialization.serializables import (
+    AnyField,
+    BoolField,
+    Float32Field,
+    Int32Field,
+    StringField,
+)
+from ....udf import BuiltinFunction
+from ..utils import TrainingCallback
+
+try:
+    from xgboost.callback import EarlyStopping as _EarlyStopping
+    from xgboost.callback import LearningRateScheduler as _LearningRateScheduler
+except ImportError:
+    _LearningRateScheduler = _EarlyStopping = None
+
+
+class XGBTrainingCallback(TrainingCallback):
+    _local_to_remote = {}
+
+    @classmethod
+    def from_local(cls, callback_obj):
+        cls._load_local_to_remote_mapping(globals())
+        return super().from_local(callback_obj)
+
+
+class LearningRateScheduler(XGBTrainingCallback):
+    _local_cls = _LearningRateScheduler
+
+    learning_rates = AnyField("learning_rates", default=None)
+
+    def __init__(
+        self, learning_rates: Union[Callable[[int], float], Sequence[float]], **kw
+    ) -> None:
+        super().__init__(learning_rates=learning_rates, **kw)
+
+    def has_custom_code(self) -> bool:
+        return not isinstance(self.learning_rates, (tuple, list, BuiltinFunction))
+
+
+class EarlyStopping(XGBTrainingCallback):
+    _local_cls = _EarlyStopping
+
+    rounds = Int32Field("rounds")
+    metric_name = StringField("metric_name", default=None)
+    data_name = StringField("data_name", default=None)
+    maximize = BoolField("maximize", default=None)
+    save_best = BoolField("save_best", default=None)
+    min_delta = Float32Field("min_delta", default=None)
+
+    def __init__(
+        self,
+        *,
+        rounds: int,
+        metric_name: Optional[str] = None,
+        data_name: Optional[str] = None,
+        maximize: Optional[bool] = None,
+        save_best: Optional[bool] = False,
+        min_delta: float = 0.0,
+        **kw
+    ) -> None:
+        super().__init__(
+            rounds=rounds,
+            metric_name=metric_name,
+            data_name=data_name,
+            maximize=maximize,
+            save_best=save_best,
+            min_delta=min_delta,
+            **kw
+        )

maxframe/learn/contrib/xgboost/classifier.py

@@ -26,9 +26,7 @@ if not xgboost:
 else:
     from xgboost.sklearn import XGBClassifierBase
 
-    from .core import wrap_evaluation_matrices
     from .predict import predict
-    from .train import train
 
     class XGBClassifier(XGBScikitLearnBase, XGBClassifierBase):
         """
@@ -43,6 +41,15 @@ else:
             super().__init__(**kwargs)
             self._set_model(xgb_model)
 
+        def get_xgb_params(self):
+            params = super().get_xgb_params()
+            if self.n_classes_ > 2:
+                params["objective"] = "multi:softprob"
+                params["num_class"] = self.n_classes_
+            else:
+                params["objective"] = "binary:logistic"
+            return params
+
         def fit(
             self,
             X,
@@ -50,43 +57,32 @@ else:
             sample_weight=None,
             base_margin=None,
             eval_set=None,
+            xgb_model=None,
             sample_weight_eval_set=None,
             base_margin_eval_set=None,
             num_class=None,
             **kw,
         ):
             session = kw.pop("session", None)
-            run_kwargs = kw.pop("run_kwargs", None) or dict()
-            dtrain, evals = wrap_evaluation_matrices(
-                None,
+            run_kwargs = kw.pop("run_kwargs", dict())
+
+            if num_class is not None:
+                self.n_classes_ = num_class
+            else:
+                t_labels = mt.unique(y).execute(session=session, **run_kwargs)
+                self.n_classes_ = t_labels.shape[0]
+
+            super().fit(
                 X,
                 y,
-                sample_weight,
-                base_margin,
-                eval_set,
-                sample_weight_eval_set,
-                base_margin_eval_set,
-            )
-            params = self.get_xgb_params()
-            self._n_features_in = X.shape[1]
-            self.n_classes_ = num_class or 1
-            if self.n_classes_ > 2:
-                params["objective"] = "multi:softprob"
-                params["num_class"] = self.n_classes_
-            else:
-                params["objective"] = "binary:logistic"
-            self.evals_result_ = dict()
-            result = train(
-                params,
-                dtrain,
-                num_boost_round=self.get_num_boosting_rounds(),
-                evals=evals,
-                evals_result=self.evals_result_,
-                num_class=num_class,
-                session=session,
-                run_kwargs=run_kwargs,
+                sample_weight=sample_weight,
+                base_margin=base_margin,
+                eval_set=eval_set,
+                xgb_model=xgb_model,
+                sample_weight_eval_set=sample_weight_eval_set,
+                base_margin_eval_set=base_margin_eval_set,
+                **kw,
             )
-            self._Booster = result
             return self
 
         def predict(self, data, **kw):

maxframe/learn/contrib/xgboost/core.py

@@ -19,26 +19,19 @@ from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 import numpy as np
 
+from ....errors import TileableNotExecutedError
+
 try:
     import xgboost
 except ImportError:
     xgboost = None
 
 from ....core import OutputType
-from ...core import Model, ModelData
-from ..models import ModelApplyChunk, to_remote_model
+from ..models import ModelApplyChunk, ModelWithEval, ModelWithEvalData, to_remote_model
 from .dmatrix import DMatrix
 
 
-class BoosterData(ModelData):
-    __slots__ = ("_evals_result",)
-
-    _evals_result: Dict
-
-    def __init__(self, *args, evals_result=None, **kwargs):
-        super().__init__(*args, **kwargs)
-        self._evals_result = evals_result if evals_result is not None else dict()
-
+class BoosterData(ModelWithEvalData):
     @staticmethod
     def _get_booster_score(bst, fmap=None, importance_type="weight"):
         if not fmap:
@@ -66,13 +59,6 @@ class BoosterData(ModelData):
                 fmap_data = fmap_file.read()
         return op(self, [{}], fmap=fmap_data, importance_type=importance_type)[0]
 
-    def execute(self, session=None, **kw):
-        # The evals_result should be fetched when BoosterData.execute() is called.
-        result = super().execute(session=session, **kw)
-        if self.op.has_evals_result and self.key == self.op.outputs[0].key:
-            self._evals_result.update(self.op.outputs[1].fetch(session=session))
-        return result
-
     def predict(
         self,
         data,
@@ -103,7 +89,7 @@ class BoosterData(ModelData):
         )
 
 
-class Booster(Model):
+class Booster(ModelWithEval):
     pass
 
 
@@ -137,39 +123,65 @@ else:
             return names
 
         def __repr__(self):
-            local_model = self.fetch()
-            return repr(local_model)
+            try:
+                local_model = self.fetch()
+                return repr(local_model)
+            except TileableNotExecutedError:
+                return f"<{type(self).__name__} unexecuted>"
 
         def fit(
             self,
             X,
             y,
-            sample_weights=None,
+            sample_weight=None,
+            base_margin=None,
             eval_set=None,
+            xgb_model=None,
             sample_weight_eval_set=None,
+            base_margin_eval_set=None,
             **kw,
         ):
-            """
-            Fit the regressor. Note that fit() is an eager-execution
-            API. The call will be blocked until training finished.
+            from .train import train
 
-            Parameters
-            ----------
-            X : array_like
-                Feature matrix
-            y : array_like
-                Labels
-            sample_weight : array_like
-                instance weights
-            eval_set : list, optional
-                A list of (X, y) tuple pairs to use as validation sets, for which
-                metrics will be computed.
-                Validation metrics will help us track the performance of the model.
-            sample_weight_eval_set : list, optional
-                A list of the form [L_1, L_2, ..., L_n], where each L_i is a list
-                of group weights on the i-th validation set.
-            """
-            raise NotImplementedError
+            session = kw.pop("session", None)
+            run_kwargs = kw.pop("run_kwargs", dict())
+
+            self._n_features_in = X.shape[1]
+
+            dtrain, evals = wrap_evaluation_matrices(
+                None,
+                X,
+                y,
+                sample_weight,
+                base_margin,
+                eval_set,
+                sample_weight_eval_set,
+                base_margin_eval_set,
+            )
+            params = self.get_xgb_params()
+            if not params.get("objective"):
+                params["objective"] = "reg:squarederror"
+            self.evals_result_ = dict()
+            train_kw = {}
+            train_kw.update(kw)
+
+            if getattr(self, "n_classes_", None):
+                train_kw["num_class"] = self.n_classes_
+
+            result = train(
+                params,
+                dtrain,
+                num_boost_round=self.get_num_boosting_rounds(),
+                evals=evals,
+                evals_result=self.evals_result_,
+                xgb_model=xgb_model,
+                callbacks=self.callbacks,
+                session=session,
+                run_kwargs=run_kwargs,
+                **train_kw,
+            )
+            self._Booster = result
+            return self
 
         def predict(self, data, **kw):
             """