Language (Langue)

Il s'agit des composants disponibles dans la catégorie Langue de l'éditeur de flux de dialogue basé sur YAML.

System.Intent

Ce composant détecte l'intention de l'utilisateur et extrait toutes les entités, puis déclenche l'état suivant.

Note

Ce composant n'est pas disponible pour les compétences développées avec le concepteur de flux visuel. Au lieu de cela, les intentions sont résolues automatiquement lorsqu'il n'y a pas de flux actif. Voir Détection et résolution des intentions.

Propriété	Description	Obligatoire?
`variable`	Contient la valeur que le cadre de traitement du langage résout à partir des données de l'entrée utilisateur. Par exemple, nos exemples de robots de compétence définissent cette propriété comme `variable=iResult` (avec `iResult: "nlpResult"` défini comme une des variables `context`). Il n'est pas nécessaire de nommer la variable `iResult`. Ce nom est une convention utilisée dans nos exemples de code et de compétences. Quel que soit le nom de variable choisi pour `nlpResult`, assurez-vous de l'utiliser systématiquement dans le flux de dialogue.	Oui
`optionsPrompt`	Titre de la liste des intentions lorsque vous définissez une valeur pour l'option Win Margin (Marge de succès). Par défaut, cette valeur de chaîne est `Do you want to (Voulez-vous)`. La valeur par défaut de cette propriété est stockée dans l'ensemble de ressources de la compétence. Pour la modifier, cliquez sur, sélectionnez l'onglet Configuration et mettez à jour la clé Intent - optionsPrompt. Si vous utilisez l'ensemble de ressources de la compétence pour modifier le message par défaut, vous n'avez pas besoin d'inclure la propriété dans le composant, sauf si vous voulez remplacer la valeur par défaut.	Non
`botName`	Nom (et non le nom d'affichage) de la compétence qui résout l'intention. Servez-vous de cette propriété si vous décidez de résoudre l'entrée utilisateur à l'aide du modèle d'une autre compétence que la compétence courante. Cette approche peut être utile si vous voulez résoudre l'intention en fonction d'un modèle dont le domaine de définition est plus étroit que celui requis par votre cas d'utilisation principal.	Non
`botVersion`	Indique la version de la compétence. La valeur par défaut est `1.0` (si vous ne spécifiez pas de numéro de version).	Non
`sourceVariable`	Le cadre de traitement du langage résout l'intention en utilisant `sourceVariable` comme entrée. Important : Vous ne pouvez pas utiliser cette propriété en combinaison avec la propriété `translate`. Si vous devez traduire l'entrée représentée par `sourceVariable`, vous pouvez utiliser System.TranslateInput pour ce faire.	Non
`daIntercept`	Pour les appels à `System. Intent`, détermine si l'assistant numérique peut intercepter et réacheminer l'entrée utilisateur vers d'autres compétences. Les valeurs suivantes sont possibles : `always` (valeur par défaut)--Autorise l'assistant numérique à intercepter l'entrée, même si le flux courant n'est pas terminé. Cela permet à l'assistant numérique de traiter les interruptions suggérant le passage à un autre flux. `never`--Empêche l'assistant numérique d'intercepter l'entrée de l'utilisateur. Pour en savoir plus sur le cas d'utilisation de la définition de cette valeur, voir Imposer des appels au composant System.Intent d'une compétence. Cette propriété est ignorée si la compétence n'appartient pas à un assistant numérique.	Non
`translate`	Remplace le jeu de valeurs pour la variable de contexte `autoTranslate` ici. Si la variable de contexte `autoTranslate` n'est pas définie ou si elle est réglée à `false`, vous pouvez régler cette propriété à `true` afin d'activer la traduction automatique pour ce composant uniquement. Si la variable de contexte `autotranslate` est réglée à `true`, vous pouvez régler cette propriété à `false` pour exclure ce composant de la traduction automatique. Important : Vous ne pouvez pas utiliser cette propriété en combinaison avec la propriété `sourceVariable`. Si vous devez traduire l'entrée représentée par `sourceVariable`, vous pouvez utiliser System.TranslateInput pour ce faire.	Non

Propriétés de FAQ pour le composant System.Intent

Il s'agit de propriétés facultatives pour l'acheminement FAQ.

Propriété	Description	Type de données	Valeur par défaut
`qnaEnable`	Active l'acheminement vers le module de FAQ. Si vous réglez cette propriété à `true` (acheminement activé), vous devez également définir l'action de transition de FAQ (`none` ou `exit`). Voir Transitions de FAQ.	booléen	`false`
`qnaBotName`	Nom (pas le nom d'affichage) de la compétence avec le module de FAQ. Si vous ne définissez pas cette propriété, la valeur définie pour la propriété `botName` du composant `System.QnA` est utilisée.	chaîne	S.O.
`qnaBotVersion`	Version de la compétence avec le module de FAQ. Par défaut, il s'agit de 1.0. Cette valeur est facultative	entier	S.O.
`qnaTimeout`	Temps, en millisecondes, pendant lequel la compétence attend que le serveur de FAQ réponde à l'entrée utilisateur.	long	`5000`
`qnaUseResult`	Réglez cette option à `true` (valeur par défaut) pour que la compétence interroge le serveur de FAQ avec l'entrée de l'utilisateur. La compétence utilise alors les résultats de l'interrogation (les correspondances) pour définir l'acheminement. Lorsque cette propriété est réglée à `true`, la compétence n'affiche le lien View Answers (Voir les réponses) que s'il y a correspondance. Réglez-la à `false` pour afficher le lien View Answers (Voir les réponses) tout le temps.	booléen	`true`
`qnaSkipIfIntentFound`	Lorsque cette option est réglée à `true`, la compétence ignore la FAQ lorsqu'une intention correspond. Avec la valeur par défaut (`false`), la compétence interroger le serveur QnA avec l'énoncé de l'utilisateur et présenter QnA comme option.	booléen	`false`
`optionsPrompt`	La FAQ s'affiche si la propriété est activée pour le composant `System.Intent` et si une correspondance est trouvée. Conseil : Pour les langues étrangères (autres que l'anglais), référencez un ensemble de ressources. Voir Référencer les ensembles de ressources dans le flux de dialogue	chaîne	`Do you want to`
`optionsQnaLabel`	Étiquette d'une action dans les options (`optionsPrompt`) qui dirige l'utilisateur vers le composant `System.QnA` pour afficher les correspondances. Conseil : Pour les langues étrangères (autres que l'anglais), référencez un ensemble de ressources. Voir Référencer les ensembles de ressources dans le flux de dialogue	chaîne	`Questions`
`qnaMatchFields`	Définit les champs Q&A utilisés pour correspondre au message de l'utilisateur. Les valeurs valides sont les suivantes : `all` `categories` `questions` `answers` `categories+questions` Vous pouvez entrer ces valeurs sous forme de liste séparée par des virgules	chaîne	`all`
`qnaMinimumMatch`	Définit le pourcentage minimum et maximum de jetons que les paires question-réponse doivent contenir pour être considérées comme une correspondance. Pour retourner les meilleures correspondances, nous avons segmenté les énoncés en unités que le moteur d'intention résout en tant que questions. Ces jetons sont formés à partir du radical des mots et de différentes combinaisons. Ainsi, un grand jeu de jetons peut être généré à partir d'un énoncé. Pour cette raison, il est peu probable qu'une paire question-réponse contienne la totalité des mots clés et variantes. Par conséquent, nous recommandons de conserver la valeur par défaut de ce paramètre, `50%,25%`. Le fait de disposer de 50 % des jetons générés (le niveau maximum par défaut) signifie que la paire question-réponse peut être considérée comme une correspondance pertinente si tous les mots clés de l'énoncé y sont présents. Si ce niveau maximum ne peut pas être atteint, un niveau minimum de 25 % devrait suffire. Si vous modifiez ces paramètres, notamment en augmentant le maximum à plus de 50 %, la paire question-réponse doit non seulement contenir tous les mots clés, mais également correspondre à des jetons supplémentaires. Donc, si vous voulez réduire la probabilité d'omettre une correspondance pertinente, et pouvez tolérer des correspondances non pertinentes, vous pouvez ajouter un seuil plus bas. Par exemple : `50%,25%,10%`. Si vous voulez réduire les correspondances non pertinentes, vous pouvez augmenter les niveaux (par exemple, `60%,50%`). Gardez à l'esprit que des paires question-réponse contenant tous les mots clés risquent alors d'être exclues. Important : Si vous ne voulez pas utiliser les niveaux par défaut, vous devez régler la propriété `minimumMatch` et l'option Match Thresholds (Seuils de correspondance) du testeur par lots de FAQ aux mêmes valeurs. Voir Tester le module de FAQ par lots.	chaîne	`50%,25%`
`qnaUseSourceVariable`	Lorsque cette option est réglée à `true`, la correspondance de FAQ est basée sur la valeur stockée dans la propriété `sourceVariable` de System.Qna, et non sur l'entrée de l'utilisateur.	booléen	`false`

System.MatchEntity

Note

Cette rubrique décrit l'utilisation de ce composant en mode YAML. Pour plus d'informations sur son utilisation dans le concepteur de flux visuel, voir Correspondance d'entité.

System.MatchEntity appelle le moteur d'intention pour extraire les informations d'entité à partir du texte contenu dans la propriété sourceVariable. S'il existe une correspondance pour le type d'entité de la variable, cette dernière est définie avec cette valeur d'entité.

Propriété	Description	Obligatoire?
`sourceVariable`	Variable contenant la valeur d'entrée.	Oui
`variable`	Nom de la variable de contexte. La valeur de cette variable peut être utilisée dans un composant `System.SetVariable` suivant pour extraire une entité spécifique à l'aide d'une expression FreeMarker. Par exemple, pour extraire une valeur d'entité `EMAIL` : `${userInputEntities.value.entityMatches['EMAIL'][0]}`	Oui

Ce composant offre également deux transitions prédéfinies : match et nomatch.

Transition	Description
`match`	Indique à quel état doit passer le moteur de dialogue lorsque les entités correspondent.
`nomatch`	Indique à quel état doit passer le moteur de dialogue lorsque les entités ne correspondent pas.

Dans l'extrait de code suivant, le composant System.MatchEntity correspond à la valeur fournie par l'utilisateur stockée dans la variable mailInput pour le type d'entité EMAIL défini pour la variable mailEntity. Si l'entrée de l'utilisateur est une adresse de courriel et respecte donc le type d'entité, le composant System.MatchEntity écrit cette valeur pour la variable mailEntity qui est répétée à l'utilisateurdu robot ("You entered ${mailEntity.value.email}"). Lorsque les valeurs ne correspondent pas, le moteur de dialogue passe à l'état nomatch.

Note

Le composant System.MatchEntity résout une seule valeur.

context:
  variables:
    iResult: "nlpresult"
    mailInput: "string"
    mailEntity: "EMAIL"
states:
  intent:
    component: "System.Intent"
    properties:
      variable: "iResult"
    transitions:
      actions:
        displayMailAdresses: "askMail"
        unresolvedIntent: "dunno"
  askMail:
    component: "System.Text"
    properties:
      prompt: "Please provide a valid email address"
      variable: "mailInput"
    transitions:
      next: "matchEntity"
  matchEntity:
    component: "System.MatchEntity"
    properties:
      sourceVariable: "mailInput"
      variable: "mailEntity"
    transitions:
      actions:
        match: "print"
        nomatch: "nomatch"
  print:
    component: "System.Output"
    properties:
      text: "You entered ${mailEntity.value.email}"
    transitions:
      return: "done"
  nomatch:
    component: "System.Output"
    properties:
      text: "All I wanted was a valid email address."
    transitions:
      return: "done"
  dunno:
    component: "System.Output"
    properties:
      text: "I don't know what you want"
    transitions:
      return: "done"

System.DetectLanguage

Note

Cette rubrique décrit l'utilisation de ce composant en mode YAML. Pour plus d'informations sur son utilisation dans le concepteur de flux visuel, voir Détecter la langue.

Ce composant utilise le service de traduction pour détecter la langue de l'utilisateur à partir de l'entrée ou du contenu enregistré dans une variable de contexte référencée par une propriété source :

context:
  variables:
    autoTranslate: "boolean"
    translated: "string"
    someTranslatedText: "string"
states:
  setAutoTranslate:
    component: "System.SetVariable"
    properties:
      variable: "autoTranslate"
      value: true
    transitions:
      next: "detect"
   detect:
    component: "System.DetectLanguage"
    properties:
      source: "someTranslatedText"  
      useExistingProfileLanguageTag: true
    transitions:
      ...

Le composant System.DetectLanguage définit une variable nommée profile.languageTag avec la chaîne de paramètres régionaux. Vous pouvez définir des variables avec la langue courante lorsque vous utilisez cette variable dans une expression de valeur (${profile.languageTag}).

Note

La variable profile.languageTag est prioritaire par rapport à la variable profile.locale définie par le client de messagerie.

La propriété useExistingProfileLanguageTag est utilisée lorsqu'une compétence fait partie d'un assistant numérique doté d'un service de traduction. Ceci permet à la compétence d'utiliser immédiatement la langue détectée par l'assistant numérique. Sinon, la compétence peut fournir un message ou une invite en anglais avant que la langue ne soit détectée (à nouveau). Si la compétence figure dans un assistant numérique ne permettant pas la traduction, la propriété est ignorée.

Variables profile.locale et profile.languageTag

L'utilisation d'un ensemble de ressources particulier et les traductions des étiquettes d'interface utilisateur et des messages du composant dépendent de la langue de l'utilisateur stockée dans les variables profile.locale et profile.languageTag.

La façon dont ces variables sont définies dépend du mode de langue de la compétence :

Pour les compétences qui utilisent la prise en charge linguistique native, la langue est détectée automatiquement et ces variables sont alimentées avec la valeur appropriée, sauf si des valeurs ont déjà été affectées aux variables.
Pour les compétences qui utilisent un service de traduction :
- La valeur de la variable profile.locale est dérivée du client de messagerie de l'utilisateur.
  Note
  
  profile.locale prend en charge les valeurs au format ISO du pays ou ISO language_country.
- La valeur de la variable profile.languageTag est fournie par le composant System.DetectLanguage.

Note

La valeur définie pour la variable profile.locale peut déterminer les formats propres aux locaux pour les entités DATE, CURRENCY et NUMBER même lorsqu'une valeur a été définie pour la variable profile.languageTag.

Vous pouvez définir la valeur de ces deux variables (et leur permettre de définir des valeurs l'une pour l'autre) à l'aide de System.SetVariable. Par exemple :

setLocaleToGerman:
  component: "System.SetVariable"
  properties:
    variable: "profile.locale"
    value: "de"

setLanguageTagToGerman:
  component: "System.SetVariable"
  properties:
    variable: "profile.languageTag"
    value: "de"

setLanguageToVariableValue:
  component: "System.SetVariable"
  properties:
    variable: "profile.languageTag"
    value: "${language_preference_var.value}"

setLocaleToLanguageTag:
  component: "System.SetVariable"
  properties:
    variable: "profile.locale"
    value: "${profile.languageTag}"

setTagToLocale:
  component: "System.SetVariable"
  properties:
    variable: "profile.languageTag"
    value: "${profile.locale}"

Conseil :

Vous pouvez mettre en oeuvre une liste de choix de langues en comparant la valeur de paramètres régionaux stockée dans ces variables, ou dans une table de base de données d'utilisateurs personnalisée, à une liste de langues prises en charge. Si la langue détectée n'est pas dans cette liste, vous pouvez inviter l'utilisateur à en choisir une, puis définir profile.languageTag avec cette valeur.

System.TranslateInput

Note

Cette rubrique décrit l'utilisation de ce composant en mode YAML. Pour plus d'informations sur son utilisation dans le concepteur de flux visuel, voir Entrée de traduction.

Ce composant envoie le texte spécifié au service de traduction de la compétence, puis stocke la traduction en anglais. Il s'appuie sur la compétence configurée avec un service de traduction, qui reconnaît la langue de l'entrée de l'utilisateur et la convertit en anglais. Ce composant ne fonctionne pas avec les compétences qui utilisent le mode linguistique pris en charge de manière native.

Utilisez ce composant lorsque vous devez traiter le texte d'entrée brut avant de le traduire. Par exemple, vous voulez supprimer certaines données personnelles de l'entrée utilisateur avant de l'envoyer au service de traduction.

Propriété	Description	Obligatoire?
`source`	Indique les valeurs de texte à traduire en anglais.	Non
`variable`	Variable contenant la traduction en anglais du texte.	Oui

Comme le composant System.TranslateInput tire parti du service de traduction, qui détecte la langue de l'utilisateur, ce composant n'a pas besoin de suivre les états qui détectent ou définissent la langue comme décrit dans la rubrique Ajouter un service de traduction à votre compétence. Ainsi, vous pouvez stocker la traduction en anglais d'une entrée utilisateur directe ou d'une variable source.

Traduction d'entrée directe

Le composant System.TranslateInput stocke la traduction en anglais de l'entrée utilisateur directe dans sa propriété variable. L'extrait de code suivant montre comment l'entrée de l'utilisateur, par exemple "Hallo, ich bin ein Mensch" dans la variable translatedString est stockée en tant que "Hello, je suis un être humain".

context:
  variables:
     translatedString: “string”
     sourceString: “string”
...

states:
...

  translateInput:
    component: "System.TranslateInput"
      properties:
        variable: "translatedString"

Variable source

Dans l'extrait de code suivant, la variable sourceString contient l'entrée de l'utilisateur. (Cette entrée, par exemple, a été collectée par un composant Common Response). Une fois le traitement par le composant System.TranslateInput terminé, la traduction en anglais est stockée dans la variable translatedString.

context:
  variables:
    autoTranslate: "boolean" 
    translatedString: "string"
    sourceString: "string"    

   ...

states:
   ...

  translateInputString:
    component: "System.TranslateInput"
    properties:
      source: "sourceString"
      variable: "translatedString"
    transitions: 
      ...

Note

Le composant System.TranslateInput ne peut pas traduire les objets de données ou les tableaux stockés dans une variable de contexte par un composant personnalisé. Ce contenu ne peut être traduit que lorsque la variable est référencée par un composant qui utilise la traduction automatique. Par exemple, le composant System.TranslateInput ne peut pas traduire un objet de données tel que {"product": "scissors", "color": "silver"} en scissors et silver.

Propriété sourceVariable

Comme la propriété sourceVariable de System.Intent contient la valeur traitée par le composant, vous pouvez l'utiliser avec le composant System.TranslateInput pour insérer du texte traduit. L'extrait de code suivant présente l'affectation de la valeur de variable translated afin qu'elle puisse être traitée par le moteur de traitement du langage naturel (TLN).


  translate:
    component: "System.TranslateInput"
    properties:
      variable: "translated"
    transitions: 
      next: "intent"
  intent:
    component: "System.Intent"
    properties:
      variable: "iResult"
      sourceVariable: "translated"
...

System.TranslateOutput

Note

Cette rubrique décrit l'utilisation de ce composant en mode YAML. Pour plus d'informations sur son utilisation dans le concepteur de flux visuel, voir Traduire la sortie.

Le composant System.TranslateOutput permet de traduire du texte dans la langue de l'utilisateur. Le composant prend la valeur définie pour la propriété source. Le texte est traduit dans la langue détectée par le composant System.DetectLanguage ou par la variable profile.locale, puis stocké dans la propriété variable.

Propriétés	Description	Obligatoire?
`source`	Texte à traduire ou expression FreeMarker qui référence une variable dont la valeur doit être traduite.	Oui
`variable`	Contient le texte traduit.	Oui

Dans cet exemple, le composant System.Output, qui affiche normalement du texte traduit automatiquement, produit toujours du texte traduit, mais dans le cas présent, il produit la traduction du texte définie pour la propriété source.

  unresolvedTranslate:
    component: "System.TranslateOutput"
    properties:
      source: "Sorry I don't understand"
      variable: "someTranslatedText"
    transitions:
      next: "unresolved"
  unresolved:
    component: "System.Output"
    properties:
      text: "${someTranslatedText}"
    transitions:
      return: "unresolved"

System.Qna

Le tableau suivant présente les propriétés facultatives du composant System.Qna.

Le nom	Description	Obligatoire?	Valeur par défaut
`botName`	Nom (pas le nom d'affichage) de la compétence avec le module de FAQ.	Non	S.O.
`botVersion`	Version de la compétence identifiée par la propriété `botName`. Vous pouvez définir la propriété `botName` sans définir également la propriété `botVersion`. Toutefois, vous ne pouvez pas définir `botVersion` sans également définir `botName` : `botVersion` est ignoré lorsque vous ne définissez pas la propriété `botName`. Par conséquent, la version par défaut (`1.0`) est appliquée uniquement si vous définissez la propriété `botName`. Pour effectuer une redirection vers une autre version de la compétence, vous devez définir la propriété `botName` et régler la propriété `botVersion` à la version cible.	Non	1
`highlighter`	Méthode utilisée pour mettre en évidence le texte le plus pertinent dans chaque réponse. Les valeurs possibles sont : `system` - Le système tente de déterminer le texte le plus pertinent dans la réponse et met ces mots en surbrillance. `firstNChars` - Les premiers caractères de la réponse sont mis en surbrillance. Le nombre de caractères est déterminé par la valeur de la propriété `highlightLength` plus les caractères restants dans le mot en surbrillance final.	Non	`system`
`highlightLength`	Nombre de caractères à mettre en surbrillance dans chaque réponse.	Non	100
`sourceVariable`	Le cadre de traitement du langage permet de résoudre les correspondances de FAQ à l'aide de la valeur stockée par `sourceVariable` et non de l'entrée utilisateur. Vous activez cette mise en correspondance en réglant `qnaUseSourceVariable: true` pour le composant System.Intent. Par exemple : metadata: platformVersion: "1.0" main: true name: "FinancialBotMainFlow" context: variables: iResult: "nlpresult" iResult2: "nlpresult" transaction: "string" faqstring1: "string" faqstring2: "string" states: ... setVariable: component: "System.SetVariable" properties: variable: "faqstring1" value: "Tell me about family floater plan" ... intent2: component: "System.Intent" properties: variable: "iResult" sourceVariable: "faqstring1" qnaEnable: true qnaUseSourceVariable: true transitions: actions: Send Money: "sendMoney" Balances: "balances" unresolvedIntent: "unresolved" qna: "qna" sendMoney: component: "System.Output" properties: text: "send money" transitions: return: "sendMoney" balances: component: "System.Output" properties: text: "Balances" transitions: return: "balances" unresolved: component: "System.Output" properties: text: "Sorry I don't understand that question!" transitions: return: "unresolved" qna: component: "System.QnA" properties: sourceVariable: "faqString1" transitions: actions: none: "unresolved" next: "intent2"	Non	S.O.
`transitionOnTextReceived`	Effectue une transition à partir de l'état défini avec le composant `System.QnA` lorsque l'utilisateur entre du texte libre. `true` (valeur par défaut)—Effectue une transition à partir de l'état `System.Qna` lorsque la compétence reçoit du texte libre. Votre compétence peut tenter de résoudre ce texte lorsque vous configurez une transition à un état `System.Intent` qui est configuré avec les propriétés de FAQ. `false`—Le moteur de dialogue reste à l'état FAQ, le texte libre étant traité comme une interrogation de FAQ. Le composant affiche également une option de sortie. Par défaut, ce bouton porte la mention Exit Questions (Quitter les questions), mais vous pouvez modifier cette étiquette à l'aide de la propriété `exitLabel`. Comme une option de sortie est ajoutée, vous devez configurer la transition `exit`.	Non	`true`
`keepTurn`	La propriété `keepTurn` se comporte différemment selon la manière dont l'utilisateur effectue la transition depuis l'état défini avec le composant `System.QnA`. Vous pouvez configurer la façon dont `keepTurn` dirige l'utilisateur dans le flux à l'aide d'une expression booléenne (true, false) ou avec un mappage de paires clé-valeur.	Non	`false` (lors de la configuration en tant qu'expression booléenne)
`matchListLimit`	Limite la pagination des réponses	Non	5
`categoryListLimit`	Limite la pagination des catégories	Non	5
`resultLayout`	Disposition des réponses qui correspondent. Valeurs valides : `horizontal` et `vertical`.	Non	horizontal
`minimumMatch`	Définit le pourcentage minimum et maximum de jetons que les paires question-réponse doivent contenir pour être considérées comme une correspondance. Pour retourner les meilleures correspondances, nous avons segmenté les énoncés en unités que le moteur d'intention résout en tant que questions. Ces jetons sont formés à partir du radical des mots et de différentes combinaisons. Selon la longueur du message de l'utilisateur, le processus peut générer un jeu de jetons important. Comme il est peu probable qu'une paire question-réponse puisse correspondre à tous, il est recommandé de régler le niveau de correspondance à `50%, 25%`. Avec ce paramètre, une paire question-réponse peut être considérée comme pertinente si elle correspond à 50 % des jetons. Si ce niveau maximum ne peut pas être atteint, un niveau minimal de 25 % suffit. Si vous voulez réduire la probabilité d'omettre une correspondance pertinente, et pouvez tolérer des correspondances non pertinentes, vous pouvez ajouter un seuil plus bas en substitution. Par exemple : `50%,25%,10%.` Si vous voulez réduire les correspondances non pertinentes, vous pouvez augmenter le pourcentage (par exemple, `minimumMatch: "80%"`), mais dans ce cas, vous risquez d'obtenir des correspondances inattendues pour les messages comportant trois à sept mots. Ce dit, vous pouvez régler la précision de la FAQ retournée pour les interrogations courtes et longues de l'utilisateur. Important : Si vous ne voulez pas utiliser les niveaux par défaut, vous devez régler la propriété `QnaMinimumMatch` et l'option Match Thresholds (Seuils de correspondance) du testeur par lots de FAQ aux valeurs définies pour la propriété `minimumMatch`. Voir Tester le module de FAQ par lots.	Non	50%25%
`matchfields`	Définit les champs Q&A utilisés pour correspondre au message de l'utilisateur. Les valeurs valides sont les suivantes : `all` `categories` `questions` `answers` `categories+questions` Vous pouvez entrer ces valeurs sous forme de liste séparée par des virgules.	Non	`all`
`enableCategoryDrilldown`	Réglez à `true` pour afficher un forage par catégorie.	Non	`true`
`exitLabel`	Texte de l'étiquette de sortie du module de FAQ.	Non	`Exit Questions`
`viewAnswerLabel`	Texte pour l'action de consultation des détails d'une réponse.	Non	`View`
`moreAnswersLabel`	Texte pour l'action de consultation des réponses supplémentaires.	Non	`More Answers`
`answersLabel`	Texte pour les actions de consultation des réponses d'une catégorie spécifique.	Non	`Answers`
`categoriesLabel`	Texte pour les catégories correspondant à l'énoncé.	Non	`Categories`
`subCategoriesLabel`	Texte pour l'action de consultation des sous-catégories.	Non	`Sub-Categories`
`moreCategoriesLabel`	Texte pour l'action de consultation de catégories supplémentaires.	Non	`More Categories`

Augmenter la précision des FAQ retournées à l'aide de minimumMatch

La valeur par défaut 50%,25% retourne des paires question-réponse pertinentes, mais vous pouvez configurer la compétence pour qu'elle fournisse des résultats moins nombreux et plus précis en augmentant le pourcentage. Par exemple, vous pouvez faire en sorte qu'elle ne retourne une paire question-réponse que si celle-ci correspond à un pourcentage élevé des jetons, et sinon orienter l'utilisateur vers un agent humain.

Dans un tel scénario, l'augmentation du pourcentage de la propriété minimumMatch à 80% peut retourner des correspondances de FAQ plus précises, en particulier pour les messages longs. Ce n'est pas nécessairement pas le cas pour les messages courts qui comportent généralement trois à sept mots, dont 50 % sont omis (mots non significatifs). Par exemple, dans la question d'utilisateur What is account security? (À quoi sert la sécurité du compte)?, le système détecte deux jetons, account et security. Lorsque minimumMatch est réglé à 80 %, un seul des jetons est retourné (80 % de 2 est 1,6, ce qui est arrondi à 1), alors qu'idéalement, les deux devraient l'être. Dans ce cas, la compétence peut retourner des paires question-réponse qui décrivent les comptes de manière générale, ce qui représente trop de réponses. La compétence aurait dû retourner des paires question-réponse concernant exclusivement la sécurité du compte, ou ne rien retourner du tout.

Pour configurer la propriété minimumMatch afin qu'elle retourne une paire question-réponse exacte pour les messages courts, entrez le nombre de jetons qui doivent être appariés, un opérateur inférieur à (<) et le niveau de correspondance requis lorsque le message contient un nombre supérieur de jetons. Par exemple :

  qna:
    component: "System.QnA"
    properties:
      minimumMatch: "3<80%"
    transitions:
      actions:
        none: "unresolved"
      next: "intent"

Dans cet extrait de code, si le message contient un à trois jetons, la paire question-réponse doit correspondre à tous pour que la compétence la propose à l'utilisateur. Pour l'exemple qui précède, cette configuration ne retourne que des paires question- réponse liées à la sécurité de compte. Lorsque le message comporte quatre jetons ou plus, les paires question-réponse retournées doivent seulement correspondre à 80 % d'entre eux.

Vous pouvez régler la correspondance minimale pour les messages plus longs contenant des détails supplémentaires en augmentant le nombre de jetons correspondants obligatoires (tout en réduisant le pourcentage). L'exemple suivant montre comment traiter les messages pouvant contenir plus de neuf jetons :

  qna:
    component: "System.QnA"
    properties:
      minimumMatch: "3<80% 8<70% 12<65%"  
    transitions:
      actions:
        none: "unresolved"
      next: "intent"

Selon la configuration du paramètre minimumMatch de cet extrait de code, la compétence retourne des paires question-réponse comme suit.

Nombre de jetons du message	Nombre de jetons qui doivent correspondre
1	1
2	2
3	3
4 (80% match)	3 (3,2, arrondi à 3)
5 (80% match)	4
6 (80% match)	4 (4,8, arrondi à 4)
7 (80% match)	5 (5,6, arrondi à 5)
8 (80% match)	6 (6,4 arrondi à 6)
9 (70% match)	6 (6,3, arrondi à 5)
10 (70 % de correspondance)	7
11 (70 % de correspondance)	7 (7,7, arrondi à 7)
12 (70 % de correspondance)	8 (8,4, arrondi à 8)
13 (65 % de correspondance)	8 (8,45, arrondi à 8)

Mappages clé-valeur et actions de transition keepTurn

Vous pouvez définir la propriété keepTurn comme un mappage dont les clés décrivent les transitions.

Clé	Description	Valeur par défaut
`next`	Lorsque cette option est réglée à `false`, la compétence abandonne le contrôle lorsque le dialogue passe à l'état suivant. La compétence ne traite aucune entrée utilisateur tant que le moteur de dialogue n'est pas passé à l'état suivant.	`false`
`none`	Lorsque cette option est réglée à `true`, la compétence conserve le contrôle lorsqu'une action de transition `none` est déclenchée car aucune question ne peut être retournée pour l'entrée de l'utilisateur.	`true`
`exit`	Lorsque cette option est réglée à `true`, la compétence conserve le contrôle lorsqu'une action de transition `exit` a été déclenchée.	`true`
`textReceived`	Lorsque cette option est réglée à `true`, la compétence conserve le contrôle de la conversation lorsque `transitionOnTextReceived` est réglé à `true`, qui indique au moteur de dialogue de quitter l'état.	`true`

Transitions de FAQ

Le nom	Description	Obligatoire?
`none`	Aucune correspondance n'a été trouvée pour l'entrée utilisateur (ce qui signifie généralement que le flux passe à un état informant l'utilisateur qu'aucune correspondance de ce type n'a été trouvée).	Oui
`exit`	L'utilisateur quitte le module de FAQ. Par défaut, `keepTurn` est réglé à `true` pour cette action.	Non

Documentation sur Oracle Cloud Infrastructure