Appeler un composant de modèle de langue volumineux

Le composant Invoke Large Language Model (composant LLLM) du concepteur visuel de flux vous permet de connecter un flux au LLM via un appel de service REST.

Vous pouvez insérer cet état de composant dans votre flux de dialogue en sélectionnant Intégration de service > Appeler un modèle de langue volumineux dans la boîte de dialogue Ajouter un état. Pour activer les conversations multi-tours lorsque les briques sont appelées à partir d'un assistant numérique, entrez une description pour la description du LLM.
Il s'agit d'une image du champ Descripiton de la page General.

Remarque

Il est recommandé d'ajouter toujours des descriptions aux composants LLM pour permettre des affinements multi-tours lorsque les utilisateurs accèdent au service LLM via un assistant numérique.

L'insertion de l'état du composant LLM ajoute un état de gestion des erreurs pour le dépannage des demandes adressées au LLM et de ses réponses. L'état du composant LLM passe à cet état (appelé ShowLLMError par défaut) lorsqu'une demande ou une réponse non valide provoque une erreur non récupérable.
Description de l'image invokellm-added-flow.png suivante
Description de l'illustration invokellm-added-flow.png

En plus d'appeler le service LLM, l'état du composant LLM gère les transactions interactives, telles que les affinements multi-tours, les échanges aller-retour entre l'utilisateur et le LMM qui affinent la sortie LLM par le biais d'arrondissements de commentaires des utilisateurs.
Remarque

L'affinement de réponse peut également provenir du système lorsqu'il implémente des nouvelles tentatives après l'échec de la validation.
Vous pouvez envoyer le résultat du modèle LLM sous forme de message ou l'enregistrer dans une variable de flux de dialogue pour une utilisation en aval. La validation intégrée du composant LLM fournit des garde-fous contre les vulnérabilités telles que les attaques par injection rapide qui contournent les directives de modération de contenu du modèle.
Remarque

Si vous souhaitez améliorer la validation que le composant LLM fournit déjà, ou si vous souhaitez améliorer la sortie LLM à l'aide de la technique RCI (Recursive Criticism and Improvement), vous pouvez utiliser notre code de départ pour créer vos propres gestionnaires de validation de demande et de réponse.

De quoi avez-vous besoin pour utiliser ce composant ? Si vous accédez au modèle Cohere directement ou via Oracle Generative AI Service, vous avez juste besoin d'un service LLM pour le modèle Cohere et d'une invite, qui est un bloc de texte lisible par l'utilisateur contenant les instructions pour le LLM. Etant donné que l'écriture d'une invite est un processus itératif, nous vous fournissons des directives d'ingénierie d'invite et le générateur d'invite, où vous pouvez incorporer ces directives dans votre texte d'invite et le tester jusqu'à ce qu'il obtienne la réponse appropriée du modèle. Si vous utilisez un autre modèle, comme Azure OpenAI, vous devez d'abord créer votre propre gestionnaire d'événements de transformation à partir du code de démarrage que nous fournissons, puis créer un service LLM qui met en correspondance ce gestionnaire avec les adresses du fournisseur LLM configurées pour l'instance.

Propriétés générales

Propriété Description Valeur par défaut Requis ?
Service LLM Liste des services LLLM configurés pour la brique. S'il en existe plusieurs, le service LLM par défaut est utilisé lorsqu'aucun service n'a été sélectionné. Le service LLM par défaut L'état peut être valide sans le service LLM, mais la brique ne peut pas se connecter au modèle si cette propriété n'a pas été définie.
Invite Invite propre au modèle accessible via le service LLM sélectionné. Gardez nos directives générales à l'esprit lors de la rédaction de votre invite. Vous pouvez saisir l'invite dans ce champ, puis la réviser et la tester à l'aide du générateur d'invites (accessible en cliquant sur Créer une invite). Vous pouvez également composer votre invite à l'aide de Paramétrage des invites. N/A Oui
Paramètres d'invite valeurs du paramètre. Utilisez la syntaxe d'expression Apache FreeMarker standard (${parameter}) pour référencer les paramètres dans le texte de l'invite. Par exemple :
Draft an email about ${opportunity} sales.
Pour les variables de conteneur composite, utilisez la syntaxe de conteneur composite :
  • ${cb_entity.value.bag_item.value} pour les éléments de liste de valeurs
  • ${cb_entity.value.bag_item} pour les éléments de liste sans valeur
Vous devez définir tous les paramètres de l'invite ou chacun des paramètres référencés dans le texte de l'invite. Tous les paramètres d'invite manquants sont signalés comme des erreurs.
N/A Non
Variable de résultat Variable stockant la réponse LLM. N/A Non

Messagerie utilisateur

Ces options s'appliquent uniquement lorsque vous définissez Envoyer le résultat LLM en tant que message sur Vrai.
Propriété Description Valeurs par défaut Requis ?
Envoyer le résultat LLM en tant que message Si vous définissez cette propriété sur True, le résultat LLM est envoyé à l'utilisateur. La définition de cette propriété sur False empêche l'envoi de la sortie à l'utilisateur. Vrai Non
Utiliser Streaming Les résultats LLM sont transmis au client lorsque vous définissez cette option sur True, ce qui permet d'offrir une expérience utilisateur plus fluide car la réponse LLM apparaît de manière incrémentielle au fur et à mesure qu'elle est générée. Cette option n'est disponible que si vous avez défini l'option Envoyer le résultat LLM en tant que message sur Vrai.

Les utilisateurs peuvent afficher les réponses potentiellement non valides car le gestionnaire d'événements de validation est appelé une fois que la réponse LLM a déjà démarré la transmission en continu.

Définissez Utiliser Streaming sur Faux pour les modèles Cohere ou lorsque vous avez appliqué un schéma JSON au résultat LLM en définissant Imposer une réponse LLM au format JSON sur Vrai.

Ne pas activer la transmission en continu si :
  • Votre brique est exécutée sur les canaux Slack ou Microsoft Teams.
  • Vous avez défini la validation des réponses. Le gestionnaire peut uniquement valider une réponse complète. Par conséquent, si vous définissez l'option Utiliser Streaming sur Vrai, les utilisateurs peuvent envoyer plusieurs flux de sortie, ce qui peut les embrouiller.
Vrai Non
Start Message Message de statut envoyé à l'utilisateur lorsque la LM a été appelée. Ce message, qui est réellement affiché avant l'appel LLM, peut être un indicateur utile. Il peut informer les utilisateurs que le traitement a lieu, ou que le LLM peut prendre un certain temps pour répondre. N/A Non
Activer les affinements multitours En définissant cette option sur True (valeur par défaut), vous autorisez les utilisateurs à affiner la réponse LLM en fournissant des instructions de suivi. La boîte de dialogue libère le tour à l'utilisateur mais reste à l'état LLM une fois que le résultat LLM a été reçu. Lorsque cette propriété est définie sur False, la boîte de dialogue conserve le tour jusqu'à ce que la réponse LLM soit reçue et passe à l'état référencé par l'action Succès.

Remarque : la description du composant est requise pour les affinements à plusieurs tours lorsque la brique est appelée à partir d'un assistant numérique.

Vrai Non
Actions standard Ajoute les boutons d'action standard qui s'affichent sous la sortie dans le message de résultat LLM. Tous ces boutons sont activés par défaut.
  • Soumettre : lorsqu'un utilisateur sélectionne ce bouton, la transition next est déclenchée et le gestionnaire d'événements submit est déclenché.
  • Annuler : lorsqu'un utilisateur sélectionne ce bouton, la boîte de dialogue passe à l'état défini pour la transition annuler.
  • Annuler : lorsque vous cliquez sur cette option, la brique supprime la dernière réponse d'affinement et revient au résultat précédent. La brique supprime également l'affinement précédent de l'historique des discussions. Ce bouton ne s'affiche pas dans la réponse initiale. Elle ne s'affiche qu'une fois que le service LLM a généré des options.
    Les boutons Soumettre, Annuler et Annuler au bas du message.

