MaxCompute:MaxFrame AI function

Présentation

La fonction IA MaxFrame constitue une solution de bout en bout pour l'inférence hors ligne de grands modèles de langage (LLM) sur la plateforme Alibaba Cloud MaxCompute. Elle intègre le traitement des données aux capacités d'intelligence artificielle, simplifiant ainsi l'adoption des grands modèles de langage en entreprise.

• Philosophie de conception : « Des données en entrée, des résultats en sortie ». Ce principe permet d'utiliser le framework Python MaxFrame et des API de style pandas pour réaliser l'ensemble du flux de travail, de la préparation et du traitement des données jusqu'à l'inférence du modèle et au stockage des résultats, directement au sein de l'écosystème MaxCompute.

• Cas d'usage : Cette fonction est idéale pour traiter des volumes massifs de données structurées (analyse de journaux, logs de comportement utilisateur) et non structurées (traduction de textes, résumé de documents, vectorisation). Elle traite des données à l'échelle du pétaoctet en un seul job, offrant une faible latence et une scalabilité linéaire grâce à son architecture de calcul distribué. Vous pouvez extraire des informations structurées à partir de textes, organiser et résumer du contenu, générer des résumés, traduire des langues, évaluer la qualité des textes et classifier les sentiments. Cela simplifie considérablement le traitement des données pour les grands modèles de langage et améliore la qualité des résultats.

• Architecture

  La fonction IA MaxFrame fournit une interface generate flexible et polyvalente, ainsi que des interfaces task concises et spécifiques, adaptées à des scénarios tels que la traduction de textes, l'extraction de données structurées et la vectorisation. Sélectionnez un modèle et fournissez une table MaxCompute ainsi que des prompts en entrée.

  Lors de l'appel d'une interface, MaxFrame fragmente d'abord les données de la table d'entrée. Définissez un niveau de concurrence approprié selon le volume de données et lancez un groupe de workers pour exécuter le job de calcul. Chaque worker utilise le modèle de prompt fourni pour formater et construire les entrées du modèle à partir des lignes de données, exécute le job d'inférence, puis écrit les résultats et le statut de succès dans MaxCompute.

  La figure suivante illustre l'architecture et le flux de travail.

  

• Avantages clés :

  • Facilité d'utilisation : API Python familières, bibliothèque de modèles prête à l'emploi et coût de déploiement nul.

  • Scalabilité : Exploite les ressources de quota CU, de quota GU et d'Inference Quota de MaxCompute pour prendre en charge le traitement parallèle à grande échelle et augmenter le débit global de tokens.

  • Intégration Données et IA : Réalisez l'intégralité de votre flux de travail, de la lecture et du traitement des données à l'inférence IA et au stockage des résultats, sur une seule plateforme. Cela réduit les coûts de migration des données et améliore l'efficacité du développement.

  • Large couverture de scénarios : Couvre plus de 10 cas d'usage courants, dont la traduction, l'extraction de données structurées et la vectorisation.

Prérequis

• Régions prises en charge :

  China (Hangzhou), China (Shanghai), China (Beijing), China (Ulanqab), China (Shenzhen), China (Chengdu), China (Hong Kong), China (Hangzhou) Finance Cloud et China (Shanghai) Finance Cloud.

• Version Python prise en charge : 3,11.

• Version SDK prise en charge : Assurez-vous que votre version du SDK MaxFrame est 2.7.1 ou ultérieure. Vérifiez la version en exécutant l'une des commandes suivantes :

  // For Windows
  pip list | findstr maxframe
  
  // For Linux
  pip list | grep maxframe

  Si votre version est obsolète, exécutez pip install --upgrade maxframe pour passer à la dernière version.

• Installer le dernier client MaxFrame.

Modèles pris en charge

MaxFrame offre une prise en charge native d'une série de grands modèles de langage intégrés, notamment Qwen 3,DeepSeek-R1-Distill-Qwen et Qwen3-embedding. Il permet également d'appeler des modèles phares commerciaux de Model Studio, tels que les modèles multimodaux qwen3.7-max,qwen3.6-plus,qwen3.6-flash,deepseek-v4-pro,deepseek-v4-flash et qwen3-vl-embedding, ainsi que le modèle de texte text-embedding-v4. Tous ces modèles sont hébergés hors ligne au sein de la plateforme MaxCompute. Vous n'avez donc pas à gérer le téléchargement des modèles, leur distribution ni les limites de concurrence des API. Utilisez les modèles via de simples appels d'API afin de tirer parti des ressources de calcul massives de MaxCompute pour accomplir des tâches d'inférence hors ligne avec un débit global de tokens et une concurrence élevés.

