Platform For AI:Comment intégrer le système de test A/B à votre système

Se connecter à la console PAI-Rec

Dans la console PAI-Rec, cliquez sur Full-link Service dans le volet de navigation de gauche. Dans l'assistant Service Initialization qui s'affiche, configurez vos espaces de travail.

Notes de configuration :

1. Recherchez les espaces de travail existants depuis Platform for AI (PAI), DataWorks et MaxCompute dans leurs consoles respectives. Sur la page d'accueil de chaque produit, cliquez sur Console.

2. Créez un bucket OSS dans la console OSS avant de le configurer ici.

Accorder l'accès à MaxCompute

Sur la page Projects , recherchez le projet MaxCompute que vous souhaitez utiliser.

Si aucun projet n'apparaît, sélectionnez d'abord la région appropriée.

Dans la colonne Actions du projet, cliquez sur Manage. Accordez à PAI-Rec un accès direct et des autorisations d'écriture sur le projet MaxCompute.

Pour plus de détails, consultez Activation et initialisation du service.

Créer un laboratoire

1. Sélectionnez un environnement d'exécution et un scénario de recommandation.

2. Cliquez sur Create Lab .

3. Dans le panneau Create Lab , configurez les paramètres suivants :

Créer un groupe d'expériences

Chaque couche d'expérience peut comporter plusieurs groupes d'expériences, et chaque groupe peut contenir plusieurs expériences. Utilisez des groupes distincts lorsque plusieurs ingénieurs doivent exécuter des expériences sur la même couche (par exemple, différents algorithmes de rappel) sans interférence mutuelle.

Groupe de test A/A (recommandé pour les nouvelles expériences) :

Pour valider que la configuration de votre expérience est impartiale, créez un groupe de test A/A avant d'exécuter des expériences réelles :

1. Sélectionnez 4 à 5 segments pour l'expérience.

2. Attribuez 2 segments à un groupe sans politique configurée. Exécutez ces segments en tant que test à blanc et surveillez les métriques clés.

3. Utilisez les deux groupes dont les métriques sont les plus similaires pour votre test A/B réel.

Paramètres supplémentaires du groupe d'expériences :

Créer une expérience

Cliquez sur Create Experiment . Par défaut, une expérience de référence est créée en premier.

Stratégies d'allocation du trafic :

Après avoir configuré tous les paramètres, cliquez sur Save .

SDK Python

pip install https://aliyun-pairec-config-sdk.oss-cn-hangzhou.aliyuncs.com/python/aliyun_pairec_config_python_sdk-1.0.0-py2.py3-none-any.whl

export ALIBABA_CLOUD_ACCESS_KEY_ID=<your-access-key-id>
export ALIBABA_CLOUD_ACCESS_KEY_SECRET=<your-access-key-secret>

import os
from alibabacloud_tea_openapi.models import Config
from api.api_scene import SceneApiService
from api.api_experiment_room import ExperimentRoomApiService
from api.api_layer import api_layer
from api.api_experiment_group import ExperimentGroupApiService
from api.api_experiment import ExperimentApiService
from client.client import ExperimentClient
from model.experiment import ExperimentContext
from api.api_crowd import CrowdApiService
from alibabacloud_pairecservice20221213.client import Client
from common.constants import ENVIRONMENT_PRODUCT_CONFIG_CENTER
from common.constants import ENVIRONMENT_PREPUB_CONFIG_CENTER
from common.constants import ENVIRONMENT_DAILY_CONFIG_CENTER

# Instance details — find these on the Basic Information page in the PAI-Rec console
instance_id = "<instance-id>"
region = "<region-id>"

# Read credentials from environment variables
access_id = os.environ['ALIBABA_CLOUD_ACCESS_KEY_ID']
access_key = os.environ['ALIBABA_CLOUD_ACCESS_KEY_SECRET']

if __name__ == '__main__':
    # Valid environments: ENVIRONMENT_PRODUCT_CONFIG_CENTER, ENVIRONMENT_PREPUB_CONFIG_CENTER, ENVIRONMENT_DAILY_CONFIG_CENTER
    experiment = ExperimentClient(
        instance_id=instance_id,
        region=region,
        access_key_id=access_id,
        access_key_secret=access_key,
        environment=ENVIRONMENT_PRODUCT_CONFIG_CENTER
    )

    # Build the request context
    # request_id: any unique identifier (auto-increment ID or UUID)
    # uid: the user ID to assign to an experiment
    experiment_context = ExperimentContext(
        request_id="<request-id>",
        uid="<user-id>",
        filter_params={}
    )

    # Match the user to an experiment in the specified scenario
    # Find the scenario name on the Recommendation Scenarios page
    experiment_result = experiment.match_experiment("<scenario-name>", experiment_context)

    # Log experiment assignment details
    print('info', experiment_result.info())

    # Store exp_id in your event tracking logs for metric calculation
    print('exp_id', experiment_result.get_exp_id())

    # Read experiment parameters to determine which algorithm variant to run
    print(experiment_result.get_experiment_params())
    print(experiment_result.get_experiment_params().get('url', 'not exist'))
    print(experiment_result.get_experiment_params().get('token', 'not exist'))

info exp_id=<exp_id> ...
exp_id <exp_id>
{'url': 'https://...', 'token': '...'}
https://...
...

