Entraîner et prédire avec un modèle XGBoost à l'aide de MaxCompute - MaxCompute

Fonctionnement

Cette rubrique présente deux flux de travail complémentaires :

Flux de travail	Moteur	Public cible
Entraînement et prédiction avec MaxFrame	Python (API MaxFrame)	Ingénieurs algorithmes développant en Python
Prédiction avec SQL	SQL (fonction `ML_PREDICT`)	Équipes analytiques développant en SQL

Les deux flux utilisent le même objet de modèle MaxCompute. Les résultats sont identiques, quel que soit le moteur utilisé. Cette approche élimine les coûts d'intégration dans les environnements inter-équipes où les ingénieurs algorithmes privilégient Python et les équipes analytiques préfèrent SQL.

Concepts clés

XGBoost est un algorithme d'apprentissage par ensemble basé sur un framework de gradient boosting. Il construit itérativement des arbres de décision, utilise des dérivées secondes pour optimiser la fonction objectif et combine leurs sorties au sein d'un modèle additif, capturant ainsi efficacement les relations complexes et non linéaires des données structurées.

Jeu de données

Cette rubrique utilise le jeu de données Boston Housing, qui décrit les conditions de logement dans la région de Boston durant les années 1970.

Données d'entraînement : 500 échantillons, 12 colonnes de caractéristiques, 1 colonne cible (MEDV)
Données de prédiction : 6 échantillons, mêmes 12 colonnes de caractéristiques

N°	Champ	Type	Description
1	CRIM	Float	Taux de criminalité par habitant et par ville
2	ZN	Float	Proportion de terrains résidentiels zonés pour des lots >25 000 pieds carrés
3	INDUS	Float	Proportion d'acres commerciaux hors vente au détail par ville
4	CHAS	Integer	Rivière adjacente (1=oui, 0=non)
5	NOX	Float	Concentration d'oxydes nitriques (ppm)
6	RM	Float	Nombre moyen de pièces par logement
7	AGE	Float	Proportion de logements occupés par leur propriétaire construits avant 1940
8	DIS	Float	Distances pondérées jusqu'à cinq centres d'emploi de Boston
9	RAD	Integer	Indice d'accessibilité aux autoroutes radiales
10	TAX	Float	Taux d'imposition foncière pleine valeur pour 10 000 USD
11	PTRATIO	Float	Ratio élèves-enseignants par ville
12	LSTAT	Float	Pourcentage de population de statut inférieur
13	MEDV	Float	Valeur médiane des logements occupés par leur propriétaire en milliers d'USD (variable cible)

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

Un projet MaxCompute actif avec la syntaxe de schéma activée. Si vous n'avez pas encore créé de projet, consultez Créer un projet MaxCompute
Les dernières versions de MaxFrame, scikit-learn et xgboost installées dans votre environnement Python local. Pour obtenir des instructions de configuration, consultez Utiliser MaxFrame dans un environnement local

Préparer les données

Créez les tables de données d'entraînement, d'entrée de prédiction et de résultat de prédiction.

-- Training data table
CREATE TABLE IF NOT EXISTS demo_xgboost_train
(
 CRIM         FLOAT comment 'Per capita crime rate by town',
 ZN           FLOAT comment 'Proportion of residential land zoned for lots >25,000 sq. ft.',
 INDUS        FLOAT comment 'Proportion of non-retail business acres per town',
 CHAS         INT   comment 'Bounds river (1=yes, 0=no)',
 NOX          FLOAT comment 'Nitric oxides concentration (ppm)',
 RM           FLOAT comment 'Average number of rooms per dwelling',
 AGE          FLOAT comment 'Proportion of owner-occupied units built before 1940',
 DIS          FLOAT comment 'Weighted distances to five Boston employment centers',
 RAD          FLOAT comment 'Index of accessibility to radial highways',
 TAX          FLOAT comment 'Full-value property-tax rate per USD 10,000',
 PTRATIO      FLOAT comment 'Pupil-teacher ratio by town',
 LSTAT        FLOAT comment 'Percentage of lower status of the population',
 MEDV         FLOAT comment 'Median value of owner-occupied homes in thousands of USD'
);

