Comment utiliser les modèles de conversation Cohere Command avec Azure Machine Learning studio

Dans cet article, vous découvrez les modèles de conversation Cohere Command et la manière de les utiliser. La famille de modèles Cohere comprend différents modèles optimisés pour différents cas d’usage, y compris les complétions de conversation, les incorporations et le reclassement. Les modèles Cohere sont optimisés pour différents cas d’usage qui incluent le raisonnement, le résumé et la réponse aux questions.

Important

Cette fonctionnalité est actuellement disponible en préversion publique. Cette préversion est fournie sans contrat de niveau de service et n’est pas recommandée pour les charges de travail de production. Certaines fonctionnalités peuvent être limitées ou non prises en charge.

Pour plus d’informations, consultez Conditions d’Utilisation Supplémentaires relatives aux Évaluations Microsoft Azure.

Modèles de conversation Cohere Command

Les modèles de conversation Cohere Command incluent les modèles suivants :

Cohere Command R+ 08-2024

Command R+ 08-2024 est un grand modèle de langage génératif optimisé pour divers cas d’utilisation, notamment pour le raisonnement, les résumés et les réponses aux questions.

• Architecture du modèle : Command R+ 08-2024 est un modèle de langage autorégressif qui utilise une architecture de transformateur optimisée. Après le pré-entraînement, le modèle utilise le réglage fin supervisé (SFT) et l’entraînement aux préférences pour aligner le comportement du modèle sur les préférences humaines, dans un souci de convivialité et de sécurité.
• Langues couvertes : le mode est optimisé pour être performant dans les langues suivantes : anglais, français, espagnol, italien, allemand, portugais du Brésil, japonais, coréen, chinois simplifié et arabe.
• Les données de préapprentissage incluent également les 13 langues suivantes : russe, polonais, turc, vietnamien, néerlandais, tchèque, indonésien, ukrainien, roumain, grec, hindi, hébreu et persan.
• Longueur du contexte : Command R+ 08-2024 prend en charge une longueur de contexte de 128 K.
• Entrée : texte uniquement.
• Sortie : texte uniquement.

Nous recommandons d’utiliser Command R+ 08-2024 pour les flux de travail qui s’appuient sur des fonctionnalités de génération augmentée de récupération (RAG) complexes, sur l’utilisation d’outils en plusieurs étapes (agents) et sur des sorties structurées.

Les modèles suivants sont disponibles :

• Cohere-command-r-plus-08-2024

Cohere Command R 08-2024

Command R 08-2024 est un grand modèle de langage optimisé pour divers cas d’utilisation, notamment pour le raisonnement, les résumés et les réponses aux questions.

• Architecture du modèle : Commande R 08-2024 est un modèle de langage autorégressif qui utilise une architecture de transformateur optimisée. Après le pré-entraînement, le modèle utilise le réglage fin supervisé (SFT) et l’entraînement aux préférences pour aligner le comportement du modèle sur les préférences humaines, dans un souci de convivialité et de sécurité.
• Langues couvertes : le modèle est optimisé pour être performant dans les langues suivantes : anglais, français, espagnol, italien, allemand, portugais du Brésil, japonais, coréen, chinois simplifié et arabe.
• Les données de préapprentissage incluent également les 13 langues suivantes : russe, polonais, turc, vietnamien, néerlandais, tchèque, indonésien, ukrainien, roumain, grec, hindi, hébreu et persan.
• Longueur du contexte : Command R 08-2024 prend en charge une longueur de contexte de 128 K.
• Entrée : texte uniquement.
• Sortie : texte uniquement.

Les modèles suivants sont disponibles :

• Cohere-command-r-08-2024

Cohere Command R+

Command R+ est un grand modèle de langage génératif optimisé pour différents cas d’usage, notamment le raisonnement, le résumé et la réponse aux questions.

• Architecture du modèle : Command R+ est un modèle de langage autorégressif qui utilise une architecture de transformateur optimisée. Après le pré-entraînement, le modèle utilise le réglage fin supervisé (SFT) et l’entraînement aux préférences pour aligner le comportement du modèle sur les préférences humaines, dans un souci de convivialité et de sécurité.
• Langues couvertes : le modèle est optimisé pour être performant dans les langues suivantes : anglais, français, espagnol, italien, allemand, portugais du Brésil, japonais, coréen, chinois simplifié et arabe.
• Les données de préapprentissage incluent également les 13 langues suivantes : russe, polonais, turc, vietnamien, néerlandais, tchèque, indonésien, ukrainien, roumain, grec, hindi, hébreu et persan.
• Longueur du contexte : Command R+ prend en charge une longueur de contexte de 128 K.
• Entrée : texte uniquement.
• Sortie : texte uniquement.

Nous vous recommandons d’utiliser Command R+ pour les flux de travail qui s’appuient sur une fonctionnalité de génération augmentée par récupération (RAG) complexe et l’utilisation d’outils à plusieurs étapes (agents).

Les modèles suivants sont disponibles :

• Cohere-command-r-plus

Cohere Command R

Command R+ est un grand modèle de langage optimisé pour différents cas d’usage, notamment le raisonnement, le résumé et la réponse aux questions.

• Architecture du modèle : Command R est un modèle de langage autorégressif qui utilise une architecture de transformateur optimisée. Après le pré-entraînement, le modèle utilise le réglage fin supervisé (SFT) et l’entraînement aux préférences pour aligner le comportement du modèle sur les préférences humaines, dans un souci de convivialité et de sécurité.
• Langues couvertes : le modèle est optimisé pour être performant dans les langues suivantes : anglais, français, espagnol, italien, allemand, portugais du Brésil, japonais, coréen, chinois simplifié et arabe.
• Les données de préapprentissage incluent également les 13 langues suivantes : russe, polonais, turc, vietnamien, néerlandais, tchèque, indonésien, ukrainien, roumain, grec, hindi, hébreu et persan.
• Longueur du contexte : Command R prend en charge une longueur de contexte de 128 K.

Command R est idéal pour une génération augmentée par récupération (RAG) plus simple et les tâches d’utilisation par outil à étape unique. Il est également idéal pour une utilisation dans les applications où le prix est un facteur important.

Les modèles suivants sont disponibles :

• Cohere-command-r

Conseil

En outre, Cohere prend en charge l’utilisation d’une API personnalisée à utiliser avec des fonctionnalités spécifiques du modèle. Pour utiliser l’API spécifique du fournisseur de modèles, consultez la Documentation Cohere ou la section exemples d’inférence pour obtenir des exemples de code.

Prérequis

Pour utiliser les modèles de conversation Cohere Command avec Azure Machine Learning, vous avez besoin des prérequis suivants :

Un modèle de déploiement

Déploiement sur des API serverless

Les modèles de conversation Cohere Command peuvent être déployés sur des points de terminaison d’API serverless avec facturation en paiement à l’utilisation. Ce type de déploiement permet de consommer des modèles en tant qu’API sans les héberger sur votre abonnement, tout en conservant la sécurité et la conformité de l’entreprise dont les organisations ont besoin.

Le déploiement vers un point de terminaison API serverless ne nécessite pas de quota de votre abonnement. Si votre modèle n’est pas encore déployé, utilisez Azure Machine Learning studio, Azure Machine Learning studio, le kit de développement logiciel (SDK) Azure Machine Learning pour Python, l’interface Azure CLI ou les modèles ARM pour déployer le modèle en tant qu’API serverless.

Déployer le modèle sur des points de terminaison API sans serveur

Le package d’inférence installé

Vous pouvez utiliser des prédictions à partir de ce modèle à l’aide du package azure-ai-inference avec Python. Pour installer ce package, vous avez besoin des prérequis suivants :

• Python 3.8 ou version ultérieure installée, y compris pip.
• L’URL du point de terminaison. Pour construire la bibliothèque cliente, vous devez passer l’URL du point de terminaison. L’URL du point de terminaison est sous la forme https://your-host-name.your-azure-region.inference.ai.azure.com, où your-host-name est le nom d’hôte unique de votre modèle de déploiement et your-azure-region est la région Azure où le modèle est déployé (par exemple, eastus2).
• En fonction de vos préférences de modèle de déploiement et d’authentification, vous aurez besoin d’une clé pour vous authentifier auprès du service ou des informations d’identification Microsoft Entra ID. La clé est une chaîne de 32 caractères.

Une fois ces conditions préalables remplies, installez le package d’inférence Azure AI avec la commande suivante :

pip install azure-ai-inference

En savoir plus sur le Package d’inférence et les informations de référence Azure AI.

Travailler avec des complétions de conversation

Dans cette section, vous utilisez l’API d’inférence de modèle Azure AI avec un modèle de complétion de conversation pour les conversations.

Conseil

L’API Inférence de modèle Azure AI vous permet de communiquer avec la plupart des modèles déployés dans Azure Machine Learning avec le même code et la même structure, y compris les modèles de conversation Cohere Command.

Créer un client pour consommer le modèle

Tout d’abord, créez le client pour consommer le modèle. Le code suivant utilise une URL de point de terminaison et une clé qui sont stockées dans les variables d’environnement.

import os
from azure.ai.inference import ChatCompletionsClient
from azure.core.credentials import AzureKeyCredential

client = ChatCompletionsClient(
    endpoint=os.environ["AZURE_INFERENCE_ENDPOINT"],
    credential=AzureKeyCredential(os.environ["AZURE_INFERENCE_CREDENTIAL"]),
)

Obtenir les fonctionnalités du modèle

L’itinéraire /info retourne des informations sur le modèle déployé sur le point de terminaison. Renvoyez les informations du modèle en appelant la méthode suivante :

model_info = client.get_model_info()

La réponse est comme suit :

print("Model name:", model_info.model_name)
print("Model type:", model_info.model_type)
print("Model provider name:", model_info.model_provider_name)

Model name: Cohere-command-r-plus-08-2024
Model type: chat-completions
Model provider name: Cohere

Créer une requête de complétion de conversation

L’exemple suivant vous montre comment créer une requête de complétions de conversation de base sur le modèle.

from azure.ai.inference.models import SystemMessage, UserMessage

response = client.complete(
    messages=[
        SystemMessage(content="You are a helpful assistant."),
        UserMessage(content="How many languages are in the world?"),
    ],
)

La réponse est la suivante, où vous pouvez voir les statistiques d’utilisation du modèle :

print("Response:", response.choices[0].message.content)
print("Model:", response.model)
print("Usage:")
print("\tPrompt tokens:", response.usage.prompt_tokens)
print("\tTotal tokens:", response.usage.total_tokens)
print("\tCompletion tokens:", response.usage.completion_tokens)

Response: As of now, it's estimated that there are about 7,000 languages spoken around the world. However, this number can vary as some languages become extinct and new ones develop. It's also important to note that the number of speakers can greatly vary between languages, with some having millions of speakers and others only a few hundred.
Model: Cohere-command-r-plus-08-2024
Usage: 
  Prompt tokens: 19
  Total tokens: 91
  Completion tokens: 72

Examinez la section usage dans la réponse pour voir le nombre de jetons utilisés pour l’invite, le nombre total de jetons générés et le nombre de jetons utilisés pour la complétion.