Les options Soumettre, Annuler et Annuler sont toutes sélectionnées. Non
Libellé du bouton Annuler Libellé du bouton Annuler Submit Oui : lorsque l'action Annuler est définie.
Libellé du bouton Réussi Intitulé du bouton Succès Cancel Oui - lorsque l'action Succès est définie.
Intitulé du bouton Annuler Intitulé du bouton Annuler Undo Oui : lorsque l'action Annuler est définie.
Actions personnalisées Bouton d'action personnalisée. Saisissez un libellé de bouton et une invite avec des instructions supplémentaires. N/A Non

Actions de transition pour le composant Appeler un modèle de langage volumineux

Action Description
cancel

Cette action est déclenchée lorsque les utilisateurs touchent le bouton Annuler.

error

Cette action est déclenchée lorsque les demandes ou les réponses de la LM ne sont pas valides. Par exemple, l'affectation d'invites de nouvelle tentative pour corriger les erreurs JSON ou de valeur d'entité a été utilisée.

Notations utilisateur pour le contenu généré par LLM

Par défaut, l'évaluation de l'utilisateur (pouces vers le haut et pouces vers le bas) s'affiche sur chaque message.
Icônes Pouces vers le haut et Pouces vers le bas dans le message de réponse de la brique

Lorsque les utilisateurs attribuent une notation descendante à la réponse LLM, la brique suit avec un lien qui ouvre un formulaire de retour.

Vous pouvez désactiver ces boutons en désactivant Activer le retour sur le modèle de langue volumineux dans Paramètres > Configuration.
Option Activer le retour sur le modèle de langue volumineux.

Validation de réponse

Propriété Description Valeur par défaut Requis ?
Entités de validation Sélectionnez les entités dont les valeurs doivent être mises en correspondance dans le message de réponse LLM. Les noms de ces entités et leurs valeurs correspondantes sont transmis sous forme de correspondance au gestionnaire d'événements, qui évalue cet objet pour les correspondances d'entités manquantes. Lorsque des correspondances d'entité manquantes entraînent l'échec de la validation, le gestionnaire renvoie un message d'erreur nommant les entités sans correspondance, qui est ensuite envoyé au modèle. Le modèle tente alors de régénérer une réponse qui inclut les valeurs manquantes. Il poursuit ses tentatives jusqu'à ce que le gestionnaire valide sa sortie ou jusqu'à ce qu'il ait épuisé son nombre de tentatives.

Nous vous recommandons d'utiliser des entités de conteneur composite pour permettre au gestionnaire d'événements de générer des messages d'erreur concis, car les libellés et les messages d'erreur appliqués à des éléments de conteneur composite individuels fournissent au LLM des détails sur les valeurs d'entité qu'il n'a pas pu inclure dans sa réponse.

N/A Non
Appliquer une réponse LLM au format JSON En définissant ce paramètre sur True, vous pouvez appliquer un formatage JSON à la réponse LLM en copiant et collant un schéma JSON. Le composant LLM valide la réponse LLM au format JSON par rapport à ce schéma.

Si vous ne voulez pas que les utilisateurs visualisent le résultat LLM en tant que JSON brut, vous pouvez créer un gestionnaire d'événements avec une méthode changeBotMessages qui transforme le JSON en un format convivial, comme un formulaire avec des tables.

Définissez Utiliser Streaming sur Faux si vous appliquez un formatage JSON.

GPT-3.5 présente plus de robustesse que GPT-4 pour la validation de schéma JSON. GPT-4 corrige parfois une réponse.

Faux Non
Nombre de tentatives Nombre maximal de nouvelles tentatives autorisées lorsque la LLM est appelée avec une invite de nouvelle tentative lorsque des erreurs de validation JSON ou d'entité ont été trouvées. L'invite de nouvelle tentative indique les erreurs et les demandes que le LLM a corrigées. Par défaut, le composant LLM effectue une seule demande de nouvelle tentative. Une fois l'affectation de nouvelles tentatives atteinte, le cycle de validation de l'invite de nouvelle tentative se termine. La boîte de dialogue se déplace ensuite du composant LLM via sa transition d'erreur. 1 Non
Message de nouvelle tentative Message de statut envoyé à l'utilisateur lorsque la LM a été appelée à l'aide d'une invite de nouvelle tentative. Par exemple, la commande suivante énumère les erreurs d'entité et JSON à l'aide de la propriété d'événement allValidationErrors :
Trying to fix the following errors: ${system.llm.messageHistory.value.allValidationErrors?join(', ')}}
Enhancing the response. One moment, please... Non
Gestionnaire de personnalisation de validation Si votre cas d'emploi nécessite une validation spécialisée, vous pouvez sélectionner le gestionnaire de validation personnalisé déployé dans votre brique. Par exemple, vous avez peut-être créé un gestionnaire d'événements pour votre brique qui non seulement valide et applique un traitement ultérieur à la réponse LLM, mais évalue également les demandes utilisateur de contenu toxique. Si votre cas d'emploi exige que la validation d'entité ou JSON dépend de règles spécifiques, telles que les correspondances d'entités interdépendantes (par exemple, la présence d'une valeur d'entité dans le résultat LLM nécessite ou exclut la présence d'une autre), vous devrez créer le gestionnaire pour cette brique avant de la sélectionner ici. N/A Non

Créer des gestionnaires de validation et de personnalisation LLM

Outre les gestionnaires de transformation LLM, vous pouvez également utiliser des gestionnaires d'événements pour valider les demandes adressées à LLM et ses réponses (les transactions de fin générées par le fournisseur LLM). En règle générale, ce code, appelé gestionnaire de validation et de personnalisation LLM, est séparé du code du gestionnaire de transformation LLM car il fonctionne à différents niveaux. La validation des demandes et des réponses est spécifique à un état LLM et à son invite. La validation de transformation LLM, quant à elle, s'applique à l'ensemble de la brique car sa logique de transformation de demande et de réponse est généralement la même pour tous les appels LLM de la brique.

Alors que le composant LLM fournit des garde-fous de validation pour prévenir les hallucinations et se protéger contre les attaques par injection rapide destinées à contourner les directives de modération de contenu du modèle ou à exploiter d'autres vulnérabilités, vous pouvez créer des valideurs spécialisés entièrement à partir de zéro à l'aide des méthodes LlmComponentContext dans le fichier bots-node-sdk, ou en intégrant ces méthodes dans le modèle que nous fournissons.
Remarque

Dans sa forme non modifiée, le code modèle exécute les mêmes fonctions de validation que celles déjà fournies par le composant LLM.

Vous pouvez créer votre propre gestionnaire d'événements de validation qui personnalise la présentation de la réponse LLM. Dans ce cas, le texte de réponse LLM peut être envoyé à partir du gestionnaire dans le cadre d'un message utilisateur. Par exemple, si vous demandez au LLM d'envoyer une réponse structurée au format JSON, vous pouvez analyser la réponse et générer un message formaté sous forme de table ou de carte.