-- Prediction input table (no MEDV column)
CREATE TABLE IF NOT EXISTS demo_xgboost_predict
(
 CRIM         FLOAT comment 'Per capita crime rate by town',
 ZN           FLOAT comment 'Proportion of residential land zoned for lots >25,000 sq. ft.',
 INDUS        FLOAT comment 'Proportion of non-retail business acres per town',
 CHAS         INT   comment 'Bounds river (1=yes, 0=no)',
 NOX          FLOAT comment 'Nitric oxides concentration (ppm)',
 RM           FLOAT comment 'Average number of rooms per dwelling',
 AGE          FLOAT comment 'Proportion of owner-occupied units built before 1940',
 DIS          FLOAT comment 'Weighted distances to five Boston employment centers',
 RAD          FLOAT comment 'Index of accessibility to radial highways',
 TAX          FLOAT comment 'Full-value property-tax rate per USD 10,000',
 PTRATIO      FLOAT comment 'Pupil-teacher ratio by town',
 LSTAT        FLOAT comment 'Percentage of lower status of the population'
);

-- MaxFrame prediction result table (uses DOUBLE types and adds a RESULT column)
CREATE TABLE IF NOT EXISTS demo_xgboost_predict_result
(
 CRIM         DOUBLE comment 'Per capita crime rate by town',
 ZN           DOUBLE comment 'Proportion of residential land zoned for lots >25,000 sq. ft.',
 INDUS        DOUBLE comment 'Proportion of non-retail business acres per town',
 CHAS         BIGINT comment 'Bounds river (1=yes, 0=no)',
 NOX          DOUBLE comment 'Nitric oxides concentration (ppm)',
 RM           DOUBLE comment 'Average number of rooms per dwelling',
 AGE          DOUBLE comment 'Proportion of owner-occupied units built before 1940',
 DIS          DOUBLE comment 'Weighted distances to five Boston employment centers',
 RAD          DOUBLE comment 'Index of accessibility to radial highways',
 TAX          DOUBLE comment 'Full-value property-tax rate per USD 10,000',
 PTRATIO      DOUBLE comment 'Pupil-teacher ratio by town',
 LSTAT        DOUBLE comment 'Percentage of lower status of the population',
 RESULT       DOUBLE comment 'Predicted value of owner-occupied homes'
);

Téléchargez les fichiers CSV d'exemple et importez-les dans MaxCompute à l'aide de l'API Tunnel.

Téléchargement :
- xgboost_train_data.csv
- xgboost_predict.csv
Importation :
```
TUNNEL UPLOAD xgboost_train_data.csv demo_xgboost_train;
TUNNEL UPLOAD xgboost_predict.csv demo_xgboost_predict;
```

Entraîner et enregistrer le modèle

Exécutez le script Python suivant pour initialiser une session MaxFrame, entraîner un XGBRegressor sur les données d'entraînement Boston Housing et enregistrer le modèle en tant qu'objet de modèle MaxCompute versionné.

# --- Session initialization ---
from odps import ODPS
import maxframe
from maxframe.config import options

o = ODPS(
    '<your-access-key-id>',
    '<your-access-key-secret>',
    '<your-project-name>',
    '<your-endpoint>',
)

# --- Engine configuration ---
options.sql.enable_mcqa = False
# Use the DPE engine first, fall back to MCSQL, then SPE.
options.dag.settings = {
    "engine_order": ["DPE", "MCSQL", "SPE"]
}
options.dpe.settings = {
    "odps.catalog_api_endpoint": "<catalog-api-endpoint>",
}
options.sql.settings = {
    "odps.session.image": "common",
}
options.service_role_arn = "acs:ram::13933481********:role/aliyunodpsdefaultrole"
options.object_cache_url = "oss://oss-cn-beijing-internal.aliyuncs.com/models-*******/mfdemo"

