Dans quels cas faut-il utiliser un moteur d'apprentissage automatique personnalisé ?

L'utilisation d'un moteur d'apprentissage automatique personnalisé est recommandée dans les situations suivantes :

• Vous n'utilisez pas de produits immédiatement disponibles pour servir vos modèles d'apprentissage automatique. Vous disposez d'un système pour servir vos modèles et il n'existe pas de support direct pour cette fonction d'évaluation des modèles.
• Le moteur de service que vous utilisez et qui provient d'un fournisseur 3rd-party n'est pas encore pris en charge pour les évaluations de modèles. Dans ce cas, vous pouvez envisager de développer un moteur d'apprentissage automatique personnalisé qui encapsulera vos déploiements initiaux ou natifs.

Fonctionnement

L'image suivante montre le support de l'environnement personnalisé :

Vous pouvez également consulter les liens suivants :

API de consignation de contenu Watson OpenScale

Kit SDK client Python

SDK Python

• Critères d'entrée pour que le modèle supporte les moniteurs

  Dans l'exemple suivant, votre modèle prend un vecteur de fonction, qui est essentiellement une collection de champs nommés et leurs valeurs, en tant qu'entrée.

  {
  "fields": [
      "name",
      "age",
      "position"
  ],
  "values": [
      [
          "john",
          33,
          "engineer"
      ],
      [
          "mike",
          23,
          "student"
      ]
  ]
  
  

  Le champ “age” peut être évalué pour déterminer son équité.

  Si l'entrée est un tenseur ou une matrice, qui est transformé à partir de l'espace des caractéristiques d'entrée, ce modèle ne peut pas être évalué. Par extension, les modèles d'apprentissage en profondeur avec des entrées texte ou images ne peuvent pas être traités pour la détection et l'atténuation de biais.

  De plus, les données de formation doivent être chargées pour prendre en charge l'explainabilité.

  Pour l'explicabilité sur du texte, le texte complet doit faire partie des fonctions. L'explicabilité sur les images pour un modèle personnalisé n'est pas prise en charge dans l'édition actuelle.

• Critères de sortie pour que le modèle supporte les moniteurs

  Votre modèle génère le vecteur de fonction d'entrée avec les probabilités de prévision de différentes classes dans ce modèle.

  {
  "fields": [
      "name",
      "age",
      "position",
      "prediction",
      "probability"
  ],
  "labels": [
      "personal",
      "camping"
  ],
  "values": [
      [
          "john",
          33,
          "engineer",
          "personal",
          [
              0.6744664422398081,
              0.3255335577601919
          ]
      ],
      [
          "mike",
          23,
          "student"
          "camping",
          [
              0.2794765664946941,
              0.7205234335053059
          ]
      ]
  ]
  }
  

  Dans cet exemple, "personal” et “camping” sont les classes possibles et les scores de chaque sortie de scoring sont affectés aux deux classes. Si les probabilités de prédiction sont manquantes, la détection de biais fonctionne, mais la dépolarisation automatique ne le fait pas.

  Vous pouvez accéder au résultat de la notation à partir d'un point final de notation en direct que vous pouvez appeler avec l'API REST pour les évaluations de modèles. Pour CUSTOMML, Amazon SageMaker, et IBM watsonx.ai Runtime, Watson OpenScale se connecte directement aux points de terminaison de notation natifs.

Moteur d'apprentissage automatique personnalisé

Un moteur d'apprentissage automatique personnalisé fournit l'infrastructure et l'hébergement pour les modèles et les applications web d'apprentissage automatique. Les moteurs d'apprentissage automatique personnalisés pris en charge pour l'évaluation des modèles doivent être conformes aux exigences suivantes :

• Exposer deux types de point d'extrémité d'API REST :

  • point d'extrémité de reconnaissance (liste GET des déploiements et détails)
  • points d'extrémité d'évaluation (évaluation en ligne et en temps réel)

• Tous les points d'extrémité doivent être compatibles avec la spécification swagger pour être supportés.

• Le contenu d'entrée et la sortie du déploiement doivent être conformes au format de fichier JSON décrit dans la spécification.

Watson OpenScale prend uniquement en charge les formats d'authentification BasicAuth, noneou apiKey.

Pour consulter la spécification des points d'extrémité de l'API REST, voir l'API REST.

Ajouter un moteur d'apprentissage automatique personnalisé

Vous pouvez configurer les évaluations de modèles pour qu'elles fonctionnent avec un fournisseur d'apprentissage automatique personnalisé en utilisant l'une des méthodes suivantes :

• Vous pouvez utiliser l'interface de configuration pour ajouter votre premier fournisseur d'apprentissage automatique personnalisé. Pour plus d'informations, consultez Spécification d'une instance de service d'apprentissage automatique personnalisé.
• Vous pouvez également ajouter votre fournisseur d'apprentissage automatique avec le SDK Python. Cette méthode est obligatoire si vous voulez avoir plusieurs fournisseurs. Pour plus d'informations, voir Ajoutez votre moteur d'apprentissage automatique.

Explorer plus avant

Vous pouvez utiliser un moniteur d'apprentissage automatique personnalisé pour créer un moyen d'interagir avec d'autres services.

Spécification d'une instance de service ML personnalisé

La première étape de la configuration des évaluations de modèles consiste à spécifier une instance de service. Votre instance de service est l'endroit où vous stockez vos modèles et déploiements d'IA.

Connectez votre instance de service personnalisé

Les modèles d'IA et les déploiements sont connectés dans une instance de service pour l'évaluation des modèles. Vous pouvez connecter un service personnalisé. Pour connecter votre service, allez dans l'onglet Configurer " , ajoutez un fournisseur d'apprentissage automatique et cliquez sur l'icône Modifier " . Outre le nom, la description et la spécification du type d'environnement préproduction ou production, vous devez fournir les informations suivantes spécifiques à ce type d'instance de service :

• Nom d'utilisateur
• Mot de passe
• Nœud final d'API qui utilise le format https://host:port, tel que https://custom-serve-engine.example.net:8443

Choisissez entre vous connecter à vos déploiements en demandant leur liste et vous connecter en entrant individuellement les points d'extrémité d'évaluation.

Exemples de moteur d'apprentissage automatique personnalisé

Utilisez les idées suivantes pour configurer votre propre moteur d'apprentissage automatique personnalisé.

Python et Flask

Vous pouvez utiliser Python et flask pour servir de modèle scikit-learn.

Pour générer le modèle de détection de dérive, vous devez utiliser scikit-learn version 0.20.2 dans le bloc-notes.

L'application peut être déployée localement à des fins de test et comme application sous IBM Cloud.

Node.js

Vous pouvez également trouver un exemple de moteur d'apprentissage automatique écrit dans Node.js ici.

Schéma de code end2end

Modèle de code montrant un exemple de end2end déploiement d'un moteur personnalisé et de l'intégration avec les évaluations de modèles.

Journalisation du contenu utile avec le moteur d'apprentissage automatique personnalisé

Pour configurer la journalisation des données utiles pour un moteur d'apprentissage machine personnalisé ou non IBM watsonx.ai Runtime, vous devez lier le moteur ML en tant que moteur personnalisé.

CUSTOM_ENGINE_CREDENTIALS = {
    "url": "***",
    "username": "***",
    "password": "***",
}

wos_client.service_providers.add(
        name=SERVICE_PROVIDER_NAME,
        description=SERVICE_PROVIDER_DESCRIPTION,
        service_type=ServiceTypes.CUSTOM_MACHINE_LEARNING,
        credentials=CustomCredentials(
            url= CUSTOM_ENGINE_CREDENTIALS['url'],
            username= CUSTOM_ENGINE_CREDENTIALS['username'],
            password= CUSTOM_ENGINE_CREDENTIALS['password'],
        ),
        background_mode=False
    ).result

client.service_providers.get(service_provider_id).result.to_dict()

{
	"input_data": [{
		"fields": [
			"name",
			"age",
			"position"
		],
		"values": [
			[
			"john",
			 33,
			"engineer"
			],
			[
			"mike",
			 23,
			"student"
			]
		]
	}]
}

{
	"predictions": [{
		"fields": [
			"name",
			"age",
			"position",
			"prediction",
			"probability"
		],
		"labels": [
			"personal",
			"camping"
		],
		"values": [
			[
			"john",
			 33,
			"engineer",
			"personal",
			[
			0.6744664422398081,
			0.32553355776019194
			]
			],
			[
			"mike",
			 23,
			"student",
			"camping",
			[
			0.2794765664946941,
			0.7205234335053059
			]
			]
		]
	}]
}

custom_asset = Asset(
        asset_id=asset['entity']['asset']['asset_id'],
        name=asset['entity']['asset']['name'],
        url = "dummy_url",
        asset_type=asset['entity']['asset']['asset_type'] if 'asset_type' in asset['entity']['asset'] else 'model',
        problem_type=ProblemType.MULTICLASS_CLASSIFICATION,
        input_data_type=InputDataType.STRUCTURED,
    )
deployment = AssetDeploymentRequest(
        deployment_id=asset['metadata']['guid'],
        url=asset['metadata']['url'],
        name=asset['entity']['name'],
        deployment_type=asset['entity']['type'],
        scoring_endpoint =  scoring_endpoint
    )
asset_properties = AssetPropertiesRequest(
        prediction_field='predicted_label',
        probability_fields = ["probability"],
        training_data_reference=None,
        training_data_schema=None,
        input_data_schema=None,
        output_data_schema=output_schema,
    )
result = ai_client.subscriptions.add(
        data_mart_id=cls.datamart_id,
        service_provider_id=cls.service_provider_id,
        asset=custom_asset,
        deployment=deployment,
        asset_properties=asset_properties,
        background_mode=False
    ).result

subscription_id = subscription_details.metadata.id
subscription_id

details: wos_client.subscriptions.get(subscription_id).result.to_dict()

request_data = {'fields': feature_columns, 
                'values': [[payload_values]]}

response_data = {'fields': list(result['predictions'][0]),
                 'values': [list(x.values()) for x in result['predictions']]}