Diffuser du contenu

Par défaut, l’API de complétion retourne l’intégralité du contenu généré dans une réponse unique. Si vous générez des complétions longues, l’attente de la réponse peut durer plusieurs secondes.

Vous pouvez diffuser en continu le contenu pour l’obtenir à mesure qu’il est généré. Diffuser le contenu en continu vous permet de commencer à traiter la complétion à mesure que le contenu devient disponible. Ce mode renvoie un objet qui diffuse la réponse en tant qu’événements envoyés par le serveur contenant uniquement des données. Extrayez les blocs du champ delta, plutôt que le champ de message.

result = client.complete(
    messages=[
        SystemMessage(content="You are a helpful assistant."),
        UserMessage(content="How many languages are in the world?"),
    ],
    temperature=0,
    top_p=1,
    max_tokens=2048,
    stream=True,
)

Pour diffuser en continu des complétions, définissez stream=True lorsque vous appelez le modèle.

Pour visualiser la sortie, définissez une fonction d’assistance pour imprimer le flux.

def print_stream(result):
    """
    Prints the chat completion with streaming.
    """
    import time
    for update in result:
        if update.choices:
            print(update.choices[0].delta.content, end="")

Vous pouvez visualiser la façon dont la diffusion en continu génère du contenu :

print_stream(result)

Découvrir d’autres paramètres pris en charge par le client d’inférence

Explorez d’autres paramètres que vous pouvez spécifier dans le client d’inférence. Pour obtenir la liste complète de tous les paramètres pris en charge et de leur documentation correspondante, consultez la référence de l'API d'inférence des modèles Azure AI.

from azure.ai.inference.models import ChatCompletionsResponseFormatText

response = client.complete(
    messages=[
        SystemMessage(content="You are a helpful assistant."),
        UserMessage(content="How many languages are in the world?"),
    ],
    presence_penalty=0.1,
    frequency_penalty=0.8,
    max_tokens=2048,
    stop=["<|endoftext|>"],
    temperature=0,
    top_p=1,
    response_format={ "type": ChatCompletionsResponseFormatText() },
)

Si vous souhaitez passer un paramètre qui ne figure pas dans la liste des paramètres pris en charge, vous pouvez le transmettre au modèle sous-jacent en utilisant des paramètres supplémentaires. Consulter Transmettre des paramètres supplémentaires au modèle.

Créer des sorties JSON

Les modèles de conversation Cohere Command peuvent créer des sorties JSON. Définissez response_format sur json_object pour activer le mode JSON et garantir que le message généré par le modèle est en JSON valide. Vous devez également vous-même demander au modèle de produire du JSON via un message système ou utilisateur. En outre, le contenu du message peut être partiellement coupé si finish_reason="length", ce qui indique que la génération a dépassé max_tokens ou que la conversation a dépassé la longueur maximale du contexte.

from azure.ai.inference.models import ChatCompletionsResponseFormatJSON

response = client.complete(
    messages=[
        SystemMessage(content="You are a helpful assistant that always generate responses in JSON format, using."
                      " the following format: { ""answer"": ""response"" }."),
        UserMessage(content="How many languages are in the world?"),
    ],
    response_format={ "type": ChatCompletionsResponseFormatJSON() }
)

Transmettre des paramètres supplémentaires au modèle

L'API d'inférence du modèle Azure AI vous permet de transmettre des paramètres supplémentaires au modèle. L’exemple de code suivant montre comment transmettre le paramètre supplémentaire logprobs au modèle.

Avant de transmettre des paramètres supplémentaires à l’API Inférence de modèle Azure AI, assurez-vous que votre modèle prend en charge ces paramètres supplémentaires. Lorsque la requête est adressée au modèle sous-jacent, l’en-tête extra-parameters est transmis au modèle avec la valeur pass-through. Cette valeur indique au point de terminaison de transmettre les paramètres supplémentaires au modèle. L’utilisation de paramètres supplémentaires avec le modèle ne garantit pas que le modèle peut réellement les gérer. Lisez la documentation du modèle pour comprendre quels paramètres supplémentaires sont pris en charge.

response = client.complete(
    messages=[
        SystemMessage(content="You are a helpful assistant."),
        UserMessage(content="How many languages are in the world?"),
    ],
    model_extras={
        "logprobs": True
    }
)

Utiliser des outils

Les modèles de conversation Cohere Command prennent en charge l’utilisation d’outils, qui peuvent être une ressource extraordinaire lorsque vous devez décharger des tâches spécifiques du modèle de langage et vous appuyer à la place sur un système plus déterministe ou même un modèle de langage différent. L'API Inférence de modèle Azure AI vous permet de définir des outils de la manière suivante.

L’exemple de code suivant crée une définition d’outil capable d’examiner les informations de vol de deux villes différentes.

from azure.ai.inference.models import FunctionDefinition, ChatCompletionsFunctionToolDefinition

flight_info = ChatCompletionsFunctionToolDefinition(
    function=FunctionDefinition(
        name="get_flight_info",
        description="Returns information about the next flight between two cities. This includes the name of the airline, flight number and the date and time of the next flight",
        parameters={
            "type": "object",
            "properties": {
                "origin_city": {
                    "type": "string",
                    "description": "The name of the city where the flight originates",
                },
                "destination_city": {
                    "type": "string",
                    "description": "The flight destination city",
                },
            },
            "required": ["origin_city", "destination_city"],
        },
    )
)

tools = [flight_info]

Dans cet exemple, la sortie de la fonction est qu’il n’existe aucun vol disponible pour l’itinéraire sélectionné, mais que l’utilisateur doit envisager de prendre un train.

def get_flight_info(loc_origin: str, loc_destination: str):
    return { 
        "info": f"There are no flights available from {loc_origin} to {loc_destination}. You should take a train, specially if it helps to reduce CO2 emissions."
    }

Remarque

Cohere-command-r-plus-08-2024, Cohere-command-r-08-2024, Cohere-command-r-plus, et Cohere-command-r nécessitent que les réponses d’un outil soient un contenu JSON valide formaté sous forme de chaîne. Lors de la construction de messages de type Outil, vérifiez que la réponse est une chaîne JSON valide.

Demandez au modèle de réserver des vols à l’aide de cette fonction :

messages = [
    SystemMessage(
        content="You are a helpful assistant that help users to find information about traveling, how to get"
                " to places and the different transportations options. You care about the environment and you"
                " always have that in mind when answering inqueries.",
    ),
    UserMessage(
        content="When is the next flight from Miami to Seattle?",
    ),
]

response = client.complete(
    messages=messages, tools=tools, tool_choice="auto"
)

Vous pouvez inspecter la réponse pour savoir si un outil doit être appelé. Inspectez le motif de fin pour déterminer si l’outil doit être appelé. N’oubliez pas que plusieurs types d’outils peuvent être indiqués. Cet exemple illustre un outil de type function.

response_message = response.choices[0].message
tool_calls = response_message.tool_calls

print("Finish reason:", response.choices[0].finish_reason)
print("Tool call:", tool_calls)

Pour continuer, ajoutez ce message à l’historique des conversations :

messages.append(
    response_message
)

À présent, il est temps d’appeler la fonction appropriée pour gérer l’appel d’outil. L’extrait de code suivant itère sur tous les appels d’outil indiqués dans la réponse et appelle la fonction correspondante avec les paramètres appropriés. La réponse est également ajoutée à l’historique des conversations.

import json
from azure.ai.inference.models import ToolMessage

for tool_call in tool_calls:

    # Get the tool details:

    function_name = tool_call.function.name
    function_args = json.loads(tool_call.function.arguments.replace("\'", "\""))
    tool_call_id = tool_call.id

    print(f"Calling function `{function_name}` with arguments {function_args}")

    # Call the function defined above using `locals()`, which returns the list of all functions 
    # available in the scope as a dictionary. Notice that this is just done as a simple way to get
    # the function callable from its string name. Then we can call it with the corresponding
    # arguments.

    callable_func = locals()[function_name]
    function_response = callable_func(**function_args)

    print("->", function_response)

    # Once we have a response from the function and its arguments, we can append a new message to the chat 
    # history. Notice how we are telling to the model that this chat message came from a tool:

    messages.append(
        ToolMessage(
            tool_call_id=tool_call_id,
            content=json.dumps(function_response)
        )
    )

Voir la réponse du modèle :

response = client.complete(
    messages=messages,
    tools=tools,
)

Appliquer la sécurité du contenu

L’API Inférence de modèle Azure AI prend en charge Azure AI Sécurité du Contenu. Lorsque vous utilisez des déploiements avec la sécurité du contenu Azure AI activée, les entrées et les sorties passent par un ensemble de modèles de classification visant à détecter et à empêcher la sortie de contenu dangereux. Le système de filtrage de contenu (préversion) détecte et prend des mesures sur des catégories spécifiques de contenu potentiellement dangereux dans les invites d’entrée et les exécutions de sortie.

L’exemple suivant montre comment gérer les évènements lorsque le modèle détecte du contenu dangereux dans l’invite d’entrée et que la sécurité du contenu est activée.

from azure.ai.inference.models import AssistantMessage, UserMessage, SystemMessage

try:
    response = client.complete(
        messages=[
            SystemMessage(content="You are an AI assistant that helps people find information."),
            UserMessage(content="Chopping tomatoes and cutting them into cubes or wedges are great ways to practice your knife skills."),
        ]
    )

    print(response.choices[0].message.content)

except HttpResponseError as ex:
    if ex.status_code == 400:
        response = ex.response.json()
        if isinstance(response, dict) and "error" in response:
            print(f"Your request triggered an {response['error']['code']} error:\n\t {response['error']['message']}")
        else:
            raise
    raise

Conseil

Pour en savoir plus sur la façon dont vous pouvez configurer et contrôler les paramètres de sécurité du contenu Azure AI, consultez la documentation Azure AI Sécurité du Contenu.

Modèles de conversation Cohere Command

Les modèles de conversation Cohere Command incluent les modèles suivants :

Cohere Command R+ 08-2024

Command R+ 08-2024 est un grand modèle de langage génératif optimisé pour divers cas d’utilisation, notamment pour le raisonnement, les résumés et les réponses aux questions.

• Architecture du modèle : Command R+ 08-2024 est un modèle de langage autorégressif qui utilise une architecture de transformateur optimisée. Après le pré-entraînement, le modèle utilise le réglage fin supervisé (SFT) et l’entraînement aux préférences pour aligner le comportement du modèle sur les préférences humaines, dans un souci de convivialité et de sécurité.
• Langues couvertes : le mode est optimisé pour être performant dans les langues suivantes : anglais, français, espagnol, italien, allemand, portugais du Brésil, japonais, coréen, chinois simplifié et arabe.
• Les données de préapprentissage incluent également les 13 langues suivantes : russe, polonais, turc, vietnamien, néerlandais, tchèque, indonésien, ukrainien, roumain, grec, hindi, hébreu et persan.
• Longueur du contexte : Command R+ 08-2024 prend en charge une longueur de contexte de 128 K.
• Entrée : texte uniquement.
• Sortie : texte uniquement.

