Expliquer les prédictions du modèle de classification de texte à l'aide d'Amazon SageMaker Clarify

L'explicabilité du modèle fait référence au processus consistant à relier la prédiction d'un modèle d'apprentissage automatique (ML) aux valeurs de caractéristique d'entrée d'une instance en termes compréhensibles par l'homme. Ce champ est souvent appelé intelligence artificielle explicable (XII). Amazon SageMaker Clarifier est une caractéristique de Amazon Sage Maker qui permet aux data scientists et aux ingénieurs ML d'expliquer les prédictions de leurs modèles ML. Il utilise des méthodes indépendantes du modèle telles que Explications additives en forme (SHAP) pour l'attribution des fonctionnalités. Outre la prise en charge des explications pour les données tabulaires, Clarify prend également en charge l'explicabilité pour la vision par ordinateur (CV) et le traitement du langage naturel (NLP) en utilisant le même algorithme SHAP.

Dans cet article, nous illustrons l'utilisation de Clarify pour expliquer les modèles NLP. Plus précisément, nous montrons comment vous pouvez expliquer les prédictions d'un modèle de classification de texte qui a été entraîné à l'aide de SageMaker BlazingText algorithme. Cela vous aide à comprendre quelles parties ou quels mots du texte sont les plus importants pour les prédictions faites par le modèle. Entre autres choses, ces observations peuvent ensuite être utilisées pour améliorer divers processus tels que l'acquisition de données qui réduit les biais dans l'ensemble de données et la validation du modèle pour garantir que les modèles fonctionnent comme prévu et gagner la confiance de toutes les parties prenantes lorsque le modèle est déployé. Cela peut être une exigence clé dans de nombreux domaines d'application tels que l'analyse des sentiments, les examens juridiques, le diagnostic médical, etc.

Nous fournissons également un modèle de conception général que vous pouvez utiliser lors de l'utilisation de Clarify avec l'un des Algorithmes SageMaker.

Vue d'ensemble de la solution

Les algorithmes SageMaker ont des formats de données d'entrée et de sortie fixes. Par exemple, le conteneur d'algorithme BlazingText accepte les entrées au format JSON. Mais les clients ont souvent besoin de formats spécifiques compatibles avec leurs pipelines de données. Nous présentons quelques options que vous pouvez suivre pour utiliser Clarify.

Option A

Dans cette option, nous utilisons la fonctionnalité de pipeline d'inférence de l'hébergement SageMaker. Un pipeline d'inférence est un modèle SageMaker qui constitue une séquence de conteneurs qui traite les demandes d'inférence. Le diagramme suivant illustre un exemple.

Vous pouvez utiliser des pipelines d'inférence pour déployer une combinaison de vos propres modèles personnalisés et d'algorithmes intégrés SageMaker emballés dans différents conteneurs. Pour plus d'informations, reportez-vous à Hébergement de modèles avec logique de prétraitement en tant que pipeline d'inférence série derrière un point de terminaison. Étant donné que Clarify ne prend en charge que les lignes CSV et JSON en entrée, vous devez effectuer les étapes suivantes :

1. Créez un modèle et un conteneur pour convertir les données de CSV (ou JSON Lines) en JSON.
2. Après l'étape d'apprentissage du modèle avec l'algorithme BlazingText, directement déployer le modèle. Cela déploiera le modèle à l'aide du conteneur BlazingText, qui accepte JSON en entrée. Lors de l'utilisation d'un algorithme différent, SageMaker crée le modèle à l'aide du conteneur de cet algorithme.
3. Utilisez les deux modèles précédents pour créer un Modèle de pipeline. Cela enchaîne les deux modèles dans une séquence linéaire et crée un modèle unique. Pour un exemple, reportez-vous à Pipeline d'inférence avec Scikit-learn et Linear Learner.

Avec cette solution, nous avons réussi à créer un modèle unique dont l'entrée est compatible avec Clarify et peut être utilisée par celui-ci pour générer des explications.

Option B

Cette option montre comment vous pouvez intégrer l'utilisation de différents formats de données entre les algorithmes Clarify et SageMaker en apportant votre propre conteneur pour héberger le modèle SageMaker. Le schéma suivant illustre l'architecture et les étapes impliquées dans la solution :

Les étapes sont les suivantes:

1. Utilisez l'algorithme BlazingText via SageMaker Estimator pour former un modèle de classification de texte.
2. Une fois le modèle formé, créez un conteneur Docker personnalisé qui peut être utilisé pour créer un modèle SageMaker et éventuellement déployer le modèle en tant que point de terminaison de modèle SageMaker.
3. Configurez et créez une tâche Clarify pour utiliser le conteneur d'hébergement afin de générer un rapport d'explicabilité.
4. Le conteneur personnalisé accepte la demande d'inférence en tant que CSV et permet à Clarify de générer des explications.

Il convient de noter que cette solution illustre l'idée d'obtenir des explications hors ligne à l'aide de Clarify pour un modèle BlazingText. Pour plus d'informations sur l'explicabilité en ligne, reportez-vous à Explicabilité en ligne avec SageMaker Clarify.

Le reste de cet article explique chacune des étapes de la deuxième option.

Former un modèle BlazingText

Nous formons d'abord un modèle de classification de texte à l'aide de l'algorithme BlazingText. Dans cet exemple, nous utilisons le Jeu de données DBpedia Ontology. DBpedia est une initiative participative pour extraire du contenu structuré à l'aide d'informations provenant de divers projets Wikimedia tels que Wikipedia. Plus précisément, nous utilisons le jeu de données d'ontologie DBpedia tel que créé par Zhang et coll.. Il est construit en sélectionnant 14 classes non superposées à partir de DBpedia 2014. Les champs contiennent un résumé d'un article de Wikipedia et la classe correspondante. L'objectif d'un modèle de classification de texte est de prédire la classe d'un article compte tenu de son résumé.

Un processus détaillé étape par étape pour la formation du modèle est disponible ci-dessous. cahier. Après avoir formé le modèle, notez les Service de stockage simple Amazon (Amazon S3) Chemin URI où les artefacts de modèle sont stockés. Pour un guide étape par étape, consultez Classification de texte à l'aide de SageMaker BlazingText.

Déployez le modèle BlazingText formé à l'aide de votre propre conteneur sur SageMaker

Avec Clarify, il existe deux options pour fournir les informations sur le modèle :

• Créer un modèle SageMaker sans le déployer sur un terminal – Lorsqu'un modèle SageMaker est fourni à Clarify, il crée un point de terminaison éphémère à l'aide du modèle.
• Créer un modèle SageMaker et le déployer sur un point de terminaison – Lorsqu'un point de terminaison est mis à la disposition de Clarify, il utilise le point de terminaison pour obtenir des explications. Cela évite la création d'un point de terminaison éphémère et peut réduire la durée d'exécution d'une tâche Clarify.

Dans cet article, nous utilisons la première option avec Clarify. Nous utilisons le Kit de développement logiciel (SDK) SageMaker Python dans ce but. Pour d'autres options et plus de détails, reportez-vous à Créez votre endpoint et déployez votre modèle.

Apportez votre propre contenant (BYOC)

Nous construisons d'abord une image Docker personnalisée qui est utilisée pour créer le Modèle SageMaker. Vous pouvez utiliser les fichiers et le code dans le répertoire source de notre référentiel GitHub.

Le Dockerfile décrit l'image que nous voulons construire. Nous commençons par une installation standard d'Ubuntu, puis installons Scikit-learn. Nous clonons également texte rapide et installez le paquet. Il est utilisé pour charger le modèle BlazingText pour faire des prédictions. Enfin, nous ajoutons le code qui implémente notre algorithme sous la forme des fichiers précédents et configurons l'environnement dans le conteneur. L'ensemble Dockerfile est fourni dans notre référentiel et vous pouvez l'utiliser tel quel. Faire référence à Utilisez votre propre code d'inférence avec les services d'hébergement pour plus de détails sur la façon dont SageMaker interagit avec votre conteneur Docker et ses exigences.

Les inspections régulières contribuent également à la sécurité des passagers. En identifiant et en traitant les risques potentiels pour la sécurité, tels que des freins usés, un éclairage défectueux ou le remplacement du revêtement de sol, les inspections permettent de réduire le risque d'accidents et de blessures et d'améliorer la sécurité générale du service. Les inspections régulières sont un moyen concret de mettre en valeur l'engagement des prestataires de services de transport en faveur du bien-être des passagers et des conducteurs. prédicteur.py contient le code pour charger le modèle et faire les prédictions. Il accepte les données d'entrée au format CSV, ce qui le rend compatible avec Clarify.