# Use CU quota compute resources.
options.session.quota_name = "mf_cpu_quota"

# Use GU quota compute resources.
options.session.gu_quota_name = "mf_gpu_quota"

Référence API

La fonction IA MaxFrame fournit deux interfaces pour allier flexibilité et facilité d'utilisation : l'interface généraliste generate et les interfaces task spécifiques à chaque tâche.

Cas d'usage

import os
import maxframe.dataframe as md
from maxframe import new_session
from maxframe.config import options
from maxframe.udf import with_running_options
from odps import ODPS

options.dag.settings = {
    "engine_order": ["DPE", "MCSQL"]
}

o = ODPS(
    os.getenv('ALIBABA_CLOUD_ACCESS_KEY_ID'),
    os.getenv('ALIBABA_CLOUD_ACCESS_KEY_SECRET'),
    project='your-default-project',
    endpoint='your-end-point',
)

# Initialize the MaxFrame session.
session = new_session(o)

# Print the Logview URL for the job.
print(session.get_logview_address())

# 1. Use GU quota compute resources.
options.session.gu_quota_name = "mf_gu_quota"

# 2. Use the Qwen3-1.7B model.
from maxframe.learn.contrib.llm.models.managed import ManagedTextLLM

llm = ManagedTextLLM(name="Qwen3-1.7B")

# 3. Prepare the data. You can skip this step if you already have data.
# o.execute_sql("""
#   CREATE TABLE IF NOT EXISTS raw_contracts (
#       en STRING
#   );
#   """)
# 
# o.execute_sql("""
#   INSERT INTO raw_contracts VALUES
#   ('This agreement is governed by the laws of the State of California.'),
#   ('The tenant shall pay rent on the first day of each month.'),
#   ('Either party may terminate this contract with 30 days written notice.'),
#   ('All intellectual property rights shall remain with the original owner.'),
#   ('The warranty period for this product is twelve months from the date of purchase.');
#   """)

df = md.read_odps_table("raw_contracts")

# 4. Define the prompt template.
messages = [
    {
        "role": "system",
        "content": "You are a document translation expert who can fluently translate English text into Chinese.",
    },
    {
        "role": "user",
        "content": "Translate the following English text into Chinese. Output only the translated text, with no other content.\n\n Example:\nInput: Hi\nOutput: 你好。\n\n Text to translate:\n\n{en}",
    },
]

# 5. Call the `generate` interface, define the prompt, and reference the corresponding data column.
result_df = llm.generate(
    df,
    prompt_template=messages,
    params={
        "temperature": 0.7,
        "top_p": 0.8,
    },
).execute()

# 6. Write the results to a MaxCompute table.
result_df.to_odps_table("raw_contracts_result")

import maxframe.dataframe as md
from maxframe import new_session
from maxframe.config import options
from maxframe.udf import with_running_options
from odps import ODPS

options.dag.settings = {
    "engine_order": ["DPE", "MCSQL"]
}

o = ODPS(
    os.getenv('ALIBABA_CLOUD_ACCESS_KEY_ID'),
    os.getenv('ALIBABA_CLOUD_ACCESS_KEY_SECRET'),
    project='your-default-project',
    endpoint='your-end-point',
)

# Initialize the MaxFrame session.
session = new_session(o)

# Print the Logview URL for the job.
print(session.get_logview_address())

# 1. Use GU quota compute resources.
options.session.gu_quota_name = "mf_gu_quota"

# 2. Use the Qwen3-4B model.
from maxframe.learn.contrib.llm.models.managed import ManagedTextLLM

llm = ManagedTextLLM(name="Qwen3-4B-Instruct-2507-FP8")

df = md.read_odps_table("traditional_chinese_medicine", index_col="index")

# Specify four concurrent partitions.
parallel_partitions = 4
df = df.mf.rebalance(num_partitions=parallel_partitions)