Nous recommandons d’utiliser Command R+ 08-2024 pour les flux de travail qui s’appuient sur des fonctionnalités de génération augmentée de récupération (RAG) complexes, sur l’utilisation d’outils en plusieurs étapes (agents) et sur des sorties structurées.

Les modèles suivants sont disponibles :

• Cohere-command-r-plus-08-2024

Cohere Command R 08-2024

Command R 08-2024 est un grand modèle de langage optimisé pour divers cas d’utilisation, notamment pour le raisonnement, les résumés et les réponses aux questions.

• Architecture du modèle : Commande R 08-2024 est un modèle de langage autorégressif qui utilise une architecture de transformateur optimisée. Après le pré-entraînement, le modèle utilise le réglage fin supervisé (SFT) et l’entraînement aux préférences pour aligner le comportement du modèle sur les préférences humaines, dans un souci de convivialité et de sécurité.
• Langues couvertes : le modèle est optimisé pour être performant dans les langues suivantes : anglais, français, espagnol, italien, allemand, portugais du Brésil, japonais, coréen, chinois simplifié et arabe.
• Les données de préapprentissage incluent également les 13 langues suivantes : russe, polonais, turc, vietnamien, néerlandais, tchèque, indonésien, ukrainien, roumain, grec, hindi, hébreu et persan.
• Longueur du contexte : Command R 08-2024 prend en charge une longueur de contexte de 128 K.
• Entrée : texte uniquement.
• Sortie : texte uniquement.

Les modèles suivants sont disponibles :

• Cohere-command-r-08-2024

Cohere Command R+

Command R+ est un grand modèle de langage génératif optimisé pour différents cas d’usage, notamment le raisonnement, le résumé et la réponse aux questions.

• Architecture du modèle : Command R+ est un modèle de langage autorégressif qui utilise une architecture de transformateur optimisée. Après le pré-entraînement, le modèle utilise le réglage fin supervisé (SFT) et l’entraînement aux préférences pour aligner le comportement du modèle sur les préférences humaines, dans un souci de convivialité et de sécurité.
• Langues couvertes : le modèle est optimisé pour être performant dans les langues suivantes : anglais, français, espagnol, italien, allemand, portugais du Brésil, japonais, coréen, chinois simplifié et arabe.
• Les données de préapprentissage incluent également les 13 langues suivantes : russe, polonais, turc, vietnamien, néerlandais, tchèque, indonésien, ukrainien, roumain, grec, hindi, hébreu et persan.
• Longueur du contexte : Command R+ prend en charge une longueur de contexte de 128 K.
• Entrée : texte uniquement.
• Sortie : texte uniquement.

Nous vous recommandons d’utiliser Command R+ pour les flux de travail qui s’appuient sur une fonctionnalité de génération augmentée par récupération (RAG) complexe et l’utilisation d’outils à plusieurs étapes (agents).

Les modèles suivants sont disponibles :

• Cohere-command-r-plus

Cohere Command R

Command R+ est un grand modèle de langage optimisé pour différents cas d’usage, notamment le raisonnement, le résumé et la réponse aux questions.

• Architecture du modèle : Command R est un modèle de langage autorégressif qui utilise une architecture de transformateur optimisée. Après le pré-entraînement, le modèle utilise le réglage fin supervisé (SFT) et l’entraînement aux préférences pour aligner le comportement du modèle sur les préférences humaines, dans un souci de convivialité et de sécurité.
• Langues couvertes : le modèle est optimisé pour être performant dans les langues suivantes : anglais, français, espagnol, italien, allemand, portugais du Brésil, japonais, coréen, chinois simplifié et arabe.
• Les données de préapprentissage incluent également les 13 langues suivantes : russe, polonais, turc, vietnamien, néerlandais, tchèque, indonésien, ukrainien, roumain, grec, hindi, hébreu et persan.
• Longueur du contexte : Command R prend en charge une longueur de contexte de 128 K.

Command R est idéal pour une génération augmentée par récupération (RAG) plus simple et les tâches d’utilisation par outil à étape unique. Il est également idéal pour une utilisation dans les applications où le prix est un facteur important.

Les modèles suivants sont disponibles :

• Cohere-command-r

Conseil

En outre, Cohere prend en charge l’utilisation d’une API personnalisée à utiliser avec des fonctionnalités spécifiques du modèle. Pour utiliser l’API spécifique du fournisseur de modèles, consultez la Documentation Cohere ou la section exemples d’inférence pour obtenir des exemples de code.

Prérequis

Pour utiliser les modèles de conversation Cohere Command avec Azure Machine Learning, vous avez besoin des prérequis suivants :

Un modèle de déploiement

Déploiement sur des API serverless

Les modèles de conversation Cohere Command peuvent être déployés sur des points de terminaison d’API serverless avec facturation en paiement à l’utilisation. Ce type de déploiement permet de consommer des modèles en tant qu’API sans les héberger sur votre abonnement, tout en conservant la sécurité et la conformité de l’entreprise dont les organisations ont besoin.

Le déploiement vers un point de terminaison API serverless ne nécessite pas de quota de votre abonnement. Si votre modèle n’est pas déjà déployé, utilisez Azure Machine Learning studio, le kit de développement logiciel (SDK) Azure Machine Learning pour Python, l’interface de ligne de commande Azure ou les modèles ARM pour déployer le modèle en tant qu’API serverless.

Déployer le modèle sur des points de terminaison API sans serveur

Le package d’inférence installé

Vous pouvez consommer des prédictions depuis ce modèle en utilisant le package @azure-rest/ai-inference de npm. Pour installer ce package, vous avez besoin des prérequis suivants :

• Versions LTS de Node.js avec npm.
• L’URL du point de terminaison. Pour construire la bibliothèque cliente, vous devez passer l’URL du point de terminaison. L’URL du point de terminaison est sous la forme https://your-host-name.your-azure-region.inference.ai.azure.com, où your-host-name est le nom d’hôte unique de votre modèle de déploiement et your-azure-region est la région Azure où le modèle est déployé (par exemple, eastus2).
• En fonction de vos préférences de modèle de déploiement et d’authentification, vous aurez besoin d’une clé pour vous authentifier auprès du service ou des informations d’identification Microsoft Entra ID. La clé est une chaîne de 32 caractères.

Une fois ces prérequis remplis, installez la bibliothèque Azure Inference pour JavaScript avec la commande suivante :

npm install @azure-rest/ai-inference

Travailler avec des complétions de conversation

Dans cette section, vous utilisez l’API d’inférence de modèle Azure AI avec un modèle de complétion de conversation pour les conversations.

Conseil

L’API Inférence de modèle Azure AI vous permet de communiquer avec la plupart des modèles déployés dans Azure Machine Learning avec le même code et la même structure, y compris les modèles de conversation Cohere Command.

Créer un client pour consommer le modèle

Tout d’abord, créez le client pour consommer le modèle. Le code suivant utilise une URL de point de terminaison et une clé qui sont stockées dans les variables d’environnement.

import ModelClient from "@azure-rest/ai-inference";
import { isUnexpected } from "@azure-rest/ai-inference";
import { AzureKeyCredential } from "@azure/core-auth";

const client = new ModelClient(
    process.env.AZURE_INFERENCE_ENDPOINT, 
    new AzureKeyCredential(process.env.AZURE_INFERENCE_CREDENTIAL)
);

Obtenir les fonctionnalités du modèle

L’itinéraire /info retourne des informations sur le modèle déployé sur le point de terminaison. Renvoyez les informations du modèle en appelant la méthode suivante :

var model_info = await client.path("/info").get()

La réponse est comme suit :

console.log("Model name: ", model_info.body.model_name)
console.log("Model type: ", model_info.body.model_type)
console.log("Model provider name: ", model_info.body.model_provider_name)

Model name: Cohere-command-r-plus-08-2024
Model type: chat-completions
Model provider name: Cohere

Créer une requête de complétion de conversation

L’exemple suivant vous montre comment créer une requête de complétions de conversation de base sur le modèle.

var messages = [
    { role: "system", content: "You are a helpful assistant" },
    { role: "user", content: "How many languages are in the world?" },
];

var response = await client.path("/chat/completions").post({
    body: {
        messages: messages,
    }
});

La réponse est la suivante, où vous pouvez voir les statistiques d’utilisation du modèle :

if (isUnexpected(response)) {
    throw response.body.error;
}

console.log("Response: ", response.body.choices[0].message.content);
console.log("Model: ", response.body.model);
console.log("Usage:");
console.log("\tPrompt tokens:", response.body.usage.prompt_tokens);
console.log("\tTotal tokens:", response.body.usage.total_tokens);
console.log("\tCompletion tokens:", response.body.usage.completion_tokens);

Response: As of now, it's estimated that there are about 7,000 languages spoken around the world. However, this number can vary as some languages become extinct and new ones develop. It's also important to note that the number of speakers can greatly vary between languages, with some having millions of speakers and others only a few hundred.
Model: Cohere-command-r-plus-08-2024
Usage: 
  Prompt tokens: 19
  Total tokens: 91
  Completion tokens: 72

Examinez la section usage dans la réponse pour voir le nombre de jetons utilisés pour l’invite, le nombre total de jetons générés et le nombre de jetons utilisés pour la complétion.

Diffuser du contenu

Par défaut, l’API de complétion retourne l’intégralité du contenu généré dans une réponse unique. Si vous générez des complétions longues, l’attente de la réponse peut durer plusieurs secondes.

Vous pouvez diffuser en continu le contenu pour l’obtenir à mesure qu’il est généré. Diffuser le contenu en continu vous permet de commencer à traiter la complétion à mesure que le contenu devient disponible. Ce mode renvoie un objet qui diffuse la réponse en tant qu’événements envoyés par le serveur contenant uniquement des données. Extrayez les blocs du champ delta, plutôt que le champ de message.

var messages = [
    { role: "system", content: "You are a helpful assistant" },
    { role: "user", content: "How many languages are in the world?" },
];

var response = await client.path("/chat/completions").post({
    body: {
        messages: messages,
    }
}).asNodeStream();

Pour diffuser les complétions en continu, utilisez .asNodeStream() lorsque vous appelez le modèle.

Vous pouvez visualiser la façon dont la diffusion en continu génère du contenu :

var stream = response.body;
if (!stream) {
    stream.destroy();
    throw new Error(`Failed to get chat completions with status: ${response.status}`);
}

if (response.status !== "200") {
    throw new Error(`Failed to get chat completions: ${response.body.error}`);
}

var sses = createSseStream(stream);

for await (const event of sses) {
    if (event.data === "[DONE]") {
        return;
    }
    for (const choice of (JSON.parse(event.data)).choices) {
        console.log(choice.delta?.content ?? "");
    }
}

Découvrir d’autres paramètres pris en charge par le client d’inférence

Explorez d’autres paramètres que vous pouvez spécifier dans le client d’inférence. Pour obtenir la liste complète de tous les paramètres pris en charge et de leur documentation correspondante, consultez la référence de l'API d'inférence des modèles Azure AI.

