Platform For AI:Como integrar o sistema de teste A/B ao seu sistema

Faça login no console do PAI-Rec

No console do PAI-Rec, clique em Full-link Service no painel de navegação à esquerda. No assistente Service Initialization exibido, configure seus workspaces.

Observações sobre a configuração:

1. Consulte os workspaces existentes no Platform for AI (PAI), DataWorks e MaxCompute em seus respectivos consoles. Na página inicial de cada product, clique em Console.

2. Crie um bucket do OSS no console do OSS antes de configurá-lo aqui.

Conceda acesso ao MaxCompute

Na página Projects, pesquise o projeto do MaxCompute que deseja utilizar.

Se nenhum projeto aparecer, selecione a região correta primeiro.

Na coluna Actions do projeto, clique em Manage. Conceda ao PAI-Rec acesso direto e permissões de gravação no projeto do MaxCompute.

Para mais detalhes, consulte Service activation and initialization.

Crie um lab

1. Selecione um ambiente de execução e um cenário de recomendação.

2. Clique em Create Lab.

3. No painel Create Lab, configure os seguintes parâmetros:

Crie um grupo de experimentos

Cada camada de experimento pode ter vários grupos de experimentos, e cada grupo pode conter múltiplos experimentos. Utilize grupos separados quando vários engenheiros precisarem executar experimentos na mesma camada (por exemplo, diferentes algoritmos de recall) sem interferir uns nos outros.

Grupo de teste A/A (recomendado para novos experimentos):

Para validar que a configuração do seu experimento é imparcial, crie um grupo de teste A/A antes de executar experimentos reais:

1. Selecione de 4 a 5 buckets para o experimento.

2. Atribua 2 buckets a um grupo sem política configurada. Execute esses buckets como um teste preliminar e monitore as métricas principais.

3. Utilize os dois grupos cujas métricas forem mais semelhantes para o seu teste A/B real.

Parâmetros adicionais do grupo de experimentos:

Crie um experimento

Clique em Create Experiment. Por padrão, um experimento base é criado primeiro.

Estratégias de alocação de tráfego:

Após configurar todos os parâmetros, clique em 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"));
    }
}

Registre uma tabela de dados

No console do PAI-Rec, acesse Metric Management > Data Registration. Associe uma tabela do MaxCompute à sua instância de teste A/B. Defina o Data Table Name com um nome que reflita o contexto de negócio.

Selecione uma tabela que contenha os campos obrigatórios. Para requisitos de campos, consulte Data registration and field configuration.

Se o seu projeto do MaxCompute não tiver uma tabela com todos os campos necessários, crie uma:

1. Faça login no console do MaxCompute e crie uma tabela de dados.

2. No DataWorks, crie uma tabela de source para relatórios de experimentos de teste A/B no MaxCompute.

Após o registro, a tabela aparece na lista de tabelas de dados. Clique em View Fields na coluna Actions para inspecionar ou editar mapeamentos de campos.

Tipos de métricas

O PAI-Rec suporta três categorias de métricas:

Além disso, distinga entre:

• Métricas principais (KPIs): os resultados primários que o experimento foi projetado para melhorar

• Métricas obrigatórias: métricas que devem ser observadas durante um teste; a capacidade testada não pode afetá-las negativamente

Configure métricas

Na página Metric Configurations, clique em Metrics. Defina os parâmetros Recommendation Scenario e Metric Timeliness.

Métricas de dimensão única são calculadas a partir de uma única agregação: contagem, contagem distinta, soma ou média. Por exemplo, cliques diários e visitas diárias são métricas de dimensão única.

No parâmetro Metric Definition:

• Page Views: conta cada visita à página

• Unique Visitors: conta cada usuário uma vez, na primeira visita

Métricas derivadas combinam múltiplas métricas de dimensão única. Por exemplo:

CTR = Daily clicks / Daily visits

Adicione cliques diários e visitas diárias como métricas de dimensão única primeiro, depois defina o CTR como uma métrica derivada usando a fórmula acima.

Configure grupos de métricas

Agrupe métricas relacionadas para calculá-las e compará-las como um conjunto.

1. Na aba Metric Groups, crie um grupo de métricas e defina o parâmetro Metric Selection para incluir as métricas desejadas.

2. Clique em Calculate na coluna Actions para acionar o cálculo das métricas.

Calcule métricas

Na aba Metric Groups da página Metric Configurations, clique em Calculate na coluna Actions. Selecione as métricas a serem calculadas no painel exibido.

Acompanhe o progresso dos jobs na página Jobs. Quando todos os jobs forem concluídos, o status mudará para Succeeded.

Visualize relatórios

Na página Performance Reports sob Experiment Platform, configure os parâmetros e clique em Start Analysis.

• Detail Data: mostra as diferenças de métricas entre o experimento base e os experimentos normais

• Trend Analysis: mostra como as métricas selecionadas variam ao longo do período do experimento