Une fois que vous avez le Dockerfile, créez le conteneur Docker et téléchargez-le sur Registre des conteneurs élastiques Amazon (Amazon ECR). Vous trouverez le processus étape par étape sous la forme d'un script shell dans notre référentiel GitHub, que vous pouvez utiliser pour créer et télécharger l'image Docker sur Amazon ECR.

Créer le modèle BlazingText

L'étape suivante consiste à créer un objet modèle à partir du SDK SageMaker Python. Classe de modèle qui peut être déployé sur un point de terminaison HTTPS. Nous configurons Clarify pour utiliser ce modèle pour générer des explications. Pour le code et les autres exigences de cette étape, reportez-vous à Déployez votre modèle SageMaker BlazingText formé à l'aide de votre propre conteneur dans Amazon SageMaker.

Configurer Clarifier

Clarify NLP est compatible avec les modèles de régression et de classification. Il vous aide à comprendre quelles parties du texte d'entrée influencent les prédictions de votre modèle. Clarify prend en charge 62 langues et peut gérer du texte en plusieurs langues. Nous utilisons le SDK Python SageMaker pour définir les trois configurations utilisées par Clarify pour créer le rapport d'explicabilité.

Tout d'abord, nous devons créer l'objet processeur et également spécifier l'emplacement de l'ensemble de données d'entrée qui sera utilisé pour les prédictions et l'attribution des caractéristiques :

import sagemaker
sagemaker_session = sagemaker.Session()
from sagemaker import clarify
clarify_processor = clarify.SageMakerClarifyProcessor(
role=role,
instance_count=1,
instance_type="ml.m5.xlarge",
sagemaker_session=sagemaker_session,
)
file_path = "<location of the input dataset>"

Configuration des données

Ici, vous devez configurer l'emplacement des données d'entrée, la colonne de caractéristiques et l'endroit où vous souhaitez que la tâche Clarify stocke la sortie. Cela se fait en transmettant les arguments pertinents lors de la création d'un objet DataConfig :

explainability_output_path = "s3://{}/{}/clarify-text-explainability".format(
sagemaker_session.default_bucket(), "explainability"
) explainability_data_config = clarify.DataConfig(
s3_data_input_path=file_path,
s3_output_path=explainability_output_path,
headers=["Review Text"],
dataset_type="text/csv",
)

ModèleConfig

Avec ModelConfig, vous devez spécifier des informations sur votre modèle formé. Ici, nous spécifions le nom du modèle BlazingText SageMaker que nous avons créé dans une étape précédente et définissons également d'autres paramètres comme le Cloud de calcul élastique Amazon (Amazon EC2) type d'instance et format du contenu :

model_config = clarify.ModelConfig(
model_name=model_name,
instance_type="ml.m5.xlarge",
instance_count=1,
accept_type="application/jsonlines",
content_type="text/csv",
endpoint_name_prefix=None,
)

SHAPConfig

Ceci est utilisé pour informer Clarify sur la façon d'obtenir les attributions de fonctionnalités. TextConfig est utilisé pour spécifier la granularité du texte et la langue. Dans notre ensemble de données, parce que nous voulons décomposer le texte d'entrée en mots et que la langue est l'anglais, nous définissons ces valeurs sur jeton et anglais, respectivement. Selon la nature de votre ensemble de données, vous pouvez définir la granularité sur une phrase ou un paragraphe. La ligne de base est définie sur un jeton spécial. Cela signifie que Clarify supprimera des sous-ensembles du texte d'entrée et les remplacera par des valeurs de la ligne de base tout en obtenant des prédictions pour calculer les valeurs SHAP. C'est ainsi qu'il détermine l'effet des jetons sur les prédictions du modèle et identifie à son tour leur importance. Le nombre d'échantillons à utiliser dans l'algorithme Kernel SHAP est déterminé par la valeur de num_samples argument. Des valeurs plus élevées se traduisent par des attributions de fonctionnalités plus robustes, mais cela peut également augmenter la durée d'exécution de la tâche. Par conséquent, vous devez faire un compromis entre les deux. Voir le code suivant :

shap_config = clarify.SHAPConfig(
baseline=[["<UNK>"]],
num_samples=1000,
agg_method="mean_abs",
save_local_shap_values=True,
text_config=clarify.TextConfig(granularity="token", language="english"),
)