var messages = [
    { role: "system", content: "You are a helpful assistant" },
    { role: "user", content: "How many languages are in the world?" },
];

var response = await client.path("/chat/completions").post({
    body: {
        messages: messages,
        presence_penalty: "0.1",
        frequency_penalty: "0.8",
        max_tokens: 2048,
        stop: ["<|endoftext|>"],
        temperature: 0,
        top_p: 1,
        response_format: { type: "text" },
    }
});

Si vous souhaitez passer un paramètre qui ne figure pas dans la liste des paramètres pris en charge, vous pouvez le transmettre au modèle sous-jacent en utilisant des paramètres supplémentaires. Consulter Transmettre des paramètres supplémentaires au modèle.

Créer des sorties JSON

Les modèles de conversation Cohere Command peuvent créer des sorties JSON. Définissez response_format sur json_object pour activer le mode JSON et garantir que le message généré par le modèle est en JSON valide. Vous devez également vous-même demander au modèle de produire du JSON via un message système ou utilisateur. En outre, le contenu du message peut être partiellement coupé si finish_reason="length", ce qui indique que la génération a dépassé max_tokens ou que la conversation a dépassé la longueur maximale du contexte.

var messages = [
    { role: "system", content: "You are a helpful assistant that always generate responses in JSON format, using."
        + " the following format: { \"answer\": \"response\" }." },
    { role: "user", content: "How many languages are in the world?" },
];

var response = await client.path("/chat/completions").post({
    body: {
        messages: messages,
        response_format: { type: "json_object" }
    }
});

Transmettre des paramètres supplémentaires au modèle

L'API d'inférence du modèle Azure AI vous permet de transmettre des paramètres supplémentaires au modèle. L’exemple de code suivant montre comment transmettre le paramètre supplémentaire logprobs au modèle.

Avant de transmettre des paramètres supplémentaires à l’API Inférence de modèle Azure AI, assurez-vous que votre modèle prend en charge ces paramètres supplémentaires. Lorsque la requête est adressée au modèle sous-jacent, l’en-tête extra-parameters est transmis au modèle avec la valeur pass-through. Cette valeur indique au point de terminaison de transmettre les paramètres supplémentaires au modèle. L’utilisation de paramètres supplémentaires avec le modèle ne garantit pas que le modèle peut réellement les gérer. Lisez la documentation du modèle pour comprendre quels paramètres supplémentaires sont pris en charge.

var messages = [
    { role: "system", content: "You are a helpful assistant" },
    { role: "user", content: "How many languages are in the world?" },
];

var response = await client.path("/chat/completions").post({
    headers: {
        "extra-params": "pass-through"
    },
    body: {
        messages: messages,
        logprobs: true
    }
});

Utiliser des outils

Les modèles de conversation Cohere Command prennent en charge l’utilisation d’outils, qui peuvent être une ressource extraordinaire lorsque vous devez décharger des tâches spécifiques du modèle de langage et vous appuyer à la place sur un système plus déterministe ou même un modèle de langage différent. L'API Inférence de modèle Azure AI vous permet de définir des outils de la manière suivante.

L’exemple de code suivant crée une définition d’outil capable d’examiner les informations de vol de deux villes différentes.

const flight_info = {
    name: "get_flight_info",
    description: "Returns information about the next flight between two cities. This includes the name of the airline, flight number and the date and time of the next flight",
    parameters: {
        type: "object",
        properties: {
            origin_city: {
                type: "string",
                description: "The name of the city where the flight originates",
            },
            destination_city: {
                type: "string",
                description: "The flight destination city",
            },
        },
        required: ["origin_city", "destination_city"],
    },
}

const tools = [
    {
        type: "function",
        function: flight_info,
    },
];

Dans cet exemple, la sortie de la fonction est qu’il n’existe aucun vol disponible pour l’itinéraire sélectionné, mais que l’utilisateur doit envisager de prendre un train.

function get_flight_info(loc_origin, loc_destination) {
    return {
        info: "There are no flights available from " + loc_origin + " to " + loc_destination + ". You should take a train, specially if it helps to reduce CO2 emissions."
    }
}

Remarque

Cohere-command-r-plus-08-2024, Cohere-command-r-08-2024, Cohere-command-r-plus, et Cohere-command-r nécessitent que les réponses d’un outil soient un contenu JSON valide formaté sous forme de chaîne. Lors de la construction de messages de type Outil, vérifiez que la réponse est une chaîne JSON valide.

Demandez au modèle de réserver des vols à l’aide de cette fonction :

var result = await client.path("/chat/completions").post({
    body: {
        messages: messages,
        tools: tools,
        tool_choice: "auto"
    }
});

Vous pouvez inspecter la réponse pour savoir si un outil doit être appelé. Inspectez le motif de fin pour déterminer si l’outil doit être appelé. N’oubliez pas que plusieurs types d’outils peuvent être indiqués. Cet exemple illustre un outil de type function.

const response_message = response.body.choices[0].message;
const tool_calls = response_message.tool_calls;

console.log("Finish reason: " + response.body.choices[0].finish_reason);
console.log("Tool call: " + tool_calls);

Pour continuer, ajoutez ce message à l’historique des conversations :

messages.push(response_message);

À présent, il est temps d’appeler la fonction appropriée pour gérer l’appel d’outil. L’extrait de code suivant itère sur tous les appels d’outil indiqués dans la réponse et appelle la fonction correspondante avec les paramètres appropriés. La réponse est également ajoutée à l’historique des conversations.

function applyToolCall({ function: call, id }) {
    // Get the tool details:
    const tool_params = JSON.parse(call.arguments);
    console.log("Calling function " + call.name + " with arguments " + tool_params);

    // Call the function defined above using `window`, which returns the list of all functions 
    // available in the scope as a dictionary. Notice that this is just done as a simple way to get
    // the function callable from its string name. Then we can call it with the corresponding
    // arguments.
    const function_response = tool_params.map(window[call.name]);
    console.log("-> " + function_response);

    return function_response
}

for (const tool_call of tool_calls) {
    var tool_response = tool_call.apply(applyToolCall);

    messages.push(
        {
            role: "tool",
            tool_call_id: tool_call.id,
            content: tool_response
        }
    );
}

Voir la réponse du modèle :

var result = await client.path("/chat/completions").post({
    body: {
        messages: messages,
        tools: tools,
    }
});

Appliquer la sécurité du contenu

L’API Inférence de modèle Azure AI prend en charge Azure AI Sécurité du Contenu. Lorsque vous utilisez des déploiements avec la sécurité du contenu Azure AI activée, les entrées et les sorties passent par un ensemble de modèles de classification visant à détecter et à empêcher la sortie de contenu dangereux. Le système de filtrage de contenu (préversion) détecte et prend des mesures sur des catégories spécifiques de contenu potentiellement dangereux dans les invites d’entrée et les exécutions de sortie.

L’exemple suivant montre comment gérer les évènements lorsque le modèle détecte du contenu dangereux dans l’invite d’entrée et que la sécurité du contenu est activée.

try {
    var messages = [
        { role: "system", content: "You are an AI assistant that helps people find information." },
        { role: "user", content: "Chopping tomatoes and cutting them into cubes or wedges are great ways to practice your knife skills." },
    ];

    var response = await client.path("/chat/completions").post({
        body: {
            messages: messages,
        }
    });

    console.log(response.body.choices[0].message.content);
}
catch (error) {
    if (error.status_code == 400) {
        var response = JSON.parse(error.response._content);
        if (response.error) {
            console.log(`Your request triggered an ${response.error.code} error:\n\t ${response.error.message}`);
        }
        else
        {
            throw error;
        }
    }
}

Conseil

Pour en savoir plus sur la façon dont vous pouvez configurer et contrôler les paramètres de sécurité du contenu Azure AI, consultez la documentation Azure AI Sécurité du Contenu.

Modèles de conversation Cohere Command

Les modèles de conversation Cohere Command incluent les modèles suivants :

Cohere Command R+ 08-2024

Command R+ 08-2024 est un grand modèle de langage génératif optimisé pour divers cas d’utilisation, notamment pour le raisonnement, les résumés et les réponses aux questions.

• Architecture du modèle : Command R+ 08-2024 est un modèle de langage autorégressif qui utilise une architecture de transformateur optimisée. Après le pré-entraînement, le modèle utilise le réglage fin supervisé (SFT) et l’entraînement aux préférences pour aligner le comportement du modèle sur les préférences humaines, dans un souci de convivialité et de sécurité.
• Langues couvertes : le mode est optimisé pour être performant dans les langues suivantes : anglais, français, espagnol, italien, allemand, portugais du Brésil, japonais, coréen, chinois simplifié et arabe.
• Les données de préapprentissage incluent également les 13 langues suivantes : russe, polonais, turc, vietnamien, néerlandais, tchèque, indonésien, ukrainien, roumain, grec, hindi, hébreu et persan.
• Longueur du contexte : Command R+ 08-2024 prend en charge une longueur de contexte de 128 K.
• Entrée : texte uniquement.
• Sortie : texte uniquement.

Nous recommandons d’utiliser Command R+ 08-2024 pour les flux de travail qui s’appuient sur des fonctionnalités de génération augmentée de récupération (RAG) complexes, sur l’utilisation d’outils en plusieurs étapes (agents) et sur des sorties structurées.

Les modèles suivants sont disponibles :

• Cohere-command-r-plus-08-2024

Cohere Command R 08-2024

Command R 08-2024 est un grand modèle de langage optimisé pour divers cas d’utilisation, notamment pour le raisonnement, les résumés et les réponses aux questions.

• Architecture du modèle : Commande R 08-2024 est un modèle de langage autorégressif qui utilise une architecture de transformateur optimisée. Après le pré-entraînement, le modèle utilise le réglage fin supervisé (SFT) et l’entraînement aux préférences pour aligner le comportement du modèle sur les préférences humaines, dans un souci de convivialité et de sécurité.
• Langues couvertes : le modèle est optimisé pour être performant dans les langues suivantes : anglais, français, espagnol, italien, allemand, portugais du Brésil, japonais, coréen, chinois simplifié et arabe.
• Les données de préapprentissage incluent également les 13 langues suivantes : russe, polonais, turc, vietnamien, néerlandais, tchèque, indonésien, ukrainien, roumain, grec, hindi, hébreu et persan.
• Longueur du contexte : Command R 08-2024 prend en charge une longueur de contexte de 128 K.
• Entrée : texte uniquement.
• Sortie : texte uniquement.

Les modèles suivants sont disponibles :

• Cohere-command-r-08-2024

Cohere Command R+

Command R+ est un grand modèle de langage génératif optimisé pour différents cas d’usage, notamment le raisonnement, le résumé et la réponse aux questions.

