Criação de avaliações e métricas personalizadas

Registre o monitor personalizado com a definição de métricas

Antes de começar usando métricas personalizadas, deve-se registrar o monitor personalizado, que é o processador que rastreia as métricas. Também deve-se definir as métricas em si.

1. Use o método get_definition(monitor_name) para importar os objetos Metric e Tag.
2. Use o método metrics para definir as métricas, que requerem os valores name, thresholds e type.
3. Use o método tags para definir metadados.

O código a seguir é do bloco de notas de amostra de trabalho que foi mencionado anteriormente:

def get_definition(monitor_name):
    monitor_definitions = wos_client.monitor_definitions.list().result.monitor_definitions

    for definition in monitor_definitions:
        if monitor_name == definition.entity.name:
            return definition

    return None


monitor_name = 'my model performance'
metrics = [MonitorMetricRequest(name='sensitivity',
                                thresholds=[MetricThreshold(type=MetricThresholdTypes.LOWER_LIMIT, default=0.8)]),
          MonitorMetricRequest(name='specificity',
                                thresholds=[MetricThreshold(type=MetricThresholdTypes.LOWER_LIMIT, default=0.75)])]
tags = [MonitorTagRequest(name='region', description='customer geographical region')]

existing_definition = get_definition(monitor_name)

if existing_definition is None:
    custom_monitor_details = wos_client.monitor_definitions.add(name=monitor_name, metrics=metrics, tags=tags, background_mode=False).result
else:
    custom_monitor_details = existing_definition

Para verificar como você está fazendo, execute o comando client.data_mart.monitors.list() para ver se o seu monitor e métricas recém-criados estão configurados adequadamente.

Também é possível obter o ID do monitor executando o comando a seguir:

custom_monitor_id = custom_monitor_details.metadata.id

print(custom_monitor_id)

Para ter uma visão mais detalhada, execute o comando a seguir:

custom_monitor_details = wos_client.monitor_definitions.get(monitor_definition_id=custom_monitor_id).result
print('Monitor definition details:', custom_monitor_details)

Habilite o monitor personalizado

Em seguida, deve-se ativar o monitor customizado para assinatura. Isso ativa o monitor e configura os limites.

1. Use o método target para importar o objeto Threshold.
2. Use o método thresholds para configurar o valor da métrica lower_limit. Forneça o valor metric_id como um dos parâmetros. Se você não se lembrar, é possível usar sempre o comando custom_monitor_details para obter os detalhes conforme mostrado no exemplo anterior.

O código a seguir é do bloco de notas de amostra de trabalho que foi mencionado anteriormente:

target = Target(
        target_type=TargetTypes.SUBSCRIPTION,
        target_id=subscription_id
    )

thresholds = [MetricThresholdOverride(metric_id='sensitivity', type = MetricThresholdTypes.LOWER_LIMIT, value=0.9)]

custom_monitor_instance_details = wos_client.monitor_instances.create(
            data_mart_id=data_mart_id,
            background_mode=False,
            monitor_definition_id=custom_monitor_id,
            target=target
).result

Para verificar os detalhes de sua configuração, use o comando subscription.monitoring.get_details(monitor_uid=monitor_uid).

Armazenar valores métricos

Você deve armazenar ou salvar suas métricas personalizadas na região em que a instância do serviço existe.

1. Use o método metrics para configurar quais métricas você está armazenando.
2. Use o método subscription.monitoring.store_metrics para confirmar as métricas.

O código a seguir é do bloco de notas de amostra de trabalho que foi mencionado anteriormente:

from datetime import datetime, timezone, timedelta
from ibm_watson_openscale.base_classes.watson_open_scale_v2 import MonitorMeasurementRequest
custom_monitoring_run_id = "11122223333111abc"
measurement_request = [MonitorMeasurementRequest(timestamp=datetime.now(timezone.utc),
                                                 metrics=[{"specificity": 0.78, "sensitivity": 0.67, "region": "us-south"}], run_id=custom_monitoring_run_id)]
print(measurement_request[0])

published_measurement_response = wos_client.monitor_instances.measurements.add(
    monitor_instance_id=custom_monitor_instance_id,
    monitor_measurement_request=measurement_request).result
published_measurement_id = published_measurement_response[0]["measurement_id"]
print(published_measurement_response)

Para listar todos os monitores customizados, execute o comando a seguir:

published_measurement = wos_client.monitor_instances.measurements.get(monitor_instance_id=custom_monitor_instance_id, measurement_id=published_measurement_id).result
print(published_measurement)

Implementar o ponto final métrico

Para gerar uma métrica personalizada que inclua métricas no nível do registro, implemente a lógica de métricas personalizadas e métricas no nível do registro no Provedor de Métricas Personalizadas (Função Python ou API REST).

As métricas em nível de registro são métricas calculadas por linha no conjunto de dados de feedback ou registro de carga útil, ou em qualquer outro conjunto de dados usado em um monitor personalizado. Você pode incluir métricas em nível de registro em implementações de monitor personalizado calculando as métricas no provedor de métricas personalizadas (função Python ou API REST), salvando-as em um conjunto de dados personalizado e visualizando-as na página Monitores personalizados na interface do usuário.

Por exemplo, suponha que você deseja calcular a métrica HAP nas entradas e saídas do usuário para cada registro (para rastreamento de segurança ou conformidade). Você pode fazer isso implementando uma métrica no nível do registro. Quando os usuários visualizam os resultados da avaliação, eles podem clicar em um carimbo de data/hora para ver os registros de entrada e saída do usuário.