# 3. Use the preset `extract` task interface.
result_df = llm.extract(
    df["text"],
    description="Please extract structured data from the following medical record in order. Return the final output in strict JSON format according to the schema.",
    schema=MedicalRecord,
    examples=[(example_input, example_output)],
)
result_df.execute()

import os
import maxframe.dataframe as md
from maxframe import new_session
from maxframe.config import options
from maxframe.udf import with_running_options
from odps import ODPS

options.dag.settings = {
    "engine_order": ["DPE", "MCSQL"]
}

o = ODPS(
    os.getenv('ALIBABA_CLOUD_ACCESS_KEY_ID'),
    os.getenv('ALIBABA_CLOUD_ACCESS_KEY_SECRET'),
    project='your-default-project',
    endpoint='your-end-point',
)

# Initialize a MaxFrame session.
session = new_session(o)

# Print the Logview URL of the job.
print(session.get_logview_address())

# 1. Create a text-embedding-v4 model instance (using Inference Quota).
# Load the text-embedding-v4 model from the public model set.
from maxframe.learn.utils import read_odps_model

llm = read_odps_model("text-embedding-v4", project="bigdata_public_modelset")

# 2. Read data.
df = md.read_odps_table("user_feedback_table")

# 3. Perform vectorization.
result_df = llm.embed(
    df["query"],
    running_options={"max_tokens": 1024, "verbose": True},
    simple=True,
).execute()

# 4. Write the results to a MaxCompute table.
result_df.to_odps_table("feedback_analysis_result")

import os

import pandas as pd
import maxframe.dataframe as md
from maxframe import new_session
from maxframe.config import options
from maxframe.learn.contrib.llm import ImageContentType
from maxframe.learn.utils import read_odps_model
from odps import ODPS

# Configure the execution engine: DPE first.
options.dag.settings = {
    "engine_order": ["DPE", "MCSQL"],
}

# 1. Create an ODPS connection.
o = ODPS(
    os.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID"),
    os.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET"),
    project="<your-project-name>",
    endpoint="<your-endpoint>",  # Example: https://service.cn-shanghai.maxcompute.aliyun.com/api
)

# 2. Configure the engine and create a session.
# Model Studio VL model inference runs on the DPE engine and is billed by token consumption.
# No CU/GU resource provisioning is required.

# Create a MaxFrame session.
session = new_session(o)
print(f"Session ID: {session.session_id}")
print(f"Logview: {session.get_logview_address()}")

## 3. Load the Model Studio VL model.
# Load the pre-registered multimodal understanding model from the MaxCompute public model set.
image_llm = read_odps_model(
    "qwen3.6-plus", project="bigdata_public_modelset", odps_entry=o
)

## 4. Prepare OSS image data.
# Use the `oss:////` format and pass OSS access credentials through `storage_options`.
# OSS configuration.
OSS_ENDPOINT = "oss-cn-shanghai-internal.aliyuncs.com"  # Replace with your OSS Endpoint.
OSS_BUCKET = "your-bucket"                              # Replace with your Bucket name.
OSS_PREFIX = "images"                                   # Replace with the image path prefix.

storage_options = {
    "access_key_id": os.getenv("OSS_ACCESS_KEY_ID"),
    "access_key_secret": os.getenv("OSS_ACCESS_KEY_SECRET"),
}

# Construct the list of image URLs.
image_urls = [
    f"oss://{OSS_ENDPOINT}/{OSS_BUCKET}/{OSS_PREFIX}/image{i}.jpg"
    for i in range(1, 9)
]

df = md.DataFrame({"image_url": image_urls})
df.execute()

## 5. Call the VL model for image understanding.
# Use the `generate()` interface to pass a text prompt and OSS images to the model.

cp = image_llm.content_part

result_df = image_llm.generate(
    df,
    messages=[
        {
            "role": "user",
            "content": [
                cp.text("Describe this image in one sentence."),
                cp.image(
                    data=df.image_url,
                    type=ImageContentType.IMAGE_URL,
                    storage_options=storage_options,
                ),
            ],
        }
    ],
    simple_output=True,
    params={"max_tokens": 128},
)

## 6. Run inference and view the results.
# MaxFrame uses lazy execution. Call `.execute()` to trigger the actual computation.
result = result_df.execute()
print(result)

## 7. Clean up resources.
session.destroy()
print("Session destroyed.")

Optimisation des performances