• Architecture du modèle : Command R+ est un modèle de langage autorégressif qui utilise une architecture de transformateur optimisée. Après le pré-entraînement, le modèle utilise le réglage fin supervisé (SFT) et l’entraînement aux préférences pour aligner le comportement du modèle sur les préférences humaines, dans un souci de convivialité et de sécurité.
• Langues couvertes : le modèle est optimisé pour être performant dans les langues suivantes : anglais, français, espagnol, italien, allemand, portugais du Brésil, japonais, coréen, chinois simplifié et arabe.
• Les données de préapprentissage incluent également les 13 langues suivantes : russe, polonais, turc, vietnamien, néerlandais, tchèque, indonésien, ukrainien, roumain, grec, hindi, hébreu et persan.
• Longueur du contexte : Command R+ prend en charge une longueur de contexte de 128 K.
• Entrée : texte uniquement.
• Sortie : texte uniquement.

Nous vous recommandons d’utiliser Command R+ pour les flux de travail qui s’appuient sur une fonctionnalité de génération augmentée par récupération (RAG) complexe et l’utilisation d’outils à plusieurs étapes (agents).

Les modèles suivants sont disponibles :

• Cohere-command-r-plus

Cohere Command R

Command R+ est un grand modèle de langage optimisé pour différents cas d’usage, notamment le raisonnement, le résumé et la réponse aux questions.

• Architecture du modèle : Command R est un modèle de langage autorégressif qui utilise une architecture de transformateur optimisée. Après le pré-entraînement, le modèle utilise le réglage fin supervisé (SFT) et l’entraînement aux préférences pour aligner le comportement du modèle sur les préférences humaines, dans un souci de convivialité et de sécurité.
• Langues couvertes : le modèle est optimisé pour être performant dans les langues suivantes : anglais, français, espagnol, italien, allemand, portugais du Brésil, japonais, coréen, chinois simplifié et arabe.
• Les données de préapprentissage incluent également les 13 langues suivantes : russe, polonais, turc, vietnamien, néerlandais, tchèque, indonésien, ukrainien, roumain, grec, hindi, hébreu et persan.
• Longueur du contexte : Command R prend en charge une longueur de contexte de 128 K.

Command R est idéal pour une génération augmentée par récupération (RAG) plus simple et les tâches d’utilisation par outil à étape unique. Il est également idéal pour une utilisation dans les applications où le prix est un facteur important.

Les modèles suivants sont disponibles :

• Cohere-command-r

Conseil

En outre, Cohere prend en charge l’utilisation d’une API personnalisée à utiliser avec des fonctionnalités spécifiques du modèle. Pour utiliser l’API spécifique du fournisseur de modèles, consultez la Documentation Cohere ou la section exemples d’inférence pour obtenir des exemples de code.

Prérequis

Pour utiliser les modèles de conversation Cohere Command avec Azure Machine Learning, vous avez besoin des prérequis suivants :

Un modèle de déploiement

Déploiement sur des API serverless

Les modèles de conversation Cohere Command peuvent être déployés sur des points de terminaison d’API serverless avec facturation en paiement à l’utilisation. Ce type de déploiement permet de consommer des modèles en tant qu’API sans les héberger sur votre abonnement, tout en conservant la sécurité et la conformité de l’entreprise dont les organisations ont besoin.

Le déploiement vers un point de terminaison API serverless ne nécessite pas de quota de votre abonnement. Si votre modèle n’est pas déjà déployé, utilisez Azure Machine Learning studio, le kit de développement logiciel (SDK) Azure Machine Learning pour Python, l’interface de ligne de commande Azure ou les modèles ARM pour déployer le modèle en tant qu’API serverless.

Déployer le modèle sur des points de terminaison API sans serveur

Le package d’inférence installé

Vous pouvez consommer les prédictions de ce modèle en utilisant le package Azure.AI.Inference de NuGet. Pour installer ce package, vous avez besoin des prérequis suivants :

• L’URL du point de terminaison. Pour construire la bibliothèque cliente, vous devez passer l’URL du point de terminaison. L’URL du point de terminaison est sous la forme https://your-host-name.your-azure-region.inference.ai.azure.com, où your-host-name est le nom d’hôte unique de votre modèle de déploiement et your-azure-region est la région Azure où le modèle est déployé (par exemple, eastus2).
• En fonction de vos préférences de modèle de déploiement et d’authentification, vous aurez besoin d’une clé pour vous authentifier auprès du service ou des informations d’identification Microsoft Entra ID. La clé est une chaîne de 32 caractères.

Une fois ces prérequis remplis, installez la bibliothèque d’inférence Azure AI avec la commande suivante :

dotnet add package Azure.AI.Inference --prerelease

Vous pouvez également vous authentifier avec Microsoft Entra ID (anciennement Azure Active Directory). Pour utiliser les fournisseurs d’informations d’identification fournis avec le kit de développement logiciel (SDK) Azure, installez le package Azure.Identity:

dotnet add package Azure.Identity

Importez les espaces de noms suivants :

using Azure;
using Azure.Identity;
using Azure.AI.Inference;

Cet exemple utilise également les espaces de noms suivants, mais vous n’en aurez peut-être pas toujours besoin :

using System.Text.Json;
using System.Text.Json.Serialization;
using System.Reflection;

Travailler avec des complétions de conversation

Dans cette section, vous utilisez l’API d’inférence de modèle Azure AI avec un modèle de complétion de conversation pour les conversations.

Conseil

L’API Inférence de modèle Azure AI vous permet de communiquer avec la plupart des modèles déployés dans Azure Machine Learning avec le même code et la même structure, y compris les modèles de conversation Cohere Command.

Créer un client pour consommer le modèle

Tout d’abord, créez le client pour consommer le modèle. Le code suivant utilise une URL de point de terminaison et une clé qui sont stockées dans les variables d’environnement.

ChatCompletionsClient client = new ChatCompletionsClient(
    new Uri(Environment.GetEnvironmentVariable("AZURE_INFERENCE_ENDPOINT")),
    new AzureKeyCredential(Environment.GetEnvironmentVariable("AZURE_INFERENCE_CREDENTIAL"))
);

Obtenir les fonctionnalités du modèle

L’itinéraire /info retourne des informations sur le modèle déployé sur le point de terminaison. Renvoyez les informations du modèle en appelant la méthode suivante :

Response<ModelInfo> modelInfo = client.GetModelInfo();

La réponse est comme suit :

Console.WriteLine($"Model name: {modelInfo.Value.ModelName}");
Console.WriteLine($"Model type: {modelInfo.Value.ModelType}");
Console.WriteLine($"Model provider name: {modelInfo.Value.ModelProviderName}");

Model name: Cohere-command-r-plus-08-2024
Model type: chat-completions
Model provider name: Cohere

Créer une requête de complétion de conversation

L’exemple suivant vous montre comment créer une requête de complétions de conversation de base sur le modèle.

ChatCompletionsOptions requestOptions = new ChatCompletionsOptions()
{
    Messages = {
        new ChatRequestSystemMessage("You are a helpful assistant."),
        new ChatRequestUserMessage("How many languages are in the world?")
    },
};

Response<ChatCompletions> response = client.Complete(requestOptions);

La réponse est la suivante, où vous pouvez voir les statistiques d’utilisation du modèle :

Console.WriteLine($"Response: {response.Value.Choices[0].Message.Content}");
Console.WriteLine($"Model: {response.Value.Model}");
Console.WriteLine("Usage:");
Console.WriteLine($"\tPrompt tokens: {response.Value.Usage.PromptTokens}");
Console.WriteLine($"\tTotal tokens: {response.Value.Usage.TotalTokens}");
Console.WriteLine($"\tCompletion tokens: {response.Value.Usage.CompletionTokens}");

Response: As of now, it's estimated that there are about 7,000 languages spoken around the world. However, this number can vary as some languages become extinct and new ones develop. It's also important to note that the number of speakers can greatly vary between languages, with some having millions of speakers and others only a few hundred.
Model: Cohere-command-r-plus-08-2024
Usage: 
  Prompt tokens: 19
  Total tokens: 91
  Completion tokens: 72

Examinez la section usage dans la réponse pour voir le nombre de jetons utilisés pour l’invite, le nombre total de jetons générés et le nombre de jetons utilisés pour la complétion.

Diffuser du contenu

Par défaut, l’API de complétion retourne l’intégralité du contenu généré dans une réponse unique. Si vous générez des complétions longues, l’attente de la réponse peut durer plusieurs secondes.

Vous pouvez diffuser en continu le contenu pour l’obtenir à mesure qu’il est généré. Diffuser le contenu en continu vous permet de commencer à traiter la complétion à mesure que le contenu devient disponible. Ce mode renvoie un objet qui diffuse la réponse en tant qu’événements envoyés par le serveur contenant uniquement des données. Extrayez les blocs du champ delta, plutôt que le champ de message.

static async Task StreamMessageAsync(ChatCompletionsClient client)
{
    ChatCompletionsOptions requestOptions = new ChatCompletionsOptions()
    {
        Messages = {
            new ChatRequestSystemMessage("You are a helpful assistant."),
            new ChatRequestUserMessage("How many languages are in the world? Write an essay about it.")
        },
        MaxTokens=4096
    };

    StreamingResponse<StreamingChatCompletionsUpdate> streamResponse = await client.CompleteStreamingAsync(requestOptions);

    await PrintStream(streamResponse);
}

Pour diffuser en continu des complétions, utilisez la méthode CompleteStreamingAsync lorsque vous appelez le modèle. Notez que dans cet exemple, l’appel est encapsulé dans une méthode asynchrone.

Pour visualiser la sortie, définissez une méthode asynchrone pour imprimer le flux dans la console.

static async Task PrintStream(StreamingResponse<StreamingChatCompletionsUpdate> response)
{
    await foreach (StreamingChatCompletionsUpdate chatUpdate in response)
    {
        if (chatUpdate.Role.HasValue)
        {
            Console.Write($"{chatUpdate.Role.Value.ToString().ToUpperInvariant()}: ");
        }
        if (!string.IsNullOrEmpty(chatUpdate.ContentUpdate))
        {
            Console.Write(chatUpdate.ContentUpdate);
        }
    }
}

Vous pouvez visualiser la façon dont la diffusion en continu génère du contenu :

StreamMessageAsync(client).GetAwaiter().GetResult();

Découvrir d’autres paramètres pris en charge par le client d’inférence

Explorez d’autres paramètres que vous pouvez spécifier dans le client d’inférence. Pour obtenir la liste complète de tous les paramètres pris en charge et de leur documentation correspondante, consultez la référence de l'API d'inférence des modèles Azure AI.

requestOptions = new ChatCompletionsOptions()
{
    Messages = {
        new ChatRequestSystemMessage("You are a helpful assistant."),
        new ChatRequestUserMessage("How many languages are in the world?")
    },
    PresencePenalty = 0.1f,
    FrequencyPenalty = 0.8f,
    MaxTokens = 2048,
    StopSequences = { "<|endoftext|>" },
    Temperature = 0,
    NucleusSamplingFactor = 1,
    ResponseFormat = new ChatCompletionsResponseFormatText()
};

response = client.Complete(requestOptions);
Console.WriteLine($"Response: {response.Value.Choices[0].Message.Content}");