Para implementar a métrica personalizada e a lógica das métricas no nível do registro no Provedor de Métricas Personalizadas (Função Python ou API REST), execute as seguintes etapas:

1. Crie um conjunto de dados personalizado.

   Se você deseja armazenar métricas no nível do registro, crie um conjunto de dados personalizado após definir o monitor personalizado e sua instância. O conjunto de dados pode ser criado usando o SDK OpenScale.

   Dica: No fluxo simplificado do SDK, esta etapa não é necessária. O fluxo cria automaticamente o conjunto de dados personalizado.

   custom_dataset_info = wos_client.custom_monitor.create_custom_dataset(
                   data_mart_id='data_mart_id_here',
                   subscription_id='subscription_id_here',
                   custom_monitor_id='custom_monitor_id_here'
               )
   

2. Implemente a lógica no Provedor de Métricas Personalizadas (Função Python ou API REST).

   • Watsonx.governance envia entradas como data_mart_id, subscription_id, custom_monitor_id, etc., ao invocar o provedor de métricas personalizadas.

   • Leia os dados da tabela de feedback, tabela de registro de carga útil ou qualquer outro conjunto de dados usando as variáveis de carga útil de entrada

   • Calcule as métricas necessárias em nível de registro para cada linha e salve as métricas calculadas em nível de registro no conjunto de dados personalizado.

   • Calcule as métricas personalizadas e publique as métricas agregadas na API de medições.

   • Atualize o status de execução do monitor para Concluído.

Um exemplo completo em funcionamento é fornecido nos cadernos de amostra simplificados e detalhados.

Crie o provedor de métricas personalizadas

Defina os detalhes do endpoint do provedor de métricas personalizadas com as informações de autenticação. Watsonx.governance gera o token e invoca o endpoint REST com o token durante o tempo de execução

O código a seguir é do caderno de amostra funcional

wos_client.integrated_systems.add(name="Custom Metrics Provider",
    description="Custom Metrics Provider", type="custom_metrics_provider",
    credentials=  {
        "auth_type":"bearer",
        "token_info": {
           "url":  IAM_URL,
           "headers": { "Content-type": "application/x-www-form-urlencoded" }
           "payload": "grant_type=urn:ibm:params:oauth:grant-type:apikey&response_type=cloud_iam&apikey=<api_key>”,
           "method": "POST"
        }
    },
    connection={
        "display_name": "Custom Metrics Provider",
        "endpoint": rest_endpoint_url
    }
).result

Adicionar grupos de métricas

1. Na página inicial, clique em Configurar e, em seguida, clique em Grupos de métricas.
2. Clique em Adicionar grupo de métricas.
3. Para configurar um grupo de métricas usando um arquivo JSON, clique em Importar do arquivo. Carregue um arquivo JSON e clique em Importar.
4. Para configurar um grupo de métricas manualmente, clique em Configurar novo grupo.
   1. Digite um nome para o grupo de métricas e clique em Aplicar. O nome deve ter menos de ou igual a 48 caracteres.
   2. Clique no ícone Editar em Tipos de modelo para oferecer suporte a blocos e selecione um ou mais tipos de modelo que sua avaliação oferece suporte. Clique em Avançar.
   3. Para especificar uma programação de avaliação, clique no botão e especifique o intervalo. Clique em Avançar.
   4. Especifique os detalhes dos parâmetros de entrada. Para cada parâmetro de entrada, insira os detalhes e clique em Adicionar. O nome do parâmetro especificado deve corresponder ao nome do parâmetro especificado na API de métricas. Se for necessário um parâmetro para configurar seu monitor personalizado, marque a caixa de seleção Parâmetro obrigatório.
   5. Clique em Salvar.

Em seguida, implemente a métrica personalizada e a lógica das métricas no nível do registro no Provedor de Métricas Personalizadas (Função Python ou API REST). Para obter mais informações, consulte Implementar o endpoint métrico.

Após implementar o endpoint de métrica, consulte Adicionar endpoints de métrica.

Adicionar pontos finais métricos

Para adicionar pontos finais métricos usando a interface do usuário, execute as seguintes etapas:

1. Na página inicial, clique em Configurar e, em seguida, clique em Pontos finais métricos.

2. Clique em Adicionar ponto final métrico.

3. Especificar um nome e uma descrição para o terminal métrico.

4. Clique no ícone Editar no quadro Conexão e especifique os detalhes da conexão. Clique em Avançar.

5. Selecione os grupos de métricas que deseja associar ao ponto de extremidade da métrica e clique em Salvar.

   Se você habilitar o suporte a lotes, ao especificar um ponto de extremidade de tempo de URL execução watsonx.ai personalizado, poderá adicionar os seguintes parâmetros de entrada a um grupo de métricas:

Configurar monitores personalizados

1. Na página inicial, clique em Painel de insights.
2. Em um bloco de implantação de modelo, selecione Configurar monitores.
3. Na seção Avaliações , selecione o nome do grupo métrico que você incluiu.
4. Selecione o ícone Editar no ladrilho Terminal Metric .
5. Selecione um terminal de métrica e clique em Avançar. Se você não quiser usar um endpoint métrico, selecione Nenhum.
6. Use as alternâncias para especificar as métricas que deseja usar para avaliar o modelo e fornecer valores de limite. Clique em Avançar.
7. Especificar valores para os parâmetros de entrada. Se você selecionou JSON como tipo de dados para o grupo de métricas, inclua os dados JSON. Clique em Avançar.

Agora é possível avaliar modelos com um monitor personalizado.