Découverte de l'API d'analyse de texte Microsoft Cognitive Service
Découvrons aujourd'hui l'API fournie par Microsoft : "Cognitive Service". Dans cette présentation nous allons aborder cette api à l'aide de Python. D'abord, réalisons les imports nécessaires. "requests" va nous permettre d'interroger l'API. Nous allons aussi utiliser "pprint" qui est la librairie nous permettant d'afficher clairement les JSON. Pour réaliser ce tutoriel, vous avez besoin d'une clef API Microsoft Cognitive Services (disponible gratuitement dans la limite de 5000 appels par mois sur une période d'un an), vous pourrez la récupérer sur le site officiel : Microsoft Azure.
Paramétrage
# analyse_texte.py import requests from pprint import pprint key = 'VOTRE_CLEF_API' endpoint = 'https://westcentralus.api.cognitive.microsoft.com/text/analytics/v2.1'
Il est possible d'utiliser un proxy. Vous devez paramétrer un dictionnaire d'adresses proxy, nous passerons ce dictionnaire en paramètre à chaque appel de l'API Microsoft Cognitive Service.
proxy_dict = {
"http": 'http://proxy.domaine.fr:port',
"https": 'https://proxy.domaine.fr:port'
}
Analyse de langue
Nous allons commencer par la détection de langue. Nous communiquons en JSON avec l'API Microsoft Cognitive Service. Nous envoyons donc un objet JSON "documents" qui contient une liste de documents. Ces documents sont constitués d'un identifiant et d'un champ texte. Nous stockons ces objets dans une variable. Pour ce test, nous allons utiliser un texte Français et un texte Chinois.
documents = {"documents": [
{
"id": "1",
"text": "Il veillait sur l'oracle de Delphes, consacré primitivement à Thémis. Apollon le blessa, se rendant " +
"ainsi maître de l'oracle, depuis nommé « Pythie » ; et pour apaiser la colère de Gaïa, il créa les " +
"Jeux pythiques."
},
{
"id": "2",
"text": "这是一个用中文写的文件"
}
]}
Il faut maintenant appeler l'API Microsoft Cognitive Services
# Détection des langues
# Création du endpoint pour la fonction langue
language_api_url = endpoint + "/languages"
# Ajout de la clé API dans l'entête
headers = {"Ocp-Apim-Subscription-Key": key}
# Appel de l'API
response = requests.post(language_api_url, headers=headers, json=documents, proxies=proxy_dict)
# Formatage de la réponse
languages = response.json()
# Affichage du résultat
pprint(languages)
Nous obtenons donc un résultat sous la forme JSON. Il contient une liste de documents (2 dans notre cas), ils sont identifiables par leurs ID. L'API Microsoft Cognitive Services nous fournit 3 champs de résultat :
- iso6391Name : code de la langue
- name : nom de la langue
- score : indice de fiabilité de l'API (cet indice peut évoluer entre 0 et 1)
{
'documents': [
{
'detectedLanguages': [
{
'iso6391Name': 'fr',
'name': 'French',
'score': 1.0
}
],
'id': '1'
},
{
'detectedLanguages': [
{
'iso6391Name': 'zh_chs',
'name': 'Chinese_Simplified',
'score': 1.0
}
],
'id': '2'
}
],
'errors': []
}
Analyse de sentiments
Maintenant l'analyse de sentiments. Il s'agit de déterminer si un texte est positif ou négatif. L'API Microsoft Cognitive Services nous retournera un indicateur compris entre 0 et 1, 0 étant un sentiment négatif, 1 étant un sentiment positif. Nous envoyons donc un objet JSON "documents" qui contient une liste de documents. Ces documents sont constitués d'un identifiant, de la langue du texte et d'un champ texte. Nous stockons ces objets dans une variable. Pour ce test, nous allons utiliser un texte Français négatif et un texte Anglais positif.
documents = {"documents": [
{
"id": "1",
"language": "en",
"text": "I had a wonderful experience! The meal were wonderful and the staff was helpful."
},
{
"id": "2",
"language": "fr",
"text": "Les entreprises "non responsables" à commencer par celles qui "cassent" leurs employés et " +
"employés de leurs prestataires doivent subir la même sanction de leurs clients et acheteurs."
},
]}
Il faut maintenant appeler l'API Microsoft Cognitive Services
# Détection des sentiments
# Création du endpoint pour la fonction sentiment
language_api_url = endpoint + "/sentiment"
# Ajout de la clé API dans l'entête
headers = {"Ocp-Apim-Subscription-Key": key}
# Appel de l'API
response = requests.post(sentiment_api_url, headers=headers, json=documents, proxies=proxy_dict)
# Formatage de la réponse
sentiments = response.json()
# Affichage du résultat
pprint(sentiments)
Nous obtenons donc un résultat sous la forme JSON. Il contient une liste de documents (2 dans notre cas), ils sont identifiables par leurs ID. L'API Microsoft Cognitive Services nous fournit 1 champ de résultat :
- score : indice de sentiment, on constate donc que le premier texte est à 0.98, ce qui est extrêmement positif. Le second texte par contre est à 0.15 ce qui est très négatif.
{
'documents': [
{
'id': '1',
'score': 0.9819198846817017
},
{
'id': '2',
'score': 0.15830545127391815
}
],
'errors': []
}
Analyse de mots clefs
Maintenant l'analyse de sentiments. Il s'agit de récupérer la liste des mots clefs d'un texte. Ils seront retourné par ordre importance (nombre d'occurrences, les premiers mots de la liste étant les plus importants). Nous envoyons donc un objet JSON "documents" qui contient une liste de documents. Ces documents sont constitués d'un identifiant, de la langue du texte et d'un champ texte. Nous stockons ces objets dans une variable. Pour ce test, nous allons utiliser les textes utilisés pour l'analyse de sentiments.
documents = {"documents": [
{
"id": "1",
"language": "en",
"text": "I had a wonderful experience! The meal were wonderful and the staff was helpful."
},
{
"id": "2",
"language": "fr",
"text": "Les entreprises "non responsables" à commencer par celles qui "cassent" leurs employés et " +
"employés de leurs prestataires doivent subir la même sanction de leurs clients et acheteurs."
},
]}
Il faut maintenant appeler l'API Microsoft Cognitive Services
# Détection des mots clefs
# Création du endpoint pour la fonction keyphrases
keyphrases_api_url = endpoint + "/keyphrases"
# Ajout de la clé API dans l'entête
headers = {"Ocp-Apim-Subscription-Key": key}
# Appel de l'API
response = requests.post(keyphrases_api_url, headers=headers, json=documents, proxies=proxy_dict)
# Formatage de la réponse
key_phrases = response.json()
# Affichage du résultat
pprint(key_phrases)
Nous obtenons donc un résultat sous la forme JSON. Il contient une liste de documents (2 dans notre cas), ils sont identifiables par leurs ID. L'API Microsoft Cognitive Services nous fournit 1 champ de résultat :
- keyPhrases : est un tableau d'expressions texte, il est trié du plus présent au moins présent dans le texte.
{
'documents': [
{
'id': '1',
'keyPhrases': [
'wonderful experience',
'staff',
'meal'
]
},
{
'id': '2',
'keyPhrases': [
'employés',
'sanction',
'prestataires',
'clients',
'acheteurs',
'celles'
]
}
],
'errors': []
}
Analyse des entitées
Pour terminer, testons la dernière méthode disponible, l'analyse des entités. Cette méthode détecte les différentes entités dans un texte (personnes, durées...) et fournit un résultat complet par rapport au type d'entité. Nous envoyons donc un objet JSON "documents" qui contient un document. Ce document est constitué d'un identifiant et d'un champ texte. Nous stockons ces objets dans une variable. Pour ce test, nous allons utiliser un seul document.
documents = {"documents": [
{
"id": "1",
"text": "Founded by American audio pioneer Paul Klipsch, Klipsch has been providing legendary sound to music " +
" lovers since 1946."
},
]}
Il faut maintenant appeler l'API Microsoft Cognitive Services
# Détection des entitées
# Création du endpoint pour la fonction entities
entities_api_url = endpoint + "/entities"
# Ajout de la clé API dans l'entête
headers = {"Ocp-Apim-Subscription-Key": key}
# Appel de l'API
response = requests.post(entities_api_url, headers=headers, json=documents, proxies=proxy_dict)
# Formatage de la réponse
entities = response.json()
# Affichage du résultat
pprint(entities)
Nous obtenons donc un résultat sous la forme JSON. Il contient une liste de documents (1 dans notre cas), ils sont identifiables par leurs ID. Nous avons aussi une liste d'entité par document. L'API Microsoft Cognitive Services a détecté deux entités différentes, une de type "Person" et une de type "DateTime". Pour l'entité "Person", l'API nous fournit plusieurs champs de résultats :
- bingId : identifiant de l'entité Bing
- matches : champs correspondant à l'entitée (ici on constate que 'Paul Klipsh' correspons à 100% à une entité alors que 'Klipsh' correspond à 64%)
- name : nom de l'entité (dans l'exemple, Paul Wilbur Klipsch est le créateur de la marque Klipsh)
- type : définit le type d'une entité, ici c'est une personne
- wikipediaId : identifiant wikipedia
- wikipediaLanguage : language du wikipedia, dans le cas de l'exemple, cette entité est représenté uniquement en anglais.
- wikipediaUrl : url de la page wikipedia de l'entité
- matches : les propriétés de matches, montrent que l'entité selectionnée est "since 1946", cette entité à un score de 80%
- name : le nom de cette entité DateTime est la période, ou date
- subType : le sous-type (une entité peut être précisée par un sous-type, dans cet exemple DateRange)
- type : type de l'entité, dans ce cas DateTime
{
'documents': [
{
'entities': [
{
'bingId': 'a38f0c52-3f9a-be34-0fa4-eed72a14fe4c',
'matches': [
{
'entityTypeScore': 1.0,
'length': 12,
'offset': 34,
'text': 'Paul Klipsch',
'wikipediaScore': 0.7407890077568229
},
{
'entityTypeScore': 0.6464075446128845,
'length': 7,
'offset': 48,
'text': 'Klipsch',
'wikipediaScore': 0.7407890077568229
}
],
'name': 'Paul Wilbur Klipsch',
'type': 'Person',
'wikipediaId': 'Paul Wilbur Klipsch',
'wikipediaLanguage': 'en',
'wikipediaUrl': 'https: //en.wikipedia.org/wiki/Paul_Wilbur_Klipsch'
},
{
'matches': [
{
'entityTypeScore': 0.8,
'length': 10,
'offset': 108,
'text': 'since 1946'
}
],
'name': 'since 1946',
'subType': 'DateRange',
'type': 'DateTime'
}
],
'id': '1'
}
],
'errors': []
}
Cette découverte de l'API Microcoft Cognitive Services est terminée. Pour des informations plus détaillées, vous pouvez visiter le site internet MSDN qui contient toutes les documentations officielles Microsoft.