sess = maxframe.new_session(o)
print(sess.get_logview_address())

# --- Model training ---
import numpy as np
import maxframe.dataframe as md
from maxframe.learn.contrib.xgboost import XGBRegressor

table_name = "demo_xgboost_train"
features = ['crim', 'zn', 'indus', 'chas', 'nox', 'rm', 'age', 'dis', 'rad', 'tax', 'ptratio', 'lstat']
label = 'medv'

# Read training data from MaxCompute.
df = md.read_odps_table(table_name, unknown_as_string=True)

# Separate features and label; fill missing values with -1.
X_train = df[features].fillna(-1)
y_train = df[label]

# Train the XGBoost regression model.
model = XGBRegressor(
    n_estimators=300,
    learning_rate=0.1,
    colsample_bytree=0.8,
    n_jobs=-1,
    tree_method="hist",
    enable_categorical=True,
    objective='reg:squarederror'
)

# Save the trained model as a versioned MaxCompute model object.
model.fit(X_train, y_train).to_odps_model(
    model_name="demo_model_xgboost_regressor",
    model_version="v01",
).execute()

Remplacez les espaces réservés par vos valeurs réelles :

Espace réservé	Description	Exemple
`<your-access-key-id>`	ID AccessKey Alibaba Cloud	`LTAI5tXxx`
`<your-access-key-secret>`	Secret AccessKey Alibaba Cloud	`xXxXxXx`
`<your-project-name>`	Nom du projet MaxCompute	`my_project`
`<your-endpoint>`	Endpoint MaxCompute	`http://service.cn-hangzhou.maxcompute.aliyun.com/api`
`<catalog-api-endpoint>`	Endpoint Catalog API pour le moteur DPE	Fourni lors de l'activation de la fonctionnalité

Vérifier le modèle enregistré

Exécutez DESC model pour confirmer que le modèle a été correctement enregistré.

DESC model demo_model_xgboost_regressor;

Résultat attendu :

+------------------------------------------------------------------------------------+
|                  Model Information                                                 |
+------------------------------------------------------------------------------------+
| Owner:                    ALIYUN$***********************                           |
| Project:                  pd_test_model                                            |
| Schema:                   default                                                  |
| Model Name:               demo_model_xgboost_regressor                            |
| Model Type:               BOOSTED_TREE_REGRESSOR                                  |
| Source Type:              INTERNAL_TRAIN                                           |
| Default Version:          v01                                                      |
| CreateTime:               2025-09-12 13:15:16                                      |
| LastModifiedTime:         2025-09-12 13:15:16                                      |
| Model ID:                 389c90e355264079923b89**********                         |
+------------------------------------------------------------------------------------+
|                Version Information                                                 |
+------------------------------------------------------------------------------------+
| Owner:                    ALIYUN$***********************                           |
| Project:                  pd_test_model                                            |
| Schema:                   default                                                  |
| Model Name:               demo_model_xgboost_regressor                            |
| Model Type:               BOOSTED_TREE_REGRESSOR                                  |
| Source Type:              INTERNAL_TRAIN                                           |
| Version Name:             v01                                                      |
| Version ID:               99acd6cb93f845c8a4a9977*********                        |
| Path:                                                                              |
| CreateTime:               2025-09-12 13:15:16                                      |
| LastModifiedTime:         2025-09-12 13:15:16                                      |
+------------------------------------------------------------------------------------+
| Input           | Type       | Comment                                             |
+------------------------------------------------------------------------------------+
| crim            | float      |                                                     |
| zn              | float      |                                                     |
| indus           | float      |                                                     |
| chas            | int        |                                                     |
| nox             | float      |                                                     |
| rm              | float      |                                                     |
| age             | float      |                                                     |
| dis             | float      |                                                     |
| rad             | float      |                                                     |
| tax             | float      |                                                     |
| ptratio         | float      |                                                     |
| lstat           | float      |                                                     |
+------------------------------------------------------------------------------------+