Pour plus d'informations, voir Attributions de fonctionnalités qui utilisent des valeurs Shapley ainsi que Livre blanc sur l'équité et l'explicabilité d'Amazon AI.

ModelPredictedLabelConfigModelPredictedLabelConfig

Pour que Clarify extraie une étiquette prédite ou des scores ou probabilités prédits, cet objet de configuration doit être défini. Voir le code suivant :

from sagemaker.clarify import ModelPredictedLabelConfig
modellabel_config = ModelPredictedLabelConfig(probability="prob", label="label")

Pour plus de détails, reportez-vous au Documentation dans le SDK.

Exécuter une tâche de clarification

Après avoir créé les différentes configurations, vous êtes maintenant prêt à déclencher la tâche de traitement Clarify. La tâche de traitement valide l'entrée et les paramètres, crée le point de terminaison éphémère et calcule les attributions de fonctionnalités locales et globales à l'aide de l'algorithme SHAP. Une fois cette opération terminée, il supprime le point de terminaison éphémère et génère les fichiers de sortie. Voir le code suivant :

clarify_processor.run_explainability(
data_config=explainability_data_config,
model_config=model_config,
explainability_config=shap_config,
model_scores=modellabel_config,
)

La durée d'exécution de cette étape dépend de la taille de l'ensemble de données et du nombre d'échantillons générés par SHAP.

Visualisez les résultats

Enfin, nous montrons une visualisation des résultats du rapport d'attribution de caractéristiques locales qui a été généré par la tâche de traitement Clarify. La sortie est au format JSON Lines et avec un certain traitement ; vous pouvez tracer les scores des jetons dans le texte d'entrée comme dans l'exemple suivant. Les barres plus hautes ont plus d'impact sur l'étiquette cible. De plus, les valeurs positives sont associées à des prédictions plus élevées dans la variable cible et les valeurs négatives à des prédictions plus faibles. Dans cet exemple, le modèle effectue une prédiction pour le texte d'entrée "Wesebach est une rivière de Hesse en Allemagne". La classe prédite est Natural Place et les scores indiquent que le modèle a trouvé que le mot « rivière » était le plus informatif pour faire cette prédiction. Ceci est intuitif pour un humain et en examinant plus d'échantillons, vous pouvez déterminer si le modèle apprend les bonnes fonctionnalités et se comporte comme prévu.

Conclusion

Dans cet article, nous avons expliqué comment vous pouvez utiliser Clarify pour expliquer les prédictions d'un modèle de classification de texte formé à l'aide de SageMaker BlazingText. Commencez à expliquer les prédictions de vos modèles de classification de texte à l'aide de l'exemple de bloc-notes Explicabilité du texte pour SageMaker BlazingText.

Nous avons également discuté d'un modèle de conception plus générique que vous pouvez utiliser lors de l'utilisation de Clarify avec les algorithmes intégrés de SageMaker. Pour plus d'informations, reportez-vous à Qu'est-ce que l'équité et l'explicabilité du modèle pour les prédictions d'apprentissage automatique. Nous vous encourageons également à lire le Livre blanc sur l'équité et l'explicabilité d'Amazon AI, qui fournit une vue d'ensemble sur le sujet et discute des meilleures pratiques et des limitations.

À propos des auteurs

Pinak Panigrahi travaille avec les clients pour créer des solutions basées sur l'apprentissage automatique afin de résoudre les problèmes commerciaux stratégiques sur AWS. Lorsqu'il n'est pas occupé par l'apprentissage automatique, on peut le trouver en train de faire une randonnée, de lire un livre ou de faire du sport.

Dhawal Patel est architecte principal en apprentissage machine chez AWS. Il a travaillé avec des organisations allant des grandes entreprises aux startups de taille moyenne sur des problèmes liés à l'informatique distribuée et à l'intelligence artificielle. Il se concentre sur l'apprentissage en profondeur, y compris les domaines de la PNL et de la vision par ordinateur. Il aide les clients à obtenir une inférence de modèle haute performance sur SageMaker.

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• Platoblockchain. Intelligence métaverse Web3. Connaissance Amplifiée. Accéder ici.
• La source: https://aws.amazon.com/blogs/machine-learning/explain-text-classification-model-predictions-using-amazon-sagemaker-clarify/