- Introduction
- Configuration de votre compte
- Équilibre
- Clusters
- Dérive de concept
- Couverture
- Jeux de données
- Champs généraux
- Libellés (prédictions, niveaux de confiance, hiérarchie des libellés et sentiment des libellés)
- Modèles
- Flux
- Évaluation du modèle
- Projets
- Précision
- Rappel
- Messages annotés et non annotés
- Extraction des champs
- Sources
- Taxonomies
- Apprentissage
- Prédictions positives et négatives vraies et fausses
- Validation
- Messages
- Contrôle et administration de l'accès
- Gérer les sources et les jeux de données
- Comprendre la structure des données et les autorisations
- Créer ou supprimer une source de données dans l'interface graphique
- Préparation des données en vue du téléchargement du fichier .CSV
- Téléchargement d’un fichier CSV dans une source
- Création d'un ensemble de données
- Sources et jeux de données multilingues
- Activation des sentiments sur un ensemble de données
- Modification des paramètres du jeu de données
- Supprimer un message
- Supprimer un jeu de données
- Exporter un ensemble de données
- Utilisation d'intégrations Exchange
- Entraînement et maintenance du modèle
- Comprendre les libellés, les champs généraux et les métadonnées
- Hiérarchie de libellés et meilleures pratiques
- Comparer les cas d’utilisation des analyses et des automatisations
- Transformer vos objectifs en libellés
- Présentation du processus d'entraînement du modèle
- Annotation générative
- Statut du jeu de données
- Entraînement des modèles et annotation des meilleures pratiques
- Entraînement avec l'analyse des sentiments des libellés activée
- Comprendre les exigences de données
- Entraîner
- Vue d'ensemble (Overview)
- Examen des prédictions de libellé
- Entraînement à l'aide de la classification par glisser-déposer
- Entraînement à l'aide de l'option Enseigner le libellé (Explore)
- Entraînement à l'aide d'une confiance faible
- Entraînement à l'aide de la recherche (Explorer)
- Affiner et réorganiser votre taxonomie
- Introduction à affiner
- Précision et rappel expliqués
- Précision et rappel
- Comment fonctionne la validation
- Comprendre et améliorer les performances du modèle
- Raisons de la faible précision moyenne des libellés
- Entraînement à l'aide du libellé Vérifier (Check label) et du libellé Manqué (Missed Label)
- Entraînement à l'aide du libellé En savoir plus (Affiner)
- Entraînement à l'aide de la recherche (affiner)
- Comprendre et augmenter la couverture
- Amélioration de l'équilibre et utilisation du rééquilibrage
- Quand arrêter l'entraînement de votre modèle
- Utilisation de champs généraux
- Extraction générative
- Vue d'ensemble (Overview)
- Configurer des champs
- Filtrage par type de champ d’extraction
- Génération de vos extractions
- Validation et annotation des extractions générées
- Meilleures pratiques et considérations
- Comprendre la validation des extractions et des performances d'extraction
- Questions fréquemment posées (FAQ)
- Utilisation des analyses et de la surveillance
- Automations et Communications Mining™
- Développeur
- Charger des données
- Téléchargement de données
- Intégration avec l'utilisateur du service Azure
- Intégration avec l'authentification d'application Azure
- Intégration d’Exchange avec l’authentification et le graphique d’application Azure
- Migration Guide: Exchange Web Services (EWS) to Microsoft Graph API
- Récupérer des données pour Tableau avec Python
- Intégration d'Elasticsearch
- Extraction de champ général
- Intégration avec Exchange auto-hébergée
- Infrastructure d’automatisation UiPath®
- Activités officielles UiPath®
- Comment les machines apprennent à comprendre les mots : guide d'intégration dans NLP
- Apprentissage basé sur des invites avec des Transformers
- Efficient Transformers II : Dilarisation des connaissances et affinement
- Transformateurs efficaces I : mécanismes d'attention
- Modélisation de l'intention hiérarchique profonde non supervisée : obtenir de la valeur sans données d'entraînement
- Correction des biais d’annotation avec Communications Mining™
- Apprentissage actif : de meilleurs modèles d'ML en moins de temps
- Tout est dans les chiffres : évaluer les performances du modèle avec des métriques
- Pourquoi la validation du modèle est importante
- Comparaison de Communications Mining™ et de Google AutoML pour l’information sur des données conversationnelles
- Licences
- FAQ et plus encore

