MaxCompute:MaxFrame AI function

Descripción general

La función de IA de MaxFrame es una solución integral para el inference offline de modelos de lenguaje grandes (LLM) en la plataforma Alibaba Cloud MaxCompute. Integra de forma transparente el procesamiento de datos con las capacidades de IA, lo que simplifica la adopción de modelos de lenguaje grandes a nivel empresarial.

• Filosofía de diseño: "Entran datos, salen resultados". Esto le permite usar el framework Python de MaxFrame y API con estilo pandas para completar todo el flujo de trabajo dentro del ecosistema de MaxCompute: desde la preparación y el procesamiento de los datos hasta el inference del modelo y el almacenamiento de los resultados.

• Casos de uso: Esta función resulta ideal para procesar volúmenes masivos de datos estructurados, como registros de análisis y de comportamiento de usuarios, así como datos no estructurados en tareas de traducción de texto, resumen de documentos y vectorización. Procesa datos a escala de petabytes en un solo trabajo y alcanza baja latencia y escalabilidad lineal gracias a su arquitectura de cómputo distribuido. Sirve para extraer información estructurada de textos, organizar y resumir contenido, generar resúmenes, traducir idiomas, evaluar la calidad textual y clasificar sentimientos. Todo esto simplifica enormemente el procesamiento de datos para modelos de lenguaje grandes y mejora la calidad de los resultados.

• Arquitectura

  La función de IA de MaxFrame ofrece una interfaz generate flexible y de propósito general, además de interfaces task concisas y específicas para escenarios como traducción de texto, extracción de datos estructurados y vectorización. Usted selecciona un modelo y proporciona como entrada una tabla de MaxCompute junto con los prompts.

  Cuando se llama a una interfaz, MaxFrame fragmenta primero los datos de la tabla de entrada. Usted establece un nivel de concurrencia adecuado según el volumen de datos e inicia un grupo de workers para ejecutar el trabajo de cómputo. Cada worker utiliza la plantilla de prompt proporcionada para representar y construir las entradas del modelo a partir de las filas de datos, ejecuta el trabajo de inference y escribe los resultados y el estado de éxito de vuelta en MaxCompute.

  A continuación se muestra la arquitectura y el flujo de trabajo.

  

• Ventajas principales:

  • Facilidad de uso: API de Python conocidas, una biblioteca de modelos lista para usarse y costo de despliegue nulo.

  • Escalabilidad: Aprovecha los recursos de cuota CU, cuota GU e Inference Quota de MaxCompute para admitir el procesamiento paralelo a gran escala y mejorar el rendimiento general de tokens.

  • Integración de datos e IA: Complete todo su flujo de trabajo en una sola plataforma, desde la lectura y el procesamiento de datos hasta el inference de IA y el almacenamiento de resultados. Esto reduce los costos de migración de datos y mejora la eficiencia de desarrollo.

  • Amplia cobertura de escenarios: Abarca más de 10 casos de uso comunes, entre ellos traducción, extracción de datos estructurados y vectorización.

Requisitos

• Regiones compatibles:

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

• Versión de Python compatible: 3.11.

• Versión del SDK compatible: Asegúrese de que la versión de su SDK de MaxFrame sea la 2.7.1 o posterior. Compruebe la versión al ejecutar uno de los comandos siguientes:

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

  Si su versión está desactualizada, ejecute pip install --upgrade maxframe para actualizar a la versión más reciente.

• Install the latest MaxFrame client.

Modelos compatibles

MaxFrame admite de forma inmediata una serie de modelos de lenguaje grandes integrados, entre ellos Qwen 3, DeepSeek-R1-Distill-Qwen y Qwen3-embedding. También permite llamar a modelos comerciales insignia de Model Studio, como los modelos multimodales qwen3.7-max, qwen3.6-plus, qwen3.6-flash, deepseek-v4-pro, deepseek-v4-flash y qwen3-vl-embedding, además del modelo de texto text-embedding-v4. Todos los modelos se alojan de manera offline dentro de la plataforma MaxCompute. Así se elimina la necesidad de gestionar descargas de modelos, su distribución o los límites de concurrencia de API. Usted utiliza los modelos mediante llamadas simples a la API, lo que le permite aprovechar los enormes recursos de cómputo de MaxCompute para completar tareas de inference offline con alta concurrencia y un gran rendimiento general de tokens.

# 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"

Referencia de API

La función de IA de MaxFrame proporciona dos interfaces para equilibrar flexibilidad y facilidad de uso: la interfaz de propósito general generate y las interfaces específicas de tarea task.

Casos de uso

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.")

Optimización del rendimiento