Si vous souhaitez passer un paramètre qui ne figure pas dans la liste des paramètres pris en charge, vous pouvez le transmettre au modèle sous-jacent en utilisant des paramètres supplémentaires. Consulter Transmettre des paramètres supplémentaires au modèle.

Créer des sorties JSON

Les modèles de conversation Cohere Command peuvent créer des sorties JSON. Définissez response_format sur json_object pour activer le mode JSON et garantir que le message généré par le modèle est en JSON valide. Vous devez également vous-même demander au modèle de produire du JSON via un message système ou utilisateur. En outre, le contenu du message peut être partiellement coupé si finish_reason="length", ce qui indique que la génération a dépassé max_tokens ou que la conversation a dépassé la longueur maximale du contexte.

requestOptions = new ChatCompletionsOptions()
{
    Messages = {
        new ChatRequestSystemMessage(
            "You are a helpful assistant that always generate responses in JSON format, " +
            "using. the following format: { \"answer\": \"response\" }."
        ),
        new ChatRequestUserMessage(
            "How many languages are in the world?"
        )
    },
    ResponseFormat = new ChatCompletionsResponseFormatJSON()
};

response = client.Complete(requestOptions);
Console.WriteLine($"Response: {response.Value.Choices[0].Message.Content}");

Transmettre des paramètres supplémentaires au modèle

L'API d'inférence du modèle Azure AI vous permet de transmettre des paramètres supplémentaires au modèle. L’exemple de code suivant montre comment transmettre le paramètre supplémentaire logprobs au modèle.

Avant de transmettre des paramètres supplémentaires à l’API Inférence de modèle Azure AI, assurez-vous que votre modèle prend en charge ces paramètres supplémentaires. Lorsque la requête est adressée au modèle sous-jacent, l’en-tête extra-parameters est transmis au modèle avec la valeur pass-through. Cette valeur indique au point de terminaison de transmettre les paramètres supplémentaires au modèle. L’utilisation de paramètres supplémentaires avec le modèle ne garantit pas que le modèle peut réellement les gérer. Lisez la documentation du modèle pour comprendre quels paramètres supplémentaires sont pris en charge.

requestOptions = new ChatCompletionsOptions()
{
    Messages = {
        new ChatRequestSystemMessage("You are a helpful assistant."),
        new ChatRequestUserMessage("How many languages are in the world?")
    },
    AdditionalProperties = { { "logprobs", BinaryData.FromString("true") } },
};

response = client.Complete(requestOptions, extraParams: ExtraParameters.PassThrough);
Console.WriteLine($"Response: {response.Value.Choices[0].Message.Content}");

Utiliser des outils

Les modèles de conversation Cohere Command prennent en charge l’utilisation d’outils, qui peuvent être une ressource extraordinaire lorsque vous devez décharger des tâches spécifiques du modèle de langage et vous appuyer à la place sur un système plus déterministe ou même un modèle de langage différent. L'API Inférence de modèle Azure AI vous permet de définir des outils de la manière suivante.

L’exemple de code suivant crée une définition d’outil capable d’examiner les informations de vol de deux villes différentes.

FunctionDefinition flightInfoFunction = new FunctionDefinition("getFlightInfo")
{
    Description = "Returns information about the next flight between two cities. This includes the name of the airline, flight number and the date and time of the next flight",
    Parameters = BinaryData.FromObjectAsJson(new
    {
        Type = "object",
        Properties = new
        {
            origin_city = new
            {
                Type = "string",
                Description = "The name of the city where the flight originates"
            },
            destination_city = new
            {
                Type = "string",
                Description = "The flight destination city"
            }
        }
    },
        new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase }
    )
};

ChatCompletionsFunctionToolDefinition getFlightTool = new ChatCompletionsFunctionToolDefinition(flightInfoFunction);

Dans cet exemple, la sortie de la fonction est qu’il n’existe aucun vol disponible pour l’itinéraire sélectionné, mais que l’utilisateur doit envisager de prendre un train.

static string getFlightInfo(string loc_origin, string loc_destination)
{
    return JsonSerializer.Serialize(new
    {
        info = $"There are no flights available from {loc_origin} to {loc_destination}. You " +
        "should take a train, specially if it helps to reduce CO2 emissions."
    });
}

Remarque

Cohere-command-r-plus-08-2024, Cohere-command-r-08-2024, Cohere-command-r-plus, et Cohere-command-r nécessitent que les réponses d’un outil soient un contenu JSON valide formaté sous forme de chaîne. Lors de la construction de messages de type Outil, vérifiez que la réponse est une chaîne JSON valide.

Demandez au modèle de réserver des vols à l’aide de cette fonction :

var chatHistory = new List<ChatRequestMessage>(){
        new ChatRequestSystemMessage(
            "You are a helpful assistant that help users to find information about traveling, " +
            "how to get to places and the different transportations options. You care about the" +
            "environment and you always have that in mind when answering inqueries."
        ),
        new ChatRequestUserMessage("When is the next flight from Miami to Seattle?")
    };

requestOptions = new ChatCompletionsOptions(chatHistory);
requestOptions.Tools.Add(getFlightTool);
requestOptions.ToolChoice = ChatCompletionsToolChoice.Auto;

response = client.Complete(requestOptions);

Vous pouvez inspecter la réponse pour savoir si un outil doit être appelé. Inspectez le motif de fin pour déterminer si l’outil doit être appelé. N’oubliez pas que plusieurs types d’outils peuvent être indiqués. Cet exemple illustre un outil de type function.

var responseMenssage = response.Value.Choices[0].Message;
var toolsCall = responseMenssage.ToolCalls;

Console.WriteLine($"Finish reason: {response.Value.Choices[0].FinishReason}");
Console.WriteLine($"Tool call: {toolsCall[0].Id}");

Pour continuer, ajoutez ce message à l’historique des conversations :

requestOptions.Messages.Add(new ChatRequestAssistantMessage(response.Value.Choices[0].Message));

À présent, il est temps d’appeler la fonction appropriée pour gérer l’appel d’outil. L’extrait de code suivant itère sur tous les appels d’outil indiqués dans la réponse et appelle la fonction correspondante avec les paramètres appropriés. La réponse est également ajoutée à l’historique des conversations.

foreach (ChatCompletionsToolCall tool in toolsCall)
{
    if (tool is ChatCompletionsFunctionToolCall functionTool)
    {
        // Get the tool details:
        string callId = functionTool.Id;
        string toolName = functionTool.Name;
        string toolArgumentsString = functionTool.Arguments;
        Dictionary<string, object> toolArguments = JsonSerializer.Deserialize<Dictionary<string, object>>(toolArgumentsString);

        // Here you have to call the function defined. In this particular example we use 
        // reflection to find the method we definied before in an static class called 
        // `ChatCompletionsExamples`. Using reflection allows us to call a function 
        // by string name. Notice that this is just done for demonstration purposes as a 
        // simple way to get the function callable from its string name. Then we can call 
        // it with the corresponding arguments.

        var flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static;
        string toolResponse = (string)typeof(ChatCompletionsExamples).GetMethod(toolName, flags).Invoke(null, toolArguments.Values.Cast<object>().ToArray());

        Console.WriteLine("->", toolResponse);
        requestOptions.Messages.Add(new ChatRequestToolMessage(toolResponse, callId));
    }
    else
        throw new Exception("Unsupported tool type");
}

Voir la réponse du modèle :

response = client.Complete(requestOptions);

Appliquer la sécurité du contenu

L’API Inférence de modèle Azure AI prend en charge Azure AI Sécurité du Contenu. Lorsque vous utilisez des déploiements avec la sécurité du contenu Azure AI activée, les entrées et les sorties passent par un ensemble de modèles de classification visant à détecter et à empêcher la sortie de contenu dangereux. Le système de filtrage de contenu (préversion) détecte et prend des mesures sur des catégories spécifiques de contenu potentiellement dangereux dans les invites d’entrée et les exécutions de sortie.

L’exemple suivant montre comment gérer les évènements lorsque le modèle détecte du contenu dangereux dans l’invite d’entrée et que la sécurité du contenu est activée.

try
{
    requestOptions = new ChatCompletionsOptions()
    {
        Messages = {
            new ChatRequestSystemMessage("You are an AI assistant that helps people find information."),
            new ChatRequestUserMessage(
                "Chopping tomatoes and cutting them into cubes or wedges are great ways to practice your knife skills."
            ),
        },
    };

    response = client.Complete(requestOptions);
    Console.WriteLine(response.Value.Choices[0].Message.Content);
}
catch (RequestFailedException ex)
{
    if (ex.ErrorCode == "content_filter")
    {
        Console.WriteLine($"Your query has trigger Azure Content Safety: {ex.Message}");
    }
    else
    {
        throw;
    }
}

Conseil

Pour en savoir plus sur la façon dont vous pouvez configurer et contrôler les paramètres de sécurité du contenu Azure AI, consultez la documentation Azure AI Sécurité du Contenu.

Modèles de conversation Cohere Command

Les modèles de conversation Cohere Command incluent les modèles suivants :

Cohere Command R+ 08-2024

Command R+ 08-2024 est un grand modèle de langage génératif optimisé pour divers cas d’utilisation, notamment pour le raisonnement, les résumés et les réponses aux questions.

• Architecture du modèle : Command R+ 08-2024 est un modèle de langage autorégressif qui utilise une architecture de transformateur optimisée. Après le pré-entraînement, le modèle utilise le réglage fin supervisé (SFT) et l’entraînement aux préférences pour aligner le comportement du modèle sur les préférences humaines, dans un souci de convivialité et de sécurité.
• Langues couvertes : le mode est optimisé pour être performant dans les langues suivantes : anglais, français, espagnol, italien, allemand, portugais du Brésil, japonais, coréen, chinois simplifié et arabe.
• Les données de préapprentissage incluent également les 13 langues suivantes : russe, polonais, turc, vietnamien, néerlandais, tchèque, indonésien, ukrainien, roumain, grec, hindi, hébreu et persan.
• Longueur du contexte : Command R+ 08-2024 prend en charge une longueur de contexte de 128 K.
• Entrée : texte uniquement.
• Sortie : texte uniquement.

Nous recommandons d’utiliser Command R+ 08-2024 pour les flux de travail qui s’appuient sur des fonctionnalités de génération augmentée de récupération (RAG) complexes, sur l’utilisation d’outils en plusieurs étapes (agents) et sur des sorties structurées.

Les modèles suivants sont disponibles :

• Cohere-command-r-plus-08-2024

Cohere Command R 08-2024

Command R 08-2024 est un grand modèle de langage optimisé pour divers cas d’utilisation, notamment pour le raisonnement, les résumés et les réponses aux questions.

• Architecture du modèle : Commande R 08-2024 est un modèle de langage autorégressif qui utilise une architecture de transformateur optimisée. Après le pré-entraînement, le modèle utilise le réglage fin supervisé (SFT) et l’entraînement aux préférences pour aligner le comportement du modèle sur les préférences humaines, dans un souci de convivialité et de sécurité.
• Langues couvertes : le modèle est optimisé pour être performant dans les langues suivantes : anglais, français, espagnol, italien, allemand, portugais du Brésil, japonais, coréen, chinois simplifié et arabe.
• Les données de préapprentissage incluent également les 13 langues suivantes : russe, polonais, turc, vietnamien, néerlandais, tchèque, indonésien, ukrainien, roumain, grec, hindi, hébreu et persan.
• Longueur du contexte : Command R 08-2024 prend en charge une longueur de contexte de 128 K.
• Entrée : texte uniquement.
• Sortie : texte uniquement.