Guide de l’utilisateur de Communications Mining
Utilisation de l'API
Nous nous efforçons de rendre l'API prévisible, et facile à utiliser et à intégrer. Si vous avez des commentaires qui pourraient nous aider à l'améliorer, ou si vous rencontrez des problèmes ou un comportement inattendu, contactez l'assistance. Nous vous répondrons dans les plus brefs délais.
Point de terminaison de l’API
Toutes les demandes d’API sont envoyées à Communications Mining™ en tant qu’objets JSON vers le point de terminaison de votre locataire via HTTPS.
Vous pouvez afficher tous les points de terminaison disponibles dans le fichier . De plus, vous pouvez consulter le Tutoriel de l’API.
Locataires intégrés via UiPath® :
https://cloud.uipath.com/<my_uipath_organisation>/<my_uipath_tenant>/reinfer_/api/...
https://cloud.uipath.com/<my_uipath_organisation>/<my_uipath_tenant>/reinfer_/api/...
Locataires intégrés via Communications Mining :
https://<mydomain>.reinfer.io/api/...
https://<mydomain>.reinfer.io/api/...
Dans Communications Mining™, les données de développement et de production ainsi que les workflows peuvent être séparés soit par des locataires distincts, soit en les plaçant dans des projets distincts dans le même locataire. Dans chaque cas, l'accès aux données est autorisé séparément, afin que les développeurs puissent avoir un accès administrateur aux données de développement tandis que des contrôles plus stricts peuvent être placés sur la production. Si vous utilisez des locataires distincts, le point de terminaison de l'API est différent pour chacune des données de développement et de production ; si vous utilisez des projets distincts dans le même locataire, le point de terminaison de ce seul locataire est utilisé pour les deux.
Authentification
All API requests require authentication to identify the user making the request. Two authentication methods are supported: developer API tokens and External Applications (OAuth Client Credentials).
Pour obtenir le jeton d'accès au développeur, procédez comme suit :
-
Accédez à IXP depuis Automation Cloud.
-
Accédez à la page Administration .
-
Sélectionnez Mon compte.
-
Sous Jeton d'API, sélectionnez le bouton Régénérer , qui générera un jeton d'accès.