Prédire avec MaxFrame

Après l'entraînement, utilisez la même session MaxFrame pour exécuter l'inférence et écrire les résultats dans une table de destination.

# Define the prediction input and output tables.
predict_table = "demo_xgboost_predict_mf"
predict_result_table = "demo_xgboost_predict_result"

# Read prediction data.
predict_data = md.read_odps_table(predict_table, unknown_as_string=True)
X_predict = predict_data[features].fillna(-1)
y_predict = model.predict(X_predict)

# Build the result DataFrame with the predicted column.
df_predict = predict_data[features].copy()
df_predict['predicted_medv'] = y_predict.astype(np.float64)

# Write results to MaxCompute.
df_predict.to_odps_table(
    predict_result_table,
    overwrite=True,
    index=False,
    unknown_as_string=True
).execute()

Interrogez la table de destination pour consulter la sortie :

SELECT * FROM demo_xgboost_predict_result LIMIT 10;

Résultat attendu :

+------------+------------+------------+------------+------------+------------+------------+------------+------------+------------+------------+------------+------------+
| crim       | zn         | indus      | chas       | nox        | rm         | age        | dis        | rad        | tax        | ptratio    | lstat      | result     |
+------------+------------+------------+------------+------------+------------+------------+------------+------------+------------+------------+------------+------------+
| 0.22438    | 0.0        | 9.69       | 0          | 0.585      | 6.027      | 79.7       | 2.4982     | 6.0        | 391.0      | 19.2       | 14.33      | 20.03961181640625      |
| 0.06263    | 0.0        | 11.93      | 0          | 0.573      | 6.593      | 69.1       | 2.4786     | 1.0        | 273.0      | 21.0       | 9.67       | 24.491479873657227     |
| 0.04527    | 0.0        | 11.93      | 0          | 0.573      | 6.12       | 76.7       | 2.2875     | 1.0        | 273.0      | 21.0       | 9.08       | 24.683202743530273     |
| 0.06076    | 0.0        | 11.93      | 0          | 0.573      | 6.976      | 91.0       | 2.1675     | 1.0        | 273.0      | 21.0       | 5.64       | 32.33962631225586      |
| 0.10959    | 0.0        | 11.93      | 0          | 0.573      | 6.794      | 89.3       | 2.3889     | 1.0        | 273.0      | 21.0       | 6.48       | 28.45917510986328      |
| 0.04741    | 0.0        | 11.93      | 0          | 0.573      | 6.03       | 80.8       | 2.505      | 1.0        | 273.0      | 21.0       | 7.88       | 24.43267822265625      |
+------------+------------+------------+------------+------------+------------+------------+------------+------------+------------+------------+------------+------------+

Prédire avec SQL

Utilisez ML_PREDICT pour exécuter l'inférence directement en SQL, sans environnement Python. La fonction prend le nom du modèle, la version et les colonnes de caractéristiques comme arguments, dans le même ordre que les données d'entraînement.

SET odps.sql.type.system.odps2=true;
SET odps.task.major.version=sqlml_master;
SET odps.sql.machine.learning.enable=true;

SELECT ML_PREDICT(demo_model_xgboost_regressor,v01,crim,zn,indus,chas,nox,rm,age,dis,rad,tax,ptratio,lstat)
FROM demo_xgboost_predict;

Important

Transmettez les colonnes de caractéristiques dans le même ordre que les données d'entraînement. La fonction renvoie une seule colonne de prédiction nommée _c0.

Résultat attendu :

+------------+
| _c0        |
+------------+
| 20.039612  |
| 24.49148   |
| 24.683203  |
| 32.339626  |
| 28.459175  |
| 24.432678  |
+------------+

Les résultats de ML_PREDICT correspondent aux prédictions MaxFrame pour les mêmes données d'entrée, ce qui confirme que les deux moteurs produisent une inférence cohérente à partir du même objet de modèle.