Les modèles suivants sont disponibles :

• Cohere-command-r-08-2024

Cohere Command R+

Command R+ est un grand modèle de langage génératif optimisé pour différents cas d’usage, notamment le raisonnement, le résumé et la réponse aux questions.

• Architecture du modèle : Command R+ est un modèle de langage autorégressif qui utilise une architecture de transformateur optimisée. Après le pré-entraînement, le modèle utilise le réglage fin supervisé (SFT) et l’entraînement aux préférences pour aligner le comportement du modèle sur les préférences humaines, dans un souci de convivialité et de sécurité.
• Langues couvertes : le modèle est optimisé pour être performant dans les langues suivantes : anglais, français, espagnol, italien, allemand, portugais du Brésil, japonais, coréen, chinois simplifié et arabe.
• Les données de préapprentissage incluent également les 13 langues suivantes : russe, polonais, turc, vietnamien, néerlandais, tchèque, indonésien, ukrainien, roumain, grec, hindi, hébreu et persan.
• Longueur du contexte : Command R+ prend en charge une longueur de contexte de 128 K.
• Entrée : texte uniquement.
• Sortie : texte uniquement.

Nous vous recommandons d’utiliser Command R+ pour les flux de travail qui s’appuient sur une fonctionnalité de génération augmentée par récupération (RAG) complexe et l’utilisation d’outils à plusieurs étapes (agents).

Les modèles suivants sont disponibles :

• Cohere-command-r-plus

Cohere Command R

Command R+ est un grand modèle de langage optimisé pour différents cas d’usage, notamment le raisonnement, le résumé et la réponse aux questions.

• Architecture du modèle : Command R est un modèle de langage autorégressif qui utilise une architecture de transformateur optimisée. Après le pré-entraînement, le modèle utilise le réglage fin supervisé (SFT) et l’entraînement aux préférences pour aligner le comportement du modèle sur les préférences humaines, dans un souci de convivialité et de sécurité.
• Langues couvertes : le modèle est optimisé pour être performant dans les langues suivantes : anglais, français, espagnol, italien, allemand, portugais du Brésil, japonais, coréen, chinois simplifié et arabe.
• Les données de préapprentissage incluent également les 13 langues suivantes : russe, polonais, turc, vietnamien, néerlandais, tchèque, indonésien, ukrainien, roumain, grec, hindi, hébreu et persan.
• Longueur du contexte : Command R prend en charge une longueur de contexte de 128 K.

Command R est idéal pour une génération augmentée par récupération (RAG) plus simple et les tâches d’utilisation par outil à étape unique. Il est également idéal pour une utilisation dans les applications où le prix est un facteur important.

Les modèles suivants sont disponibles :

• Cohere-command-r

Conseil

En outre, Cohere prend en charge l’utilisation d’une API personnalisée à utiliser avec des fonctionnalités spécifiques du modèle. Pour utiliser l’API spécifique du fournisseur de modèles, consultez la Documentation Cohere ou la section exemples d’inférence pour obtenir des exemples de code.

Prérequis

Pour utiliser les modèles de conversation Cohere Command avec Azure Machine Learning, vous avez besoin des prérequis suivants :

Un modèle de déploiement

Déploiement sur des API serverless

Les modèles de conversation Cohere Command peuvent être déployés sur des points de terminaison d’API serverless avec facturation en paiement à l’utilisation. Ce type de déploiement permet de consommer des modèles en tant qu’API sans les héberger sur votre abonnement, tout en conservant la sécurité et la conformité de l’entreprise dont les organisations ont besoin.

Le déploiement vers un point de terminaison API serverless ne nécessite pas de quota de votre abonnement. Si votre modèle n’est pas déjà déployé, utilisez Azure Machine Learning studio, le kit de développement logiciel (SDK) Azure Machine Learning pour Python, l’interface de ligne de commande Azure ou les modèles ARM pour déployer le modèle en tant qu’API serverless.

Déployer le modèle sur des points de terminaison API sans serveur

Un client REST

Les modèles déployés avec l’API Inférence de modèle Azure AI peuvent être consommés en utilisant tout client REST. Pour utiliser le client REST, vous avez besoin des prérequis suivants :

• Pour construire les requêtes, vous devez transmettre l’URL du point de terminaison. L’URL du point de terminaison a la forme https://your-host-name.your-azure-region.inference.ai.azure.com, où your-host-name`` is your unique model deployment host name and votre-région-azure`` est la région Azure où le modèle est déployé (par exemple, eastus2).
• En fonction de vos préférences de modèle de déploiement et d’authentification, vous aurez besoin d’une clé pour vous authentifier auprès du service ou des informations d’identification Microsoft Entra ID. La clé est une chaîne de 32 caractères.

Travailler avec des complétions de conversation

Dans cette section, vous utilisez l’API d’inférence de modèle Azure AI avec un modèle de complétion de conversation pour les conversations.

Conseil

L’API Inférence de modèle Azure AI vous permet de communiquer avec la plupart des modèles déployés dans Azure Machine Learning avec le même code et la même structure, y compris les modèles de conversation Cohere Command.

Créer un client pour consommer le modèle

Tout d’abord, créez le client pour consommer le modèle. Le code suivant utilise une URL de point de terminaison et une clé qui sont stockées dans les variables d’environnement.

Obtenir les fonctionnalités du modèle

L’itinéraire /info retourne des informations sur le modèle déployé sur le point de terminaison. Renvoyez les informations du modèle en appelant la méthode suivante :

GET /info HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json

La réponse est comme suit :

{
    "model_name": "Cohere-command-r-plus-08-2024",
    "model_type": "chat-completions",
    "model_provider_name": "Cohere"
}

Créer une requête de complétion de conversation

L’exemple suivant vous montre comment créer une requête de complétions de conversation de base sur le modèle.

{
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": "How many languages are in the world?"
        }
    ]
}

La réponse est la suivante, où vous pouvez voir les statistiques d’utilisation du modèle :

{
    "id": "0a1234b5de6789f01gh2i345j6789klm",
    "object": "chat.completion",
    "created": 1718726686,
    "model": "Cohere-command-r-plus-08-2024",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "As of now, it's estimated that there are about 7,000 languages spoken around the world. However, this number can vary as some languages become extinct and new ones develop. It's also important to note that the number of speakers can greatly vary between languages, with some having millions of speakers and others only a few hundred.",
                "tool_calls": null
            },
            "finish_reason": "stop",
            "logprobs": null
        }
    ],
    "usage": {
        "prompt_tokens": 19,
        "total_tokens": 91,
        "completion_tokens": 72
    }
}

Examinez la section usage dans la réponse pour voir le nombre de jetons utilisés pour l’invite, le nombre total de jetons générés et le nombre de jetons utilisés pour la complétion.

Diffuser du contenu

Par défaut, l’API de complétion retourne l’intégralité du contenu généré dans une réponse unique. Si vous générez des complétions longues, l’attente de la réponse peut durer plusieurs secondes.

Vous pouvez diffuser en continu le contenu pour l’obtenir à mesure qu’il est généré. Diffuser le contenu en continu vous permet de commencer à traiter la complétion à mesure que le contenu devient disponible. Ce mode renvoie un objet qui diffuse la réponse en tant qu’événements envoyés par le serveur contenant uniquement des données. Extrayez les blocs du champ delta, plutôt que le champ de message.

{
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": "How many languages are in the world?"
        }
    ],
    "stream": true,
    "temperature": 0,
    "top_p": 1,
    "max_tokens": 2048
}

Vous pouvez visualiser la façon dont la diffusion en continu génère du contenu :

{
    "id": "23b54589eba14564ad8a2e6978775a39",
    "object": "chat.completion.chunk",
    "created": 1718726371,
    "model": "Cohere-command-r-plus-08-2024",
    "choices": [
        {
            "index": 0,
            "delta": {
                "role": "assistant",
                "content": ""
            },
            "finish_reason": null,
            "logprobs": null
        }
    ]
}

Le dernier message dans le flux a finish_reason défini, indiquant la raison de l’arrêt du processus de génération.

{
    "id": "23b54589eba14564ad8a2e6978775a39",
    "object": "chat.completion.chunk",
    "created": 1718726371,
    "model": "Cohere-command-r-plus-08-2024",
    "choices": [
        {
            "index": 0,
            "delta": {
                "content": ""
            },
            "finish_reason": "stop",
            "logprobs": null
        }
    ],
    "usage": {
        "prompt_tokens": 19,
        "total_tokens": 91,
        "completion_tokens": 72
    }
}

Découvrir d’autres paramètres pris en charge par le client d’inférence

Explorez d’autres paramètres que vous pouvez spécifier dans le client d’inférence. Pour obtenir la liste complète de tous les paramètres pris en charge et de leur documentation correspondante, consultez la référence de l'API d'inférence des modèles Azure AI.

{
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": "How many languages are in the world?"
        }
    ],
    "presence_penalty": 0.1,
    "frequency_penalty": 0.8,
    "max_tokens": 2048,
    "stop": ["<|endoftext|>"],
    "temperature" :0,
    "top_p": 1,
    "response_format": { "type": "text" }
}

{
    "id": "0a1234b5de6789f01gh2i345j6789klm",
    "object": "chat.completion",
    "created": 1718726686,
    "model": "Cohere-command-r-plus-08-2024",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "As of now, it's estimated that there are about 7,000 languages spoken around the world. However, this number can vary as some languages become extinct and new ones develop. It's also important to note that the number of speakers can greatly vary between languages, with some having millions of speakers and others only a few hundred.",
                "tool_calls": null
            },
            "finish_reason": "stop",
            "logprobs": null
        }
    ],
    "usage": {
        "prompt_tokens": 19,
        "total_tokens": 91,
        "completion_tokens": 72
    }
}

Si vous souhaitez passer un paramètre qui ne figure pas dans la liste des paramètres pris en charge, vous pouvez le transmettre au modèle sous-jacent en utilisant des paramètres supplémentaires. Consulter Transmettre des paramètres supplémentaires au modèle.

Créer des sorties JSON

Les modèles de conversation Cohere Command peuvent créer des sorties JSON. Définissez response_format sur json_object pour activer le mode JSON et garantir que le message généré par le modèle est en JSON valide. Vous devez également vous-même demander au modèle de produire du JSON via un message système ou utilisateur. En outre, le contenu du message peut être partiellement coupé si finish_reason="length", ce qui indique que la génération a dépassé max_tokens ou que la conversation a dépassé la longueur maximale du contexte.

{
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant that always generate responses in JSON format, using the following format: { \"answer\": \"response\" }"
        },
        {
            "role": "user",
            "content": "How many languages are in the world?"
        }
    ],
    "response_format": { "type": "json_object" }
}