Vous ne pouvez avoir qu'un seul jeton API actif à la fois. La génération d’un nouveau jeton invalidera le précédent.
Vous devez inclure l’en-tête HTTP suivant pour chaque appel API que vous effectuez, où $REINFER_TOKEN est votre jeton d’API Communications Mining™.
Authorization: Bearer $REINFER_TOKEN
Authorization: Bearer $REINFER_TOKEN
Les exemples bash supposent que vous avez enregistré votre jeton dans une variable d'environnement. Les exemples Python et Node supposent que le jeton a été stocké dans une variable locale REINFER_TOKEN via la solution de configuration choisie.
Bash
curl -X GET 'https://<my_api_endpoint>/api/...' \
-H "Authorization: Bearer $REINFER_TOKEN"
curl -X GET 'https://<my_api_endpoint>/api/...' \
-H "Authorization: Bearer $REINFER_TOKEN"
Nœud
const request = require("request");
request.get(
{
url: "https://<my_api_endpoint>/api/...",
headers: {
Authorization: "Bearer " + process.env.REINFER_TOKEN,
},
},
function (error, response, json) {
// digest response
console.log(JSON.stringify(json, null, 2));
}
);
const request = require("request");
request.get(
{
url: "https://<my_api_endpoint>/api/...",
headers: {
Authorization: "Bearer " + process.env.REINFER_TOKEN,
},
},
function (error, response, json) {
// digest response
console.log(JSON.stringify(json, null, 2));
}
);
Python
import json
import os
import requests
response = requests.get(
"https://<my_api_endpoint>/api/...",
headers={"Authorization": "Bearer " + os.environ["REINFER_TOKEN"]},
)
print(json.dumps(response.json(), indent=2, sort_keys=True))
import json
import os
import requests
response = requests.get(
"https://<my_api_endpoint>/api/...",
headers={"Authorization": "Bearer " + os.environ["REINFER_TOKEN"]},
)
print(json.dumps(response.json(), indent=2, sort_keys=True))
Réponse
{
"status": "ok"
}
{
"status": "ok"
}
Authentication with external applications
For automated or server-to-server integrations where a developer API token is not appropriate, you can authenticate using an External Application with the Client Credentials flow.
Step 1: Create an external application
An administrator must create a Confidential application and configure the required scopes based on which APIs you need to access.
Required scopes:
PM.UserPM.User.ReadIxp.ApiAccess
Save the App ID and App Secret immediately after creation, as you cannot retrieve the secret later.
For the complete instructions, check Managing External Applications.
Step 2: Assign application permissions
After creating the external application, you must assign it the appropriate permissions before it can access resources.
- Navigate to the Manage Access page in IXP in your UiPath environment.
- Search for your application by the name you gave it when you created it.
- Assign the necessary roles to the application. The application will appear in the list just like regular users.
- Save the role assignments.
For the complete permission assignment details, check Managing User and Group Roles.
Step 3: Authenticate using the client credentials flow
Use the Client Credentials grant type to obtain an access token.
Required parameters:
grant_type=client_credentialsclient_id={app_id}- from Step 1client_secret={app_secret}- from Step 1scope- the scopes you configured in Step 1 (space-separated)
For the complete authentication details, check External Applications (OAuth).
Step 4: Use the access token
Once you have an access token, include it in the Authorization header for all API requests.
Authorization: Bearer {access_token}
Authorization: Bearer {access_token}
Example request:
curl -X GET "https://cloud.uipath.com/{organizationName}/{tenantName}/reinfer_/api/v1/datasets" \
-H "Authorization: Bearer {access_token}" \
-H "Accept: application/json"
curl -X GET "https://cloud.uipath.com/{organizationName}/{tenantName}/reinfer_/api/v1/datasets" \
-H "Authorization: Bearer {access_token}" \
-H "Accept: application/json"
Replace {organizationName}, {tenantName}, and {access_token} with your actual values.
Autorisations
Chaque point de terminaison d'API dans la liste ses autorisations requises. Pour afficher les autorisations dont vous disposez, accédez à l'onglet Gérer l'accès sur la page Administration . L'onglet affiche les projets auxquels vous avez accès et les autorisations dont vous disposez par rapport à chaque projet.
Erreurs (Errors)
Nous utilisons des codes de réponse HTTP classiques pour indiquer la réussite ou l'échec d'une requête d'API. En général, les codes dans la plage 2xx indiquent un succès, les codes dans la plage 4xx indiquent une erreur qui a résulté de la requête fournie, tandis que les codes dans la plage 5xx indiquent un problème avec Communications Mining.
Les demandes de cette erreur renverront également un corps avec une valeur status de error au lieu de ok, ainsi qu'un message d'erreur décrivant l'erreur.
Bash
curl -X GET 'https://<my_api_endpoint>/api/v1/nonexistent_page' \
-H "Authorization: Bearer $REINFER_TOKEN"
curl -X GET 'https://<my_api_endpoint>/api/v1/nonexistent_page' \
-H "Authorization: Bearer $REINFER_TOKEN"
Nœud
const request = require("request");
request.get(
{
url: "https://<my_api_endpoint>/api/v1/nonexistent_page",
headers: {
Authorization: "Bearer " + process.env.REINFER_TOKEN,
},
},
function (error, response, json) {
// digest response
console.log(JSON.stringify(json, null, 2));
}
);
const request = require("request");
request.get(
{
url: "https://<my_api_endpoint>/api/v1/nonexistent_page",
headers: {
Authorization: "Bearer " + process.env.REINFER_TOKEN,
},
},
function (error, response, json) {
// digest response
console.log(JSON.stringify(json, null, 2));
}
);
Python
import json
import os
import requests
response = requests.get(
"https://<my_api_endpoint>/api/v1/nonexistent_page",
headers={"Authorization": "Bearer " + os.environ["REINFER_TOKEN"]},
)
print(json.dumps(response.json(), indent=2, sort_keys=True))
import json
import os
import requests
response = requests.get(
"https://<my_api_endpoint>/api/v1/nonexistent_page",
headers={"Authorization": "Bearer " + os.environ["REINFER_TOKEN"]},
)
print(json.dumps(response.json(), indent=2, sort_keys=True))
Réponse
{
"message": "404 Not Found",
"status": "error"
}
{
"message": "404 Not Found",
"status": "error"
}
Votre demande peut échouer en raison de problèmes sur votre réseau avant qu’elle n’atteigne Communications Mining. Dans de tels cas, la réponse que vous recevrez sera différente de la réponse d’erreur Communications Mining décrite précédemment.
Performance timing
Nous utilisons l' en-tête HTTP Server-Mining pour communiquer le temps nécessaire au traitement des requêtes adressées à notre API. Nous incluons une seule mesure, total, que vous pouvez utiliser pour mesurer le temps que notre plate-forme a mis à traiter votre demande sans latence de la demande réseau.
Un exemple de l’en-tête, tel qu’il apparaît dans une réponse :
Server-Timing: total;dur=37.7
Server-Timing: total;dur=37.7
Les valeurs Server-Timing sont toujours en millisecondes. Par conséquent, dans ce cas, la requête d'API avec cette valeur d'en-tête a pris 37,7 millisecondes à traiter sur notre plate-forme.
- Point de terminaison de l’API
- Authentification
- Authentication with external applications
- Step 1: Create an external application
- Step 2: Assign application permissions
- Step 3: Authenticate using the client credentials flow
- Step 4: Use the access token
- Autorisations
- Erreurs (Errors)
- Performance timing