MaxCompute:MaxFrame AI Function

Language translation

Scenario: A multinational corporation needs to translate 100,000 English contracts into Chinese and annotate key clauses.

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 the user's English text into Chinese.",
    },
    {
        "role": "user",
        "content": "Please 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")

Keyword extraction

Scenario: This use case demonstrates how MaxFrame AI Function processes unstructured data. A large portion of unstructured data consists of text and images, which pose significant challenges for big data analytics. The following example shows how to use AI Function to simplify this process.

The following code demonstrates how to use AI Function to extract a candidate's work experience from resumes. The example uses randomly generated resume text for the input data. For detailed best practices and demos, see AI Function on GU Development Practices.

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()

Text vectorization: text-embedding-v4

Scenario description: Use the Model Studio (Bailian) commercial model text-embedding-v4 to perform vectorization tasks. Billing is based on token consumption, which eliminates the need to manage underlying computing resources. This scenario is suitable for complex text analysis and high-quality inference tasks that require large models or commercial large language models (LLMs) from Model Studio (Bailian).

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. Use Token Quota computing resources
options.session.inference_quota_name = "mf_token_quota"

# 2. Create a text-embedding-v4 model instance (using Token Quota)
# Load the text-embedding-v4 model from the Model Studio (Bailian) public model set
from maxframe.learn.utils import read_odps_model

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

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

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

# 6. Write the result to a MaxCompute table
result_df.to_odps_table("feedback_analysis_result")

VL multimodal image understanding: Qwen3.6-Plus

Scenario description: This scenario is suitable for high-quality inference and complex text analysis or multimodal data processing tasks that require large models or commercial LLMs from Model Studio (Bailian). Resources are consumed on demand, keeping costs controllable.

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"],
}

# Use Token Quota computing resources (Model Studio commercial models)
options.session.inference_quota_name = "<your-token-quota-name>"

# 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, 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()}")

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

## 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://<endpoint>/<bucket>/<path>` 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"),
}

# Build the image URL list
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 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")