maxframe 2.2.0__cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

maxframe/learn/contrib/lightgbm/dataset.py

@@ -0,0 +1,153 @@
+# 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 List
+
+from .... import opcodes
+from ....core import EntityData
+from ....core.entity.output_types import get_output_types
+from ....core.operator.base import Operator
+from ....core.operator.core import TileableOperatorMixin
+from ....dataframe.core import DATAFRAME_TYPE
+from ....serialization.serializables import BoolField, KeyField, ListField
+from ....serialization.serializables.field import AnyField
+from ....tensor import tensor as astensor
+from ....tensor.core import TENSOR_TYPE
+from ....typing_ import TileableType
+from ...utils import convert_to_tensor_or_dataframe
+
+
+class ToLGBMDataset(Operator, TileableOperatorMixin):
+    _op_type_ = opcodes.TO_LGBM_DATASET
+
+    data = KeyField("data", default=None)
+    label = KeyField("label", default=None)
+    reference = KeyField("reference", default=None)
+    weight = KeyField("weight", default=None)
+    init_score = KeyField("init_score", default=None)
+    group = AnyField("group", default=None)
+    feature_name = ListField("feature_name", default=None)
+    categorical_feature = ListField("categorical_feature", default=None)
+    params = AnyField("params", default=None)
+    free_raw_data = BoolField("free_raw_data", default=None)
+    position = AnyField("position", default=None)
+    # if to collocate the data, label and weight
+    collocate = BoolField("collocate", default=False)
+
+    @property
+    def output_limit(self):
+        if self.collocate:
+            return 1 + sum(bool(x) for x in [self.label, self.weight, self.init_score])
+        return 1
+
+    @classmethod
+    def _set_inputs(cls, op: "ToLGBMDataset", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        if op.data is not None:
+            op.data = op._inputs[0]
+        has_label = op.label is not None
+        if has_label:
+            op.label = op._inputs[1]
+        if op.weight is not None:
+            i = 1 if not has_label else 2
+            op.weight = op._inputs[i]
+        if op.init_score is not None:
+            op.init_score = op._inputs[-1]
+
+    @staticmethod
+    def _get_kw(obj):
+        if isinstance(obj, TENSOR_TYPE):
+            return {"shape": obj.shape, "dtype": obj.dtype, "order": obj.order}
+        else:
+            return {
+                "shape": obj.shape,
+                "dtypes": obj.dtypes,
+                "index_value": obj.index_value,
+                "columns_value": obj.columns_value,
+            }
+
+    def __call__(self):
+        inputs = [self.data]
+        kw = self._get_kw(self.data)
+        if self.label is not None:
+            inputs.append(self.label)
+        if self.weight is not None:
+            inputs.append(self.weight)
+        if self.init_score is not None:
+            inputs.append(self.init_score)
+
+        return self.new_tileable(inputs, **kw)
+
+
+def check_data(data):
+    data = convert_to_tensor_or_dataframe(data)
+    if data.ndim != 2:
+        raise ValueError(f"Expecting 2-d data, got: {data.ndim}-d")
+
+    return data
+
+
+def check_array_like(y: TileableType, name: str) -> TileableType:
+    if y is None:
+        return
+    y = convert_to_tensor_or_dataframe(y)
+    if isinstance(y, DATAFRAME_TYPE):
+        y = y.iloc[:, 0]
+    return astensor(y)
+
+
+def to_lgbm_dataset(
+    data,
+    label=None,
+    reference=None,
+    weight=None,
+    group=None,
+    init_score=None,
+    feature_name="auto",
+    categorical_feature="auto",
+    params=None,
+    free_raw_data=True,
+    position=None,
+):
+    data = check_data(data)
+    label = check_array_like(label, "label")
+    weight = check_array_like(weight, "weight")
+    init_score = check_array_like(init_score, "init_score")
+
+    if weight is not None and weight.ndim > 1:
+        raise ValueError("weight must be 1-dimensional")
+
+    # If not multiple outputs, try to collect the chunks on same worker into one
+    # to feed the data into LightGBM for training.
+    op = ToLGBMDataset(
+        data=data,
+        label=label,
+        reference=reference,
+        weight=weight,
+        group=group,
+        init_score=init_score,
+        feature_name=None if feature_name == "auto" else feature_name,
+        categorical_feature=None
+        if categorical_feature == "auto"
+        else categorical_feature,
+        params=params,
+        free_raw_data=free_raw_data,
+        position=position,
+        gpu=data.op.gpu,
+        _output_types=get_output_types(data),
+    )
+    return op()
+
+
+Dataset = to_lgbm_dataset

maxframe/learn/contrib/lightgbm/regressor.py

@@ -0,0 +1,29 @@
+# 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 ..utils import make_import_error_func
+from .core import LGBMScikitLearnBase
+
+try:
+    import lightgbm
+except ImportError:
+    lightgbm = None
+
+
+if not lightgbm:
+    LGBMRegressor = make_import_error_func("lightgbm")
+else:
+
+    class LGBMRegressor(LGBMScikitLearnBase, lightgbm.LGBMRegressor):
+        _default_objective = "regression"

maxframe/learn/contrib/lightgbm/tests/__init__.py

@@ -0,0 +1,13 @@
+# 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.

maxframe/learn/contrib/lightgbm/tests/test_callback.py

@@ -0,0 +1,58 @@
+# 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.
+
+import inspect
+
+import pytest
+
+from ..callback import (
+    EarlyStoppingCallback,
+    LGBMTrainingCallback,
+    early_stopping,
+    reset_parameter,
+)
+
+try:
+    from lightgbm.callback import _EarlyStoppingCallback
+except ImportError:
+    try:
+        from lightgbm.callback import early_stopping as _EarlyStoppingCallback
+    except ImportError:
+        pytestmark = pytest.mark.skip("Need lightgbm to run the test")
+
+
+def test_lgbm_training_callbacks():
+    early_stopping_cb = early_stopping(stopping_rounds=5)
+    assert not early_stopping_cb.has_custom_code()
+
+    local_early_stopping_cb = early_stopping_cb.to_local()
+    if isinstance(_EarlyStoppingCallback, type):
+        assert isinstance(local_early_stopping_cb, _EarlyStoppingCallback)
+        assert local_early_stopping_cb.stopping_rounds == 5
+    else:
+        assert local_early_stopping_cb.__qualname__.startswith(
+            _EarlyStoppingCallback.__name__
+        )
+        cb_vars = inspect.getclosurevars(local_early_stopping_cb).nonlocals
+        assert cb_vars["stopping_rounds"] == 5
+
+    rmt_early_stopping_cb = LGBMTrainingCallback.from_local(local_early_stopping_cb)
+    assert isinstance(rmt_early_stopping_cb, EarlyStoppingCallback)
+    assert rmt_early_stopping_cb.stopping_rounds == 5
+
+    lr_sch_cb = reset_parameter(a=[0.5, 0.4, 0.1])
+    assert not lr_sch_cb.has_custom_code()
+
+    lr_sch_cb = reset_parameter(a=lambda x: x * 0.1)
+    assert lr_sch_cb.has_custom_code()

maxframe/learn/contrib/llm/__init__.py

@@ -0,0 +1,17 @@
+# 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 . import models, multi_modal, text
+
+del models

maxframe/learn/contrib/llm/core.py

@@ -0,0 +1,77 @@
+# 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 Any, Dict
+
+import numpy as np
+import pandas as pd
+
+from ....core.entity.output_types import OutputType
+from ....core.operator.base import Operator
+from ....core.operator.core import TileableOperatorMixin
+from ....dataframe.core import SERIES_TYPE
+from ....dataframe.operators import DataFrameOperatorMixin
+from ....dataframe.utils import parse_index
+from ....serialization.serializables import Int32Field
+from ....serialization.serializables.core import Serializable
+from ....serialization.serializables.field import AnyField, DictField, StringField
+
+
+class LLM(Serializable):
+    name = StringField("name", default=None)
+
+    def validate_params(self, params: Dict[str, Any]):
+        pass
+
+
+class LLMTaskOperator(Operator, DataFrameOperatorMixin):
+    task = AnyField("task", default=None)
+    model = AnyField("model", default=None)
+    params = DictField("params", default=None)
+    running_options: Dict[str, Any] = DictField("running_options", default=None)
+    timeout = Int32Field("timeout", default=None)
+
+    def __init__(self, output_types=None, **kw):
+        if output_types is None:
+            output_types = [OutputType.dataframe]
+        super().__init__(_output_types=output_types, **kw)
+
+    def get_output_dtypes(self) -> Dict[str, np.dtype]:
+        raise NotImplementedError
+
+    def __call__(self, data, index=None):
+        outputs = self.get_output_dtypes()
+        col_name = list(outputs.keys())
+        columns = parse_index(pd.Index(col_name), store_data=True)
+        out_dtypes = pd.Series(list(outputs.values()), index=col_name)
+        index_value = index or (
+            parse_index(pd.RangeIndex(-1), data)
+            if isinstance(data, SERIES_TYPE)
+            else data.index_value
+        )
+
+        return self.new_dataframe(
+            inputs=[data],
+            shape=(np.nan, len(col_name)),
+            index_value=index_value,
+            columns_value=columns,
+            dtypes=out_dtypes,
+        )
+
+
+class LLMTextGenOperator(LLMTaskOperator, TileableOperatorMixin):
+    prompt_template = AnyField("prompt_template", default=None)
+
+    def get_output_dtypes(self) -> Dict[str, np.dtype]:
+        return {"response": np.dtype("O"), "success": np.dtype("bool")}

maxframe/learn/contrib/llm/models/__init__.py

@@ -0,0 +1,15 @@
+# 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 .dashscope import DashScopeMultiModalLLM, DashScopeTextLLM

maxframe/learn/contrib/llm/models/dashscope.py

@@ -0,0 +1,108 @@
+# 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 Any, Dict
+
+from ..... import opcodes
+from .....serialization.serializables.core import Serializable
+from .....serialization.serializables.field import StringField
+from ..core import LLMTextGenOperator
+from ..multi_modal import MultiModalLLM
+from ..text import TextLLM
+
+
+class DashScopeLLMMixin(Serializable):
+    __slots__ = ()
+
+    _not_supported_params = {"stream", "incremental_output"}
+
+    def validate_params(self, params: Dict[str, Any]):
+        for k in params.keys():
+            if k in self._not_supported_params:
+                raise ValueError(f"{k} is not supported")
+
+
+class DashScopeTextLLM(TextLLM, DashScopeLLMMixin):
+    """
+    DashScope text LLM.
+    """
+
+    api_key_resource = StringField("api_key_resource", default=None)
+
+    def __init__(self, name: str, api_key_resource: str):
+        """
+        Initialize a DashScope text LLM.
+
+        Parameters
+        ----------
+        name : str
+            The LLM name to use, check DashScope for `available models <https://help.aliyun.com/zh/model-studio/getting-started/models>`_.
+        api_key_resource : str
+            The MaxCompute resource file name containing the DashScope API key.
+        """
+        super().__init__(name=name, api_key_resource=api_key_resource)
+
+    def generate(
+        self,
+        data,
+        prompt_template: Dict[str, Any],
+        params: Dict[str, Any] = None,
+    ):
+        return DashScopeTextGenerationOperator(
+            model=self,
+            prompt_template=prompt_template,
+            params=params,
+        )(data)
+
+
+class DashScopeMultiModalLLM(MultiModalLLM, DashScopeLLMMixin):
+    """
+    DashScope multi-modal LLM.
+    """
+
+    api_key_resource = StringField("api_key_resource", default=None)
+
+    def __init__(self, name: str, api_key_resource: str):
+        """
+        Initialize a DashScope multi-modal LLM.
+
+        Parameters
+        ----------
+        name : str
+            The LLM name to use, check DashScope for `available models <https://help.aliyun.com/zh/model-studio/getting-started/models>`_.
+        api_key_resource : str
+            The MaxCompute resource file name containing the DashScope API key.
+        """
+        super().__init__(name=name, api_key_resource=api_key_resource)
+
+    def generate(
+        self,
+        data,
+        prompt_template: Dict[str, Any],
+        params: Dict[str, Any] = None,
+    ):
+        # TODO add precheck here
+        return DashScopeMultiModalGenerationOperator(
+            model=self,
+            prompt_template=prompt_template,
+            params=params,
+        )(data)
+
+
+class DashScopeTextGenerationOperator(LLMTextGenOperator):
+    _op_type_ = opcodes.DASHSCOPE_TEXT_GENERATION
+
+
+class DashScopeMultiModalGenerationOperator(LLMTextGenOperator):
+    _op_type_ = opcodes.DASHSCOPE_MULTI_MODAL_GENERATION

maxframe/learn/contrib/llm/models/managed.py

@@ -0,0 +1,54 @@
+# 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 Any, Dict, List
+
+from ..... import opcodes
+from .....serialization.serializables import StringField
+from ..core import LLMTextGenOperator
+from ..text import TextLLM
+
+
+class ManagedLLMTextGenOperator(LLMTextGenOperator):
+    _op_type_ = opcodes.MANAGED_TEXT_MODAL_GENERATION
+
+    inference_framework: str = StringField("inference_framework", default=None)
+
+
+class ManagedTextLLM(TextLLM):
+    """
+    Managed text LLM by MaxFrame.
+    """
+
+    def __init__(self, name: str):
+        """
+        Initialize a managed text LLM.
+
+        Parameters
+        ----------
+        name : str
+            The managed text LLM name to use.
+        """
+        super().__init__(name=name)
+
+    def generate(
+        self,
+        data,
+        prompt_template: List[Dict[str, Any]],
+        params: Dict[str, Any] = None,
+        **kw
+    ):
+        return ManagedLLMTextGenOperator(
+            model=self, prompt_template=prompt_template, params=params, **kw
+        )(data)

maxframe/learn/contrib/llm/multi_modal.py

@@ -0,0 +1,135 @@
+# 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 Any, Dict
+
+from ....dataframe.core import DATAFRAME_TYPE, SERIES_TYPE
+from .core import LLM
+
+
+class MultiModalLLM(LLM):
+    def generate(
+        self,
+        data,
+        prompt_template: Dict[str, Any],
+        params: Dict[str, Any] = None,
+    ):
+        raise NotImplementedError
+
+
+def generate(
+    data,
+    model: MultiModalLLM,
+    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):
+        raise ValueError("model must be a MultiModalLLM object")
+    params = params if params is not None else dict()
+    model.validate_params(params)
+    return model.generate(data, prompt_template, params)