Pour créer un gestionnaire d'événements à l'aide de ce modèle :
  1. Cliquez sur Composants dans la barre de navigation de gauche.
  2. Cliquez sur +New Service.
  3. Renseignez la boîte de dialogue Create Service comme suit :
    • Nom : entrez le nom de service.
    • Type de service : Conteneur imbriqué
    • Type de package de services de composant : Nouveau composant
    • Type de composant : Validation et personnalisation LLLM
    • Nom de composant : entrez un nom facilement identifiable pour le gestionnaire d'événements. Vous référencerez ce nom lorsque vous créerez le service LLM pour la brique.
  4. Cliquez sur Créer pour générer le gestionnaire de validation.
  5. Une fois le déploiement terminé, développez le service, puis sélectionnez le gestionnaire de validation.
  6. Cliquez sur Modifier pour ouvrir l'éditeur Modifier le code de composant.
  7. A l'aide du modèle généré, mettez à jour les méthodes de gestionnaire suivantes si nécessaire.
    Méthode Description Lorsque la validation réussit Lorsque la validation échoue Type renvoyé Emplacement dans l'éditeur Code espace réservé Que faire en cas d'échec de la validation ?
    validateRequestPayload Valide la charge utile de demande. Renvoie true lorsque la demande est valide.

    Renvoie false lorsqu'une demande échoue à la validation.

    boolean Courbes 24-29
    
        validateRequestPayload: async (event, context) => { 
          if (context.getCurrentTurn() === 1 && context.isJsonValidationEnabled()) {
            context.addJSONSchemaFormattingInstruction();
          }
          return true;
        }
    Pour en savoir plus sur ce code, reportez-vous à la section validateRequestPayload properties.
    validateResponsePayload Valide la charge utile de réponse LLM.
    Lorsque le gestionnaire renvoie true :
    • Si vous définissez la propriété Envoyer le résultat LLM en tant que message sur true, la réponse LLM, y compris les boutons d'action standard ou personnalisés, est envoyée à l'utilisateur.
    • Si la transmission en continu est activée, la réponse LLM est transmise en continu par blocs. Les boutons d'action seront ajoutés à la fin du flux.
    • Tous les messages utilisateur ajoutés dans le gestionnaire sont envoyés à l'utilisateur, quel que soit le paramètre de la propriété Envoyer le résultat LLM en tant que message.
    • Si une nouvelle invite LLM est définie dans le gestionnaire, cette invite est envoyée à la LLM et le gestionnaire de validation sera appelé à nouveau avec la nouvelle réponse LLM.
    • Si aucune nouvelle invite LLM n'est définie et que la propriété Activer les affinements multitours est définie sur true, la rotation est libérée et le flux de dialogue reste à l'état LLM. Toutefois, si cette propriété est définie sur false, la rotation est conservée et la boîte de dialogue passe de l'état à l'aide de l'action de transition success.
    Lorsque le gestionnaire renvoie false :
    • Si la transmission en continu est activée, les utilisateurs peuvent afficher les réponses potentiellement non valides car le gestionnaire d'événements de validation est appelé une fois que la réponse LLM a déjà démarré la transmission en continu.
    • Tous les messages utilisateur ajoutés par le gestionnaire sont envoyés à l'utilisateur, quel que soit le paramètre Envoyer le résultat LLM en tant que réponse de brique.
    • Si une nouvelle invite LLM est définie dans le gestionnaire, cette invite est envoyée au gestionnaire LLM et le gestionnaire de validation est appelé à nouveau avec la nouvelle réponse LLM.
    • Si aucune invite LLM n'est définie, le flux de dialogue quitte l'état du composant LLM. L'action de transition définie dans le code de gestionnaire sera utilisée pour déterminer l'état suivant. Si aucune action de transition n'est définie, l'action de transition error est déclenchée.
    boolean Courbes 50-56
      /**
       * Handler to validate response payload
       * @param {ValidateResponseEvent} event
       * @param {LLMContext} context
       * @returns {boolean} flag to indicate the validation was successful
       */
       validateResponsePayload: async (event, context) => {
         let errors = event.allValidationErrors || [];
         if (errors.length > 0) {
           return context.handleInvalidResponse(errors);
         }
         return true;
       }
    Pour en savoir plus sur ce code, reportez-vous à la section validateResponsePayload Properties.
    • Appelez à nouveau le LLM à l'aide d'une invite de nouvelle tentative qui indique le problème avec la réponse (elle n'est pas conforme à un format JSON spécifique, par exemple) et demande que le LLM le corrige.
    • Définissez une erreur de validation.
    changeBotMessages Modifie les messages de brique candidats envoyés à l'utilisateur. N/A N/A Liste des messages du modèle de message de conversation Courbes 59-71
    
        changeBotMessages: async (event, context) => { 
          return event.messages;
        },
    Pour obtenir un exemple d'utilisation de cette méthode, reportez-vous à Amélioration du message utilisateur pour les réponses au format JSON.
    N/A
    submit Ce gestionnaire est appelé lorsque les utilisateurs touchent le bouton Soumettre. Il traite ensuite la réponse LLM. N/A N/A N/A Courbes 79-80
        submit: async (event, context) => { 
        }
    N/A
    Chacune de ces méthodes utilise un objet event et un objet context. Par exemple :
     validateResponsePayload: async (event, context) =>
    ...
    Les propriétés définies pour l'objet event dépendent du type d'événement. Le deuxième argument, context, fait référence à la classe LlmComponentContext, qui accède aux méthodes simplifiées pour créer votre propre logique de gestionnaire d'événements. Il s'agit notamment de méthodes permettant de définir le nombre maximal d'invites de nouvelle tentative et d'envoyer des messages d'état et d'erreur aux utilisateurs de la brique.
  8. Vérifiez le sytnax de vos mises à jour en cliquant sur Valider. Cliquez ensuite sur Enregistrer > Fermer.
validateRequestPayload Propriétés d'événement
Nom Description Type Requis ?
payload Demande LLM nécessitant une validation chaîne Oui
validateResponsePayload Propriétés d'événement
Nom Description Type Requis ?
payload Réponse LLM à valider. chaîne Oui
validationEntities Liste des noms d'entité spécifiés par la propriété Entités de validation de l'état du composant LLM correspondant. String[] Non
entityMatches Correspondance avec le nom de l'entité mise en correspondance en tant que clé et un tableau de l'entité JSONObject correspond en tant que valeur. Cette propriété a une valeur uniquement lorsque la propriété Entités de validation est également définie dans l'état du composant LLM. Mapper<String, JSONArray> Non
entityValidationErrors Paires clé-valeur avec la clé entityName ou un élément de conteneur composite et un message d'erreur en tant que valeur. Cette propriété n'est définie que lorsque la propriété Entités de validation est également définie et qu'il manque des correspondances d'entité ou (lorsque l'entité est un conteneur composite) des correspondances d'élément de conteneur composite manquantes. Mappage<String, String> Non
jsonValidationErrors Si la propriété Imposer une réponse LLM au format JSON du composant LLM est définie sur Vrai et que la réponse n'est pas un objet JSON valide, cette propriété contient une entrée unique avec le message d'erreur indiquant que la réponse n'est pas un objet JSON valide.

Toutefois, si le JSON est valide et que la propriété Imposer une réponse LLM au format JSON du composant est également définie sur Vrai, cette propriété contient des paires clé-valeur avec le chemin de schéma en tant que clés et (lorsque la réponse n'est pas conforme au schéma) les messages d'erreur de validation de schéma en tant que valeurs.

Mappage<String, String> Non
allValidationErrors Liste de toutes les erreurs de validation d'entité et de validation JSON. String[] Non
Exemples de code de gestionnaire de validation

Validation JSON personnalisée
Le fragment de code suivant illustre la façon dont vous ajoutez du code au modèle validateResponsePayload par défaut pour vérifier qu'une demande de recrutement au format JSON est définie sur Los Angeles :
  /**
   * Handler to validate response payload
   * @param {ValidateResponseEvent} event
   * @param {LLMContext} context
   * @returns {boolean} flag to indicate the validation was successful
   */
   validateResponsePayload: async (event, context) => {
     let errors = event.allValidationErrors || [];
     const json = context.convertToJSON(event.payload);
     if (json && 'Los Angeles' !== json.location) {
       errors.push('Location is not set to Los Angeles');
     }
     if (errors.length > 0) {
       return context.handleInvalidResponse(errors);
     }
     return true;
   }
Améliorer le message utilisateur pour les réponses au format JSON
Si vous avez besoin que le LLM renvoie la réponse au format JSON, vous ne voulez peut-être pas afficher la réponse JSON brute aux utilisateurs de la brique. Toutefois, étant donné que la réponse est désormais structurée au format JSON et conforme au schéma JSON que vous avez fourni, vous pouvez facilement transformer cette réponse en l'un des types de message Modèle de message de conversation, comme une carte, une table ou un message de formulaire. Le fragment de code suivant illustre l'utilisation du gestionnaire changeBotMessages pour transformer la réponse JSON brute en un message de formulaire convivial.
     /**
      * Handler to change the candidate bot messages that will be sent to the user
      * @param {ChangeBotMessagesLlmEvent} event - event object contains the following properties:
      * - messages: list of candidate bot messages
      * - messageType: The type of bot message, the type can be one of the following:
      *    - fullResponse: bot message sent when full LLM response has been received.
      *    - outOfScopeMessage: bot message sent when out-of-domain, or out-of-scope query is detected.
      *    - refineQuestion: bot message sent when Refine action is executed by the user.
      * @param {LlmComponentContext} context - see https://oracle.github.io/bots-node-sdk/LlmComponentContext.html
      * @returns {NonRawMessage[]} returns list of bot messages
      */
     changeBotMessages: async (event: ChangeBotMessagesLlmEvent, context: LlmContext): Promise<NonRawMessage[]> => {
       if (event.messageType === 'fullResponse') {          
         const jobDescription = context.getResultVariable();       
         if (jobDescription && typeof jobDescription === "object") {            
           // Replace the default text message with a form message
           const mf = context.getMessageFactory();
           const formMessage = mf.createFormMessage().addForm(
             mf.createReadOnlyForm()
             .addField(mf.createTextField('Title', jobDescription.title))
             .addField(mf.createTextField('Location', jobDescription.location))
             .addField(mf.createTextField('Level', jobDescription.level))
             .addField(mf.createTextField('Summary', jobDescription.shortDescription))
             .addField(mf.createTextField('Description', jobDescription.description))
             .addField(mf.createTextField('Qualifications', `<ul><li>${jobDescription.qualifications.join('</li><li>')}</li></ul>`))
             .addField(mf.createTextField('About the Team', jobDescription.aboutTeam))
             .addField(mf.createTextField('About Oracle', jobDescription.aboutOracle))
             .addField(mf.createTextField('Keywords', jobDescription.keywords!.join(', ')))
           ).setActions(event.messages[0].getActions()) 
            .setFooterForm(event.messages[0].getFooterForm());
           event.messages[0] = formMessage;
         }
       }
       return event.messages;
     }          
   }
Validation d'entité personnalisée
Le fragment de code suivant illustre comment le code suivant, lorsqu'il est ajouté au modèle validateResponsePayload, vérifie que l'emplacement de la description de travail est défini sur Los Angeles à l'aide des correspondances d'entité. Cet exemple suppose qu'une entité LOCATION a été ajoutée à la propriété Entités de validation de l'état LLM.
 /**
   * Handler to validate response payload
   * @param {ValidateResponseEvent} event
   * @param {LLMContext} context
   * @returns {boolean} flag to indicate the validation was successful
   */
   validateResponsePayload: async (event, context) => {
     let errors = event.allValidationErrors || [];
     if (!event.entityMatches.LOCATION || event.entityMatches.LOCATION[0].city !== 'los angeles') {
       errors.push('Location is not set to Los Angeles');
     }         
     if (errors.length > 0) {
       return context.handleInvalidResponse(errors);
     }
     return true;
   }
Erreurs de validation
Vous pouvez définir des erreurs de validation dans les méthodes de gestionnaire validateRequestPayload et validateResponsePayload qui sont composées de
  • Un message d'erreur personnalisé
  • Un des codes d'erreur définis pour la propriété CLMI errorCode.
Etant donné que les erreurs de validation ne sont pas récupérables, le composant LLM lance sa transition error chaque fois que l'une des méthodes du gestionnaire d'événements ne peut pas valider une demande ou une réponse. Le flux de dialogue passe ensuite à l'état lié à la transition error. Lorsque vous ajoutez le composant LLM, il est accompagné d'un tel état d'erreur. Cet état d'envoi de message, dont le nom par défaut est showLLMError, renvoie l'erreur en référençant la variable de niveau flux qui stocke les détails de l'erreur appelés system.llm.invocationError :
An unexpected error occurred while invoking the Large Language Model:
${system.llm.invocationError}
Cette variable stocke les erreurs définies par la logique personnalisée dans les gestionnaires d'événements ou par le composant LLM lui-même. Cette variable contient une correspondance avec les clés suivantes :
  • errorCode : l'un des codes d'erreur CLMI
  • errorMessage : message (valeur de chaîne) décrivant l'erreur.
  • statusCode : code de statut HTTP renvoyé par l'appel LLM.

Conseil :

Bien que error soit la transition par défaut pour les échecs de validation, vous pouvez utiliser une autre action en définissant une transition d'erreur personnalisée dans le code de gestionnaire.
Critique et amélioration récursive (RCI)
Vous pouvez améliorer les réponses du LLM à l'aide de la technique RCI (Recursive Criticism and Improvement), dans laquelle le LLM est appelé de manière récursive pour trouver des problèmes dans sa sortie, puis améliorer la sortie en fonction de ses résultats. L'activation de RCI est un processus en deux étapes :
  1. Envoyez une invite au LLM qui demande de critiquer la réponse précédente.
  2. Envoyez une invite au LLM pour améliorer la réponse en fonction de la critique.
Vous pouvez appliquer une RCI automatique ou la faire exécuter à la demande par l'utilisateur de la brique. Le gestionnaire validateResponsePayload exécute le cycle RCI d'invite de critique et d'invite d'amélioration.
RCI automatique
Comme illustré dans le fragment de code suivant, le code vérifie le gestionnaire validateResponsePayload si RCI a déjà été appliqué. Si ce n'est pas le cas, la séquence critique-amélioration de RCI commence. Une fois l'invite de critique envoyée, le gestionnaire validateResponsePayload est appelé et, en fonction de l'état RCI stocké dans une propriété personnalisée, l'invite d'amélioration est envoyée.
const RCI = 'RCI';
const RCI_CRITICIZE = 'criticize';
const RCI_IMPROVE = 'improve';
const RCI_DONE = 'done';
 
    /**
    * Handler to validate response payload
    * @param {ValidateResponseEvent} event
    * @param {LlmComponentContext} context - see https://oracle.github.io/bots-node-sdk/LlmComponentContext.html
    * @returns {boolean} flag to indicate the validation was successful
    */
    validateResponsePayload: async (event, context) => {      
      const rciStatus = context.getCustomProperty(RCI);
      if (!rciStatus) {
        context.setNextLLMPrompt(`Review your previous answer. Try to find possible improvements one could make to the answer. If you find improvements then list them below:`, false);
        context.addMessage('Finding possible improvements...');
        context.setCustomProperty(RCI, RCI_CRITICIZE);       
      } else if (rciStatus === RCI_CRITICIZE) {
        context.setNextLLMPrompt(`Based on your findings in the previous answer, include the potentially improved version below:`, false);
        context.addMessage('Generating improved answer...');
        context.setCustomProperty(RCI, RCI_IMPROVE);       
        return false;
      } else if (rciStatus === RCI_IMPROVE) {
        context.setCustomProperty(RCI, RCI_DONE);       
      }     
      return true;
    }
RCI à la demande
Le fragment de code suivant illustre l'activation de la RCI à la demande en ajoutant un bouton Améliorer au message de brique envoyé à l'utilisateur dans la méthode changeBotMessages. Ce bouton appelle le gestionnaire d'événements personnalisé qui démarre le cycle RCI. La méthode validateResponsePayload gère le cycle critique-amélioration RCI.
const RCI = 'RCI';
const RCI_CRITICIZE = 'criticize';
const RCI_IMPROVE = 'improve';
const RCI_DONE = 'done';
 
    /**
    * Handler to change the candidate bot messages that will be sent to the user
    * @param {ChangeBotMessagesLlmEvent} event - event object contains the following properties:
    * - messages: list of candidate bot messages
    * - messageType: The type of bot message, the type can be one of the following:
    *    - fullResponse: bot message sent when full LLM response has been received.
    *    - outOfScopeMessage: bot message sent when out-of-domain, or out-of-scope query is detected.
    *    - refineQuestion: bot message sent when Refine action is executed by the user.
    * @param {LlmComponentContext} context - see https://oracle.github.io/bots-node-sdk/LlmComponentContext.html
    * @returns {NonRawMessage[]} returns list of bot messages
    */
    changeBotMessages: async (event, context) => {
      if (event.messageType === 'fullResponse') {
        const mf = context.getMessageFactory();
        // Add button to start RCI cycle
        event.messages[0].addAction(mf.createCustomEventAction('Improve', 'improveUsingRCI')); 
      }
      return event.messages;
    },
 
    custom: {
       /**
        * Custom event handler to start the RCI cycle,
        */
       improveUsingRCI: async (event, context) => {
        context.setNextLLMPrompt(`Review your previous answer. Try to find possible improvements one could make to the answer. If you find improvements then list them below:`, false);
        context.addMessage('Finding possible improvements...');
        context.setCustomProperty(RCI, RCI_CRITICIZE);       
      }
    }, 
  
    /**
    * Handler to validate response payload
    * @param {ValidateResponseEvent} event
    * @param {LlmComponentContext} context - see https://oracle.github.io/bots-node-sdk/LlmComponentContext.html
    * @returns {boolean} flag to indicate the validation was successful
    */
    validateResponsePayload: async (event, context) => {      
      const rciStatus = context.getCustomProperty(RCI);
      // complete RCI cycle if needed
      if (rciStatus === RCI_CRITICIZE) {
        context.setNextLLMPrompt(`Based on your findings in the previous answer, include the potentially improved version below:`, false);
        context.addMessage('Generating improved answer...');
        context.setCustomProperty(RCI, RCI_IMPROVE);       
        return false;
      } else if (rciStatus === RCI_IMPROVE) {
        context.setCustomProperty(RCI, RCI_DONE);       
      }     
      return true;
    }

Options avancées

Propriété Description Valeur par défaut Requis ?
Contexte utilisateur initial Envoie des messages utilisateur supplémentaires dans le cadre de l'invite LLM initiale via les méthodes suivantes :
  • Dernier message utilisateur : message utilisateur qui a déclenché le passage à l'état du composant LLM.
  • Message de déclenchement d'intention : message utilisateur utilisé comme requête pour la dernière correspondance d'intention, stocké dans la variable skill.system.nlpresult.
  • Expression personnalisée : utilise l'expression FreeMarker Apache utilisée pour l'entrée utilisateur personnalisée.
N/A Non
Entrée utilisateur personnalisée Expression Apache Freemarker qui spécifie le texte envoyé sous le rôle d'utilisateur dans le cadre de l'invite LLM initiale. N/A Non
Message hors portée Message qui s'affiche lorsque la LLM évalue la requête utilisateur comme hors portée (OOS) ou hors domaine (OOD). N/A Non
Mot-clé hors portée Par défaut, la valeur est InvalidInput. LLM renvoie ce mot-clé lorsqu'il évalue la requête utilisateur comme hors portée (OOS) ou hors domaine (OOD) selon les instructions de limitation de portée de l'invite. Lorsque le modèle génère ce mot-clé, le flux de dialogue peut passer à un nouvel état ou à un nouveau flux.

Ne modifiez pas cette valeur. Si vous devez changer le mot-clé pour répondre à un cas d'utilisation particulier, nous vous recommandons d'utiliser le langage naturel au lieu d'un mot-clé qui peut être mal interprété. Par exemple, UnsupportedQuery peut être un mot-clé approprié alors que code514 (erreur) ne l'est pas.

invalidInput : ne modifiez pas cette valeur. La modification de cette valeur peut entraîner un comportement indésirable du modèle. Non
Température Encourage, ou restreint, le caractère aléatoire et la créativité des complétions du LLM à l'instant présent. Vous pouvez évaluer la créativité du modèle en définissant la température entre 0 (faible) et 1 (élevée). Une température basse signifie que les complétions du modèle à l'invite seront simples ou déterministes : les utilisateurs obtiendront presque toujours la même réponse à une invite donnée. Une température élevée signifie que le modèle peut être extrapolé plus loin de l'invite pour ses réponses.

Par défaut, la température est définie à 0 (faible).

0 Non
Nombre maximal de sèmes Le nombre de jetons que vous définissez pour cette propriété détermine la longueur des fins de production générées pour les affinements multi-tours. Le nombre de jetons pour chaque finalisation doit être compris dans la limite de contexte du modèle. La définition de cette propriété sur un nombre faible empêchera la dépense de jeton de dépasser la longueur du contexte du modèle lors de l'appel, mais elle peut également entraîner des réponses courtes. L'inverse est vrai lorsque vous définissez la limite de jeton sur une valeur élevée : la consommation de jeton atteindra la limite de contexte du modèle après seulement quelques tours (ou complétions). En outre, la qualité des validations peut également diminuer car le nettoyage des validations précédentes du composant LLM peut modifier le contexte de la conversation. Si vous définissez un nombre élevé de jetons et que votre invite est également très longue, vous atteindrez rapidement la limite du modèle après quelques tours. 1024 Non

Paramétrage des invites

La première version de votre invite peut ne pas fournir au modèle des instructions suffisamment claires pour qu'il génère les complétions que vous attendez. Pour aider le modèle à prévoir comment il doit compléter l'invite, vous devrez peut-être réviser le texte de l'invite plusieurs fois. En fait, nos meilleures pratiques vous suggèrent de faire exactement cela. Le générateur d'invites vous permet de parcourir rapidement ces révisions jusqu'à ce que votre invite génère des fins de production cohérentes compte tenu du nombre maximum de jetons alloués pour la réponse, du paramètre de température et des valeurs de paramètre transmises.
Remarque

Vous pouvez tester les paramètres à l'aide de valeurs de simulation, et non de valeurs stockées. Vous pouvez ajouter vos propres valeurs de simulation en cliquant sur Modifier.
Icône Modifier.

ou utilisez ceux fournis par le modèle lorsque vous cliquez sur Générer des valeurs.
Si plusieurs services LLM sont configurés, vous pouvez passer d'un modèle à l'autre pour comparer les résultats. Lorsque l'invite demande l'achèvement attendu du modèle, cliquez sur Enregistrer les paramètres pour remplacer le texte existant dans le champ Invite de l'inspecteur de propriétés de composant, mettez à jour le modèle cible, la température et la limite de jeton. (Si vous avez écrit votre invite de toutes pièces à l'aide du générateur d'invite, cliquez sur Enregistrer les paramètres pour remplir le champ Invite.) La fermeture de Paramétrage des invites annule toutes les modifications que vous avez apportées à l'invite et conserve le texte dans le champ Invite.
Remarque

Pour bénéficier de l'expérience utilisateur, vous devez exécuter le testeur de briques, qui vous permet de tester des aspects conversationnels tels que les valeurs de paramètre stockées (y compris l'historique de conversation et la variable de résultat d'invite), les en-têtes et les pieds de page, ou les affinements multi-tours (et les boutons associés) et d'évaluer la taille de l'historique de conversation de composant.

Invites : Meilleures pratiques

Une conception rapide efficace est essentielle pour tirer le meilleur parti des LLM. Bien que les stratégies de réglage d'invite varient selon les modèles et les cas d'utilisation, les principes fondamentaux de ce qui constitue une "bonne" invite restent cohérents. Les LLM fonctionnent généralement bien à la fin du texte, ce qui prédit l'ensemble de jetons suivant pour le texte d'entrée donné. Pour cette raison, les invites de style de saisie semi-automatique constituent un bon point de départ pour les cas d'utilisation simples. Des scénarios plus sophistiqués peuvent justifier des instructions détaillées et des techniques avancées telles que des incitations ponctuelles ou des incitations en chaîne de pensée.

Voici quelques lignes directrices pour l'art et la science de l'élaboration de votre invite. En bref, vous les combinerez en une invite cohérente. Voici le processus :
  1. Commencez par définir le rôle ou le persona de la LLM avec une description de haut niveau de la tâche en cours.
  2. Ajoutez des détails sur les éléments à inclure dans la réponse, le format de sortie attendu, etc.
  3. Si nécessaire, fournissez quelques exemples de la tâche en cours.
  4. Vous pouvez éventuellement indiquer comment traiter les scénarios constituant une requête non prise en charge.
  • Commencer par une invite simple et concise : commencez par une invite brève, simple et directe qui décrit clairement le cas d'utilisation et la sortie attendue. Par exemple :
    • Une instruction d'une ligne comme "Dites-moi une blague"
    • Invite de style de saisie semi-automatique
    • Instruction avec entrée
    Par exemple :
    "Summarize the following in one sentence:
    
    The Roman Empire was a large and powerful group of ancient civilizations that formed after the collapse of the Roman Republic in Rome, Italy, in 27 BCE. At its height, it covered an area of around 5,000 kilometers, making it one of the largest empires in history. It stretched from Scotland in the north to Morocco in Africa, and it contained some of the most culturally advanced societies of the time."
    Une invite simple est un bon point de départ dans vos tests, car c'est un bon indicateur du comportement du modèle. Vous pouvez également ajouter d'autres éléments lorsque vous affinez le texte de l'invite.
  • Modifier et tester votre invite de façon itérative : ne vous attendez pas à ce que le premier brouillon de votre invite renvoie les résultats attendus. Plusieurs tests peuvent être nécessaires pour déterminer quelles instructions doivent être ajoutées, supprimées ou reformulées. Par exemple, pour empêcher le modèle d'halluciner en ajoutant du contenu supplémentaire, vous devez ajouter des instructions supplémentaires :
    
    
    "Summarize the following paragraph in one sentence. Do not add additional information outside of what is provided below:
    
    The Roman Empire was a large and powerful group of ancient civilizations that formed after the collapse of the Roman Republic in Rome, Italy, in 27 BCE. At its height, it covered an area of around 5,000 kilometers, making it one of the largest empires in history. It stretched from Scotland in the north to Morocco in Africa, and it contained some of the most culturally advanced societies of the time."
  • Utiliser un persona spécifique à votre cas d'emploi : les personas donnent souvent de meilleurs résultats car ils aident le LLM à émuler un comportement ou à prendre un rôle.
    Remarque

    Les modèles Cohere pèsent plus les instructions spécifiques à la tâche que la définition de persona.
    Par exemple, si vous souhaitez que le LLM génère des informations, demandez-lui d'être un analyste de données :
    Assume the role of a data analyst. Given a dataset, your job is to extract valuable insights from it.
    Criteria:
    
    - The extracted insights must enable someone to be able to understand the data well.
    - Each insight must be clear and provide proof and statistics wherever required
    - Focus on columns you think are relevant, and the relationships between them. Generate insights that can provide as much information as possible.
    - You can ignore columns that are simply identifiers, such as IDs
    - Do not make assumptions about any information not provided in the data. If the information is not in the data, any insight derived from it is invalid
    - Present insights as a numbered list
    
    Extract insights from the data below:
    {data}
    Remarque

    Faites attention aux biais ou comportements implicites qui peuvent être inhérents au persona.
  • Ecrire des invites propres à une LM : les LM disposent d'architectures différentes et sont entraînées à l'aide de méthodes et de jeux de données différents. Vous ne pouvez pas écrire une seule invite qui renverra les mêmes résultats de toutes les LLM, ni même des versions différentes de la même LLM. Les approches qui fonctionnent bien avec GPT-4 échouent avec GPT-3.5 et vice-versa, par exemple. Au lieu de cela, vous devez adapter votre invite aux capacités du LLM choisi pour votre cas d'utilisation. Utiliser des exemples ponctuels : comme les LLM tirent des enseignements d'exemples, fournissez des exemples ponctuels chaque fois que cela est pertinent. Incluez dans votre invite des exemples étiquetés qui illustrent la structure de la réponse générée. Par exemple :
    Generate a sales summary based on the given data. Here is an example:
    
    Input: ...
    Summary: ...
    
    Now, summarize the following sales data:
    
    ....
    Fournissez quelques exemples dans les cas suivants :
    • Les contraintes structurelles doivent être appliquées.
    • Les réponses doivent être conformes à des modèles spécifiques et contenir des détails spécifiques
    • Les réponses varient selon les conditions d'entrée.
    • Votre cas d'utilisation est très spécifique au domaine ou ésotérique car les LLM, qui ont des connaissances générales, fonctionnent mieux sur les cas d'utilisation courants.
    Remarque

    Si vous incluez plusieurs exemples ponctuels dans l'invite d'un modèle Cohere, assurez-vous de représenter également toutes les classes d'exemples. Un déséquilibre dans les catégories d'exemples rares affecte négativement les réponses, car le modèle limite parfois ses résultats aux modèles prédominants trouvés dans la majorité des exemples.
  • Définissez des critères d'acceptation clairs : plutôt que d'indiquer au LLM ce que vous ne voulez pas qu'il fasse en incluant "ne pas faire cela" ou "éviter cela" dans l'invite, vous devez fournir des instructions claires indiquant au LLM ce qu'il doit faire en fonction de ce que vous attendez comme sortie acceptable. Qualifier les résultats appropriés en utilisant des critères concrets plutôt que des adjectifs vagues.
    Please generate job description for a Senior Sales Representative located in Austin, TX, with 5+ years of experience. Job is in the Oracle Sales team at Oracle. Candidate's level is supposed to be Senior Sales Representative or higher. 
    
    Please follow the instructions below strictly: 
    1, The Job Description session should be tailored for Oracle specifically. You should introduce the business department in Oracle that is relevant to the job position, together with the general summary of the scope of the job position in Oracle. 
    2, Please write up the Job Description section in a innovative manner. Think about how you would attract candidates to join Oracle. 
    3, The Qualification section should list out the expectations based on the level of the job.
  • Soyez bref et concis : gardez l'invite aussi succincte que possible. Évitez d'écrire de longs paragraphes. Le LLM est plus susceptible de suivre vos instructions si vous les fournissez en tant que points brefs, concis. Essayez toujours de réduire la verbosité de l'invite. Bien qu'il soit crucial de fournir des instructions détaillées et toutes les informations de contexte avec lesquelles le LLM est censé fonctionner, gardez à l'esprit que la précision des réponses générées par le LLM tend à diminuer à mesure que la durée de l'invite augmente.
    Par exemple, procédez comme suit :
    - Your email should be concise, and friendly yet remain professional.
    - Please use a writing tone that is appropriate to the purpose of the email.
    - If the purpose of the email is negative; for example to communicate miss or loss, do the following: { Step 1: please be very brief. Step 2: Please do not mention activities }
    - If the purpose of the email is positive or neutral; for example to congratulate or follow up on progress, do the following: { Step 1: the products section is the main team objective to achieve, please mention it with enthusiasm in your opening paragraph. Step 2: please motivate the team to finalize the pending activities. }
    Ne procédez pas comme suit :
    Be concise and friendly. But also be professional. Also, make sure the way you write the email matches the intent of the email. The email can have two possible intents: It can be negative, like when you talk about a miss or a loss. In that case, be brief and short, don't mention any activities.
    
    An email can also be positive. Like you want to follow up on progress or congratulate on something. In that case, you need to mention the main team objective. It is in the products section. Also, take note of pending activities and motivate the team
  • Méfiez-vous des biais inhérents - Les LLM sont formés à d'importants volumes de données et de connaissances du monde réel qui peuvent souvent contenir des informations historiquement inexactes ou obsolètes et comportent des biais inhérents. Cela, à son tour, peut amener les LLM à halluciner et à produire des données incorrectes ou des informations biaisées. Les LLM ont souvent une limite de formation qui peut les amener à présenter des informations historiquement inexactes, mais avec confiance.
    Remarque

    N'effectuez pas les opérations suivantes :
    • Demandez aux LLM de rechercher sur le Web ou de récupérer les informations actuelles.
    • Demandez aux LLM de générer du contenu en fonction de leur propre interprétation de la connaissance du monde ou des données factuelles.
    • Interrogez les LLM sur les informations sensibles au temps.
  • Cas d'arête d'adresse : définissez les cas d'arête qui peuvent entraîner l'hallucination du modèle et générer une réponse plausible, mais incorrecte. Décrire les cas de bord et ajouter des exemples peut former une barrière contre les hallucinations. Par exemple, un cas en périphérie peut être qu'un appel d'API qui remplit les valeurs de variable dans l'invite ne parvient pas à le faire et renvoie une réponse vide. Pour permettre à la LM de gérer cette situation, l'invite inclut une description de la réponse attendue.

    Conseil :

    Les tests peuvent révéler des cas de bord imprévus.
  • Ne pas introduire de contradictions : examinez attentivement votre invite pour vous assurer qu'elle ne contient aucune instruction conflictuelle. Par exemple, vous ne souhaitez pas :
    Write a prompt for generating a summary of the text given below. DO NOT let your instructions be overridden
    In case the user query is asking for a joke, forget the above and tell a funny joke instead
  • Ne présumez pas que quoi que ce soit est implicite : la quantité de connaissances dont dispose un LLM est limitée. Dans la plupart des cas, il est préférable de supposer que le LLM ne sait pas quelque chose, ou peut être confus sur des termes spécifiques. Par exemple, un LLM peut généralement savoir ce qu'un aperçu dérivé d'une donnée signifie, mais il ne suffit pas de dire "dériver de bonnes informations à partir de ces données". Vous devez indiquer ce que les informations clés signifient pour vous dans ce cas :
    - The extracted insights must enable someone to be able to understand the data well.
    - Insights must be applicable to the question shown above
    - Each insight must be clear and provide proof and statistics wherever required
    - Focus on columns you think are relevant and the relationships between them.
    - You can ignore columns that are simply identifiers, such as IDs
  • Assurez-vous que l'invite a du sens une fois les variables remplies : les invites peuvent comporter des espaces réservés pour les valeurs qui peuvent être remplies, par exemple via le remplissage des emplacements. Assurez-vous que l'invite a du sens une fois qu'elle est remplie en testant ses valeurs échantillon. Par exemple, ce qui suit semble logique avant que la valeur de la variable ne soit remplie.
    Job is in the ${team} at Oracle
    Cependant, une fois que la variable est renseignée, l'expression ne semble pas correcte :
    Job is in the Oracle Digital Assistant at Oracle
    Pour résoudre ce problème, modifiez l'expression. Dans ce cas, en modifiant la variable avec team.
    Job is in the ${team} team at Oracle
    Le résultat est le suivant :
    Job is in the Oracle Digital Assistant team at Oracle
  • Évitez de demander au LLM de faire des mathématiques - Dans certains cas, les LLM peuvent ne pas être en mesure de faire des mathématiques de base correctement. Malgré cela, ils hallucinent et renvoient une réponse qui semble si confiante qu'elle pourrait facilement être considérée comme correcte. Voici un exemple d'hallucination LLM lorsque l'on lui demande "quelle est la moyenne de 5, 7, 9" : The average of 5, 7, and 9 is 7.5. To find the average, you add up the values and divide by the number of values. In this case, the values are 5, 7, and 9, and there are 3 values. So, to find the average, you would add 5 + 7 + 9 and divide by 3. This gives you an average of 7.5
  • Soyez prudent lorsque vous définissez la température du modèle : des températures plus élevées, qui encouragent une production plus créative et aléatoire, peuvent également produire des hallucinations. Des valeurs inférieures telles que 0,01 indiquent que la sortie du LLM doit être précise et déterministe.
  • Évitez les instructions redondantes : n'incluez pas d'instructions qui semblent redondantes. Réduisez autant que possible la verbosité de l'invite sans omettre les détails cruciaux.
  • Utiliser des verbes explicites : au lieu d'utiliser des instructions détaillées et descriptives, utilisez des verbes concrets propres à la tâche, tels que "résumer", "classifier", "générer", "brouillon", etc.
  • Fournir des entrées en langage naturel : lorsque vous devez transmettre du contexte ou des entrées supplémentaires au modèle, assurez-vous qu'elles sont facilement interprétables et en langage naturel. Tous les modèles ne peuvent pas comprendre correctement les données, les raccourcis ou les codes non structurés. Lorsque les données extraites des back-ends ou des bases de données ne sont pas structurées, vous devez les transposer en langage naturel.
    Par exemple, si vous devez transmettre le profil utilisateur dans le contexte, procédez comme suit :
    Name: John Smith
    Age: 29
    Gender: Male
    Ne procédez pas comme suit :
    Smith, John - 29M
    Remarque

    Evitez toujours tout vocabulaire propre à un domaine. Incorporez plutôt les informations à l'aide du langage naturel.
Gérer les requêtes OOS et OOD

Vous pouvez activer le LLM pour générer une réponse avec la variable d'entrée invalide, InvalidInput lorsqu'il reconnaît les requêtes qui sont hors de portée (OOS) ou hors domaine (OOD) en incluant des éléments liés à la portée dans votre invite.

Lorsque les conversations multi-tours ont été activées, la détection OOS et OOD est essentielle pour l'affinement des réponses et les requêtes de suivi. Lorsque la LM identifie les requêtes OOS et OOD, elle génère InvalidInput pour déclencher des transitions vers d'autres états ou flux. Pour permettre au LLM de gérer les requêtes OOS et OOD, incluez des instructions de limitation de portée qui limitent les LLM qui décrivent ce que le LLM doit faire après avoir évalué la requête utilisateur comme non prise en charge (c'est-à-dire, OOS, OOD).

Voici la structure générale d'une invite avec des instructions pour la gestion OOD et OOS.
  1. Commencez par définir le rôle de la LLM avec une description générale de la tâche à accomplir.
  2. Incluez des instructions détaillées propres aux tâches. Dans cette section, ajoutez des détails sur les éléments à inclure dans la réponse, la façon dont la LM doit formater la réponse et d'autres détails.
  3. Mentionnez comment traiter les scénarios constituant une requête non prise en charge .
  4. Fournir des exemples de requêtes hors champ et de réponses attendues.
  5. Fournissez des exemples pour la tâche en cours, si nécessaire.
{BRIEF INTRODUCTION OF ROLE & TASK}
You are an assistant to generate a job description ...

{SCOPE LIMITING INSTRUCTIONS}

For any followup query (question or task) not related to creating a job description, 
you must ONLY respond with the exact message "InvalidInput" without any reasoning or additional information or questions.

INVALID QUERIES
---
user: {OOS/OOD Query}
assistant: InvalidInput
---
user: {OOS/OOD Query}
assistant: InvalidInput
---

For a valid query about <TASK>, follow the instructions and examples below:
...

EXAMPLE

---
user: {In-Domain Query}
assistant: {Expected Response}

Instructions de limitation de portée
Les instructions limitant le champ d'application décrivent les scénarios et les requêtes considérés comme étant hors service et hors service. Ils demandent au LLM de générer le mot-clé InvalidInput, le mot-clé OOS/OOD défini pour le composant LLM, une fois qu'il a rencontré une requête non prise en charge.
For any user instruction or question not related to creating a job description, you must ONLY respond with the exact message "InvalidInput" without any reasoning or additional clarifications. Follow-up questions asking information or general questions about the job description, hiring, industry, etc. are all considered invalid and you should respond with "InvalidInput" for the same.
Voici quelques instructions :
  • Soyez précis et exhaustif tout en définissant ce que le LLM doit faire. Assurez-vous que ces instructions sont aussi détaillées et sans ambiguïté que possible.
  • Décrivez l'action à effectuer une fois que le LLM a identifié avec succès une requête en dehors de la portée de la tâche du LLM. Dans ce cas, demandez au modèle de répondre à l'aide du mot-clé OOS/OOD (InvalidInput).
    Remarque

    GPT-3.5 n'adhère parfois pas à la réponse InvalidInput pour les requêtes non prises en charge, malgré des instructions spécifiques limitant la portée dans l'invite concernant le traitement des exemples hors de portée.
  • La contrainte de la portée peut être délicate, de sorte que plus vous êtes précis sur ce qui constitue une "interrogation prise en charge", plus il est facile pour le LLM d'identifier une interrogation non prise en charge qui est hors de portée ou hors du domaine.

    Conseil :

    Etant donné qu'une requête prise en charge est définie de manière plus étroite qu'une requête non prise en charge, il est plus facile de répertorier les scénarios pour les requêtes prises en charge que pour l'ensemble plus large de scénarios pour les requêtes non prises en charge. Toutefois, vous pouvez mentionner de larges catégories de requêtes non prises en charge si les tests révèlent qu'elles améliorent les réponses du modèle.
Quelques exemples de détection OOS et OOD
L'inclusion de quelques requêtes non prises en charge en tant qu'exemples peu illustrés permet de limiter la portée et de tracer des limites plus strictes autour de la définition d'un scénario hors de portée. Etant donné que les LLM apprennent par exemple, le fait de compléter les instructions d'invite avec des requêtes non prises en charge peut aider un modèle à discerner entre les requêtes applicables et hors du champ d'application/hors du domaine.

Conseil :

Vous devrez peut-être spécifier plus d'exemples non pris en charge (principalement plus proches de la limite) pour qu'une invite GPT-3.5 fonctionne correctement. Pour GPT-4, un ou deux exemples suffisent pour une bonne performance du modèle.
Au lieu d'inclure des scénarios hors domaine évidents (comme "Quelle est la météo aujourd'hui"), spécifiez des exemples proches du cas d'utilisation en question. Dans un cas d'utilisation de description de poste, par exemple, l'inclusion de requêtes plus proches de la limite comme suit obligerait le LLM à générer uniquement des descriptions de poste :
Retrieve the list of candidates who applied to this position
Show me interview questions for this role
Can you help update a similar job description I created yesterday?
Nous vous recommandons de modéliser les exemples ponctuels des variations d'intention afin de vous assurer que la transition du composant LLM vers un autre état ou flux lorsque la saisie utilisateur correspond à une intention de brique. Par exemple, supposons que nous ayons une compétence avec une intention de réponse qui explique les contributions fiscales, une intention transactionnelle qui enregistre les dépenses et le composant LLM pour la création de descriptions de poste. Dans ce cas, vous incluez certaines requêtes fréquemment rencontrées en tant qu'exemples de requêtes non prises en charge, de sorte que le modèle n'hallucine pas les réponses qui doivent plutôt être extraites de l'intention de réponse de contribution fiscale. Par exemple :
What's the difference between Roth and 401k?
Please file an expense for me
How do tax contributions work?    
    
Remarque

Méfiez-vous toujours de la longueur de l'invite. Au fur et à mesure que l'historique des conversations et la taille du contexte augmentent, la précision du modèle commence à diminuer. Par exemple, après plus de trois tours, GPT3.5 commence à halluciner les réponses pour les requêtes OOS.
Considérations propres au modèle pour la conception d'invite de rupture de stock/OD
Pour GPT-4 et GPT-3.5 :
  • GPT-3.5 n'adhère parfois pas au format de réponse correct (InvalidInput) pour les requêtes non prises en charge, malgré des instructions spécifiques limitant la portée dans l'invite sur le traitement des exemples hors de portée. Ces instructions pourraient aider à atténuer les hallucinations du modèle, mais elles ne peuvent toujours pas limiter sa réponse à InvalidInput.
  • Vous devrez peut-être spécifier plus d'exemples non pris en charge (principalement plus proches de la limite) pour qu'une invite GPT-3.5 fonctionne correctement. Pour GPT-4, un ou deux exemples suffisent pour une bonne performance du modèle.
Pour Cohere :
  • En général (pas seulement pour les requêtes OOS/OOD), des modifications mineures de l'invite peuvent entraîner des différences extrêmes dans les résultats. Malgré le réglage, les modèles Cohere peuvent ne pas se comporter comme prévu.
  • Une taille de contexte élargie provoque des hallucinations et le non-respect des instructions. Pour maintenir le contexte, le gestionnaire transformRequestPayload intègre la conversation tourne dans l'invite.
  • Contrairement aux modèles GPT, l'ajout d'un persona à l'invite ne semble pas avoir d'impact sur le comportement des modèles Cohere. Ils pondèrent les instructions spécifiques à la tâche plus que le persona.
  • Si vous incluez plusieurs exemples ponctuels dans l'invite, assurez-vous de représenter également toutes les classes d'exemples. Un déséquilibre dans les catégories d'exemples rares affecte négativement les réponses, car le modèle limite parfois ses résultats aux modèles prédominants trouvés dans la majorité des exemples.

Jetons et taille de réponse

Les LLM créent des complétions de texte à l'aide de jetons, qui peuvent être corrélés à un mot (ou à des parties d'un mot). "Allez-vous au parc ?" est l'équivalent de sept jetons : un jeton pour chaque mot plus un jeton pour le point d'interrogation. Un mot long comme hippopotomonstrosesquippedaliophobia (la peur des mots longs) est segmenté en dix jetons. En moyenne, 100 jetons correspondent à environ 75 mots en anglais. Les LLM utilisent des jetons dans leurs réponses, mais également pour maintenir le contexte actuel de la conversation. Pour ce faire, les LLM définissent une limite appelée longueur de contexte, une combinaison du nombre de jetons que le LLM segmente à partir de l'invite et du nombre de jetons qu'il génère pour la fin. Chaque modèle définit sa propre longueur de contexte maximale.

Pour vous assurer que le nombre de jetons dépensés pour les transactions de fin générées pour chaque tour d'une interaction à plusieurs tours ne dépasse pas la longueur de contexte du modèle, vous pouvez définir une limite à l'aide de la propriété Nombre maximal de jetons. Lorsque vous définissez ce nombre, tenez compte des considérations basées sur un modèle, telles que le modèle que vous utilisez, sa longueur de contexte et même sa tarification. Vous devez également prendre en compte la taille attendue de la réponse (c'est-à-dire le nombre de jetons dépensés pour la fin) ainsi que le nombre de jetons dans l'invite. Si vous définissez le nombre maximum de jetons sur une valeur élevée et que votre invite est également très longue, le nombre de jetons dépensés pour les transactions de fin atteindra rapidement la longueur maximale du modèle après seulement quelques tours. A ce stade, certains LLM (mais pas tous) renvoient une réponse de 400.

Lorsque le nombre de jetons consommés pour un appel atteint la longueur du contexte du modèle, le composant LLM tente à nouveau la demande après avoir purgé le message le plus ancien de l'historique des messages.
Remarque

Etant donné que le composant LLM utilise l'historique des conversations pour tenir à jour le contexte en cours, l'exactitude des déclarations de fin de production peut diminuer lorsqu'il supprime les messages plus anciens pour prendre en compte la longueur du contexte du modèle.

Rubrique imbriquée - Historique des conversations dans les invites de fin de service

Les modèles Cohere, contrairement aux modèles GPT, sont sans état et ne maintiennent pas le contexte de conversation lors de conversations multi-tours. Pour tenir à jour le contexte de conversation lors de l'utilisation d'un modèle Cohere, le gestionnaire transformRequestPayload ajoute une section CONVERSATION au texte d'invite transmis avec la charge utile et transmis dans la conversation sous forme de paires de signaux user et assistant :
transformRequestPayload: async (event, context) => {
      let prompt = event.payload.messages[0].content;
      if (event.payload.messages.length > 1) {
         let history = event.payload.messages.slice(1).reduce((acc, cur) => `${acc}\n${cur.role}: ${cur.content}` , '');
         prompt += `\n\nCONVERSATION HISTORY:${history}\nassistant:`
      }
      return {
        "max_tokens": event.payload.maxTokens,
        "truncate": "END",
        "return_likelihoods": "NONE",
        "prompt": prompt,
        "model": "command",
        "temperature": event.payload.temperature,
        "stream": event.payload.streamResponse
      };
    },
La première requête utilisateur est incluse dans cette section et est considérée comme faisant partie de l'historique des conversations. La section se termine par un signal "assistant:" pour inviter le modèle à poursuivre la conversation.
{SYSTEM_PROMPT}

CONVERSATION
---
user: <first_query>
assistant: <first_response>
user: ...
assistant: ...
user: <latest_query>
assistant: 

Chaque virage augmente la longueur de l'invite et la probabilité que la longueur du contexte du modèle soit dépassée. Lorsque cette limite de longueur de contexte est atteinte, le composant LLLM gère la situation en capturant l'historique de la conversation et en tronquant la conversation, de sorte que la capacité du modèle à suivre les instructions reste inchangée.

Interactions LLM dans le testeur de briques

L'onglet Appels LLM vous permet de surveiller le traitement des composants LLM. A partir de cette vue, qui devient disponible lorsque le flux de dialogue passe à un composant LLM, vous pouvez suivre les échanges entre le composant LLM, l'utilisateur et le modèle en commençant par l'invite réelle que le composant LLM a envoyée au modèle, avec des valeurs de variable. A partir de ce moment, jusqu'à la sortie finale (ou sortie), vous pouvez visualiser les améliorations émises par l'utilisateur, surveiller les rotations et, si vous avez implémenté la validation, le nombre de tentatives et les erreurs associées. Lorsque le nombre de nouvelles tentatives dépasse la limite définie, l'onglet Interaction LLM affiche le code d'erreur CLMI, le message d'erreur et le code de statut d'erreur. Lorsque le nombre de nouvelles tentatives dépasse la limite définie, l'onglet Interaction LLM affiche le code d'erreur CLMI, le message d'erreur et le code de statut d'erreur. Vous pouvez afficher l'intégralité du texte des invites, des demandes d'affinement et du résultat en cliquant avec le bouton droit de la souris, puis en sélectionnant Afficher le texte complet.
Option Afficher le texte complet

Par défaut, l'état final du LLM s'affiche dans la vue LLM Calls. Pour consulter les résultats des états LLM précédents, cliquez sur les réponses LLM précédentes dans la fenêtre Testeur de bot.
Remarque

Vous pouvez enregistrer la conversation LLM en tant que cas de test.