SDK Java

package com.aliyun.openservices.pairec;

import com.aliyun.openservices.pairec.api.ApiClient;
import com.aliyun.openservices.pairec.api.Configuration;
import com.aliyun.openservices.pairec.common.Constants;
import com.aliyun.openservices.pairec.model.ExperimentContext;
import com.aliyun.openservices.pairec.model.ExperimentResult;

public class ExperimentTest {
    static ExperimentClient experimentClient;

    public static void main(String[] args) throws Exception {
        // Instance details — find regionId and instanceId on the Basic Information page
        String regionId = "<region-id>";
        String instanceId = System.getenv("Instance ID"); // pai-rec instance ID

        // Read credentials from environment variables
        String accessId = System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID");
        String accessKey = System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET");

        Configuration configuration = new Configuration(regionId, accessId, accessKey, instanceId);
        // Set the experiment environment
        configuration.setEnvironment(Constants.Environment_Product_Desc);

        ApiClient apiClient = new ApiClient(configuration);
        experimentClient = new ExperimentClient(apiClient);
        // Initialize the client
        experimentClient.init();

        // Build the request context
        ExperimentContext experimentContext = new ExperimentContext();
        experimentContext.setUid("<user-id>");
        experimentContext.setRequestId("<request-id>");

        // Match the user to an experiment in the specified scenario
        ExperimentResult experimentResult = experimentClient.matchExperiment("<scenario-name>", experimentContext);

        // Store exp_id in your event tracking logs for metric calculation
        System.out.println(experimentResult.getExpId());
        // Log experiment assignment details
        System.out.println(experimentResult.info());

        // Read experiment parameters to determine which algorithm variant to run
        System.out.println(experimentResult.getExperimentParams().getString("rank_version", "not exist"));
        System.out.println(experimentResult.getExperimentParams().getString("version", "not exist"));
        System.out.println(experimentResult.getExperimentParams().getString("recall", "not exist"));
        System.out.println(experimentResult.getExperimentParams().getDouble("recall_d", 0.0));

        // Read parameters for a specific experiment layer by name
        System.out.println(experimentResult.getLayerParams("recall").getString("rank_version", "not exist"));
        System.out.println(experimentResult.getLayerParams("rank").getString("version", "not exist"));
    }
}

Enregistrer une table de données

Dans la console PAI-Rec, accédez à Metric Management > Data Registration . Associez une table MaxCompute à votre instance de test A/B. Définissez Data Table Name sur un nom qui reflète le contexte métier.

Sélectionnez une table contenant les champs requis. Pour les exigences relatives aux champs, consultez Enregistrement des données et configuration des champs .

Si votre projet MaxCompute ne dispose pas d'une table contenant tous les champs requis, créez-en une :

1. Connectez-vous à la console MaxCompute et créez une table de données.

2. Dans DataWorks, créez une table source pour les rapports d'expérience de test A/B dans MaxCompute.

Après l'enregistrement, la table apparaît dans la liste des tables de données. Cliquez sur View Fields dans la colonne Actions pour inspecter ou modifier les mappages de champs.

Types de métriques

PAI-Rec prend en charge trois catégories de métriques :

De plus, faites la distinction entre :

• Métriques clés (KPI) : les principaux résultats que l'expérience vise à améliorer

• Métriques indispensables : métriques qui doivent être observées pendant un test ; la capacité testée ne doit pas les affecter négativement

Configurer les métriques

Sur la page Metric Configurations , cliquez sur Metrics . Définissez les paramètres Recommendation Scenario et Metric Timeliness.

Les métriques à dimension unique sont calculées à partir d'une seule agrégation : count, unique count, sum ou average. Par exemple, les clics quotidiens et les visites quotidiennes sont des métriques à dimension unique.

Dans le paramètre Metric Definition :

• Page Views : compte chaque visite de page

• Unique Visitors : compte chaque utilisateur une seule fois, lors de la première visite

Les métriques dérivées combinent plusieurs métriques à dimension unique. Par exemple :

CTR = Daily clicks / Daily visits

Ajoutez d'abord les clics quotidiens et les visites quotidiennes en tant que métriques à dimension unique, puis définissez le CTR comme une métrique dérivée en utilisant la formule ci-dessus.

Configurer les groupes de métriques

Regroupez les métriques connexes pour les calculer et les comparer en tant qu'ensemble.

1. Dans l'onglet Metric Groups , créez un groupe de métriques et définissez le paramètre Metric Selection pour inclure les métriques souhaitées.

2. Cliquez sur Calculate dans la colonne Actions pour déclencher le calcul des métriques.

Calculer les métriques

Dans l'onglet Metric Groups de la page Metric Configurations , cliquez sur Calculate dans la colonne Actions . Sélectionnez les métriques à calculer dans le panneau qui s'affiche.

Suivez la progression des tâches sur la page Jobs . Lorsque toutes les tâches sont terminées, le statut passe à Succeeded.

Afficher les rapports

Sur la page Performance Reports sous Experiment Platform, configurez les paramètres et cliquez sur Start Analysis .

• Detail Data : affiche les différences de métriques entre l'expérience de référence et les expériences normales

• Trend Analysis : montre l'évolution des métriques sélectionnées sur la période de l'expérience