{
    "id": "0a1234b5de6789f01gh2i345j6789klm",
    "object": "chat.completion",
    "created": 1718727522,
    "model": "Cohere-command-r-plus-08-2024",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "{\"answer\": \"There are approximately 7,117 living languages in the world today, according to the latest estimates. However, this number can vary as some languages become extinct and others are newly discovered or classified.\"}",
                "tool_calls": null
            },
            "finish_reason": "stop",
            "logprobs": null
        }
    ],
    "usage": {
        "prompt_tokens": 39,
        "total_tokens": 87,
        "completion_tokens": 48
    }
}

Transmettre des paramètres supplémentaires au modèle

L'API d'inférence du modèle Azure AI vous permet de transmettre des paramètres supplémentaires au modèle. L’exemple de code suivant montre comment transmettre le paramètre supplémentaire logprobs au modèle.

Avant de transmettre des paramètres supplémentaires à l’API Inférence de modèle Azure AI, assurez-vous que votre modèle prend en charge ces paramètres supplémentaires. Lorsque la requête est adressée au modèle sous-jacent, l’en-tête extra-parameters est transmis au modèle avec la valeur pass-through. Cette valeur indique au point de terminaison de transmettre les paramètres supplémentaires au modèle. L’utilisation de paramètres supplémentaires avec le modèle ne garantit pas que le modèle peut réellement les gérer. Lisez la documentation du modèle pour comprendre quels paramètres supplémentaires sont pris en charge.

POST /chat/completions HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json
extra-parameters: pass-through

{
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": "How many languages are in the world?"
        }
    ],
    "logprobs": true
}

Utiliser des outils

Les modèles de conversation Cohere Command prennent en charge l’utilisation d’outils, qui peuvent être une ressource extraordinaire lorsque vous devez décharger des tâches spécifiques du modèle de langage et vous appuyer à la place sur un système plus déterministe ou même un modèle de langage différent. L'API Inférence de modèle Azure AI vous permet de définir des outils de la manière suivante.

L’exemple de code suivant crée une définition d’outil capable de rechercher des informations sur les vols à partir de deux villes différentes.

{
    "type": "function",
    "function": {
        "name": "get_flight_info",
        "description": "Returns information about the next flight between two cities. This includes the name of the airline, flight number and the date and time of the next flight",
        "parameters": {
            "type": "object",
            "properties": {
                "origin_city": {
                    "type": "string",
                    "description": "The name of the city where the flight originates"
                },
                "destination_city": {
                    "type": "string",
                    "description": "The flight destination city"
                }
            },
            "required": [
                "origin_city",
                "destination_city"
            ]
        }
    }
}

Dans cet exemple, la sortie de la fonction est qu’il n’existe aucun vol disponible pour l’itinéraire sélectionné, mais que l’utilisateur doit envisager de prendre un train.

Remarque

Cohere-command-r-plus-08-2024, Cohere-command-r-08-2024, Cohere-command-r-plus, et Cohere-command-r nécessitent que les réponses d’un outil soient un contenu JSON valide formaté sous forme de chaîne. Lors de la construction de messages de type Outil, vérifiez que la réponse est une chaîne JSON valide.

Demandez au modèle de réserver des vols à l’aide de cette fonction :

{
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant that help users to find information about traveling, how to get to places and the different transportations options. You care about the environment and you always have that in mind when answering inqueries"
        },
        {
            "role": "user",
            "content": "When is the next flight from Miami to Seattle?"
        }
    ],
    "tool_choice": "auto",
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "get_flight_info",
                "description": "Returns information about the next flight between two cities. This includes the name of the airline, flight number and the date and time of the next flight",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "origin_city": {
                            "type": "string",
                            "description": "The name of the city where the flight originates"
                        },
                        "destination_city": {
                            "type": "string",
                            "description": "The flight destination city"
                        }
                    },
                    "required": [
                        "origin_city",
                        "destination_city"
                    ]
                }
            }
        }
    ]
}

Vous pouvez inspecter la réponse pour savoir si un outil doit être appelé. Inspectez le motif de fin pour déterminer si l’outil doit être appelé. N’oubliez pas que plusieurs types d’outils peuvent être indiqués. Cet exemple illustre un outil de type function.

{
    "id": "0a1234b5de6789f01gh2i345j6789klm",
    "object": "chat.completion",
    "created": 1718726007,
    "model": "Cohere-command-r-plus-08-2024",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "",
                "tool_calls": [
                    {
                        "id": "abc0dF1gh",
                        "type": "function",
                        "function": {
                            "name": "get_flight_info",
                            "arguments": "{\"origin_city\": \"Miami\", \"destination_city\": \"Seattle\"}",
                            "call_id": null
                        }
                    }
                ]
            },
            "finish_reason": "tool_calls",
            "logprobs": null
        }
    ],
    "usage": {
        "prompt_tokens": 190,
        "total_tokens": 226,
        "completion_tokens": 36
    }
}

Pour continuer, ajoutez ce message à l’historique des conversations :

À présent, il est temps d’appeler la fonction appropriée pour gérer l’appel d’outil. L’extrait de code suivant itère sur tous les appels d’outil indiqués dans la réponse et appelle la fonction correspondante avec les paramètres appropriés. La réponse est également ajoutée à l’historique des conversations.

Voir la réponse du modèle :

{
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant that help users to find information about traveling, how to get to places and the different transportations options. You care about the environment and you always have that in mind when answering inqueries"
        },
        {
            "role": "user",
            "content": "When is the next flight from Miami to Seattle?"
        },
        {
            "role": "assistant",
            "content": "",
            "tool_calls": [
                {
                    "id": "abc0DeFgH",
                    "type": "function",
                    "function": {
                        "name": "get_flight_info",
                        "arguments": "{\"origin_city\": \"Miami\", \"destination_city\": \"Seattle\"}",
                        "call_id": null
                    }
                }
            ]
        },
        {
            "role": "tool",
            "content": "{ \"info\": \"There are no flights available from Miami to Seattle. You should take a train, specially if it helps to reduce CO2 emissions.\" }",
            "tool_call_id": "abc0DeFgH" 
        }
    ],
    "tool_choice": "auto",
    "tools": [
        {
            "type": "function",
            "function": {
            "name": "get_flight_info",
            "description": "Returns information about the next flight between two cities. This includes the name of the airline, flight number and the date and time of the next flight",
            "parameters":{
                "type": "object",
                "properties": {
                    "origin_city": {
                        "type": "string",
                        "description": "The name of the city where the flight originates"
                    },
                    "destination_city": {
                        "type": "string",
                        "description": "The flight destination city"
                    }
                },
                "required": ["origin_city", "destination_city"]
            }
            }
        }
    ]
}

Appliquer la sécurité du contenu

L’API Inférence de modèle Azure AI prend en charge Azure AI Sécurité du Contenu. Lorsque vous utilisez des déploiements avec la sécurité du contenu Azure AI activée, les entrées et les sorties passent par un ensemble de modèles de classification visant à détecter et à empêcher la sortie de contenu dangereux. Le système de filtrage de contenu (préversion) détecte et prend des mesures sur des catégories spécifiques de contenu potentiellement dangereux dans les invites d’entrée et les exécutions de sortie.

L’exemple suivant montre comment gérer les évènements lorsque le modèle détecte du contenu dangereux dans l’invite d’entrée et que la sécurité du contenu est activée.

{
    "messages": [
        {
            "role": "system",
            "content": "You are an AI assistant that helps people find information."
        },
                {
            "role": "user",
            "content": "Chopping tomatoes and cutting them into cubes or wedges are great ways to practice your knife skills."
        }
    ]
}

{
    "error": {
        "message": "The response was filtered due to the prompt triggering Microsoft's content management policy. Please modify your prompt and retry.",
        "type": null,
        "param": "prompt",
        "code": "content_filter",
        "status": 400
    }
}

Conseil

Pour en savoir plus sur la façon dont vous pouvez configurer et contrôler les paramètres de sécurité du contenu Azure AI, consultez la Documentation Azure AI Sécurité du Contenu.

Autres exemples d’inférence

Pour plus d’exemples sur l’utilisation des modèles Cohere, consultez les exemples et tutoriels suivants :

Description	Langage	Exemple
Requêtes web	Bash	Command-R - Command-R+
Package Azure AI Inference pour JavaScript	JavaScript	Lien
Package Azure AI Inference pour Python	Python	Lien
Kit de développement logiciel (SDK) OpenAI (expérimental)	Python	Lien
LangChain	Python	Lien
Kit de développement logiciel (SDK) Cohere	Python	Lien
LiteLLM SDK	Python	Lien

Génération augmentée de récupération (RAG) et exemples d’utilisation d’outils

Description	Paquets	Exemple
Créer un index vectoriel de recherche de similarité Facebook IA (FAISS) local à l’aide d’incorporations Cohere - Langchain	langchain, langchain_cohere	cohere_faiss_langchain_embed.ipynb
Utiliser Cohere Command R/R+ pour répondre aux questions des données dans l’index vectoriel FAISS local - Langchain	langchain, langchain_cohere	command_faiss_langchain.ipynb
Utiliser Cohere Command R/R+ pour répondre aux questions des données dans l’index vectoriel de recherche IA - Langchain	langchain, langchain_cohere	cohere-aisearch-langchain-rag.ipynb
Utiliser Cohere Command R/R+ pour répondre aux questions des données dans l’index vectoriel de recherche IA - Kit de développement logiciel (SDK) Cohere	cohere, azure_search_documents	cohere-aisearch-rag.ipynb
Outil/appel de fonction commande R+, à l’aide de LangChain	cohere, langchain, langchain_cohere	command_tools-langchain.ipynb

Considérations relatives aux coûts et aux quotas pour les modèles Cohere déployés en tant que points de terminaison d’API serverless

Le quota est géré par déploiement. Chaque déploiement a une limite de débit de 200 000 jetons par minute et 1 000 requêtes d’API par minute. Toutefois, nous limitons actuellement un déploiement par modèle par projet. Contactez le Support Microsoft Azure si les limites de débit actuelles ne suffisent pas pour vos scénarios.

Les modèles Cohere déployés en tant qu’API serverless sont proposés par Cohere via la Place de marché Azure et intégrés à Azure Machine Learning studio pour être utilisés. Vous trouverez la tarification de la Place de marché Azure lors du déploiement du modèle.

Chaque fois qu’un projet s’abonne à une offre donnée à partir de la Place de marché Azure, une nouvelle ressource est créée pour suivre les coûts associés à sa consommation. La même ressource est utilisée pour suivre les coûts associés à l’inférence; plusieurs compteurs sont cependant disponibles pour suivre chaque scénario indépendamment.

Pour plus d’informations sur le suivi des coûts, consultez Surveiller les coûts des modèles proposés via la Place de marché Azure.

Contenu connexe

• API Inférence de modèle Azure AI
• Déployer des modèles en tant que des API sans serveur
• Disponibilité des régions pour les modèles dans les points de terminaison d’API serverless
• Planifier et gérer les coûts d’Azure AI Studio