Liaison d’entrée d’incorporation Azure OpenAI pour Azure Functions

Article
05/21/2024

Important

L’extension Azure OpenAI pour Azure Functions est actuellement en préversion.

La liaison d’entrée d’incorporation Azure OpenAI vous permet de générer des incorporations pour les entrées. La liaison peut générer des incorporations à partir de fichiers ou d’entrées de texte brut.

Pour plus d’informations sur l’installation et la configuration de l’extension Azure OpenAI, consultez Extensions Azure OpenAI pour Azure Functions. Pour en savoir plus sur les incorporations dans Azure OpenAI Service, consultez Comprendre les incorporations dans Azure OpenAI Service.

Remarque

Les références et les exemples sont fournis uniquement pour le modèle Node.js v4.

Remarque

Les références et exemples sont fournis uniquement pour le modèle Python v2.

Remarque

Bien que les deux modèles de processus C# soient pris en charge, seuls les exemples de modèles worker isolés sont fournis.

Exemple

Cet exemple montre comment générer des incorporations pour une chaîne de texte brut.

[Function(nameof(GenerateEmbeddings_Http_RequestAsync))]
public async Task GenerateEmbeddings_Http_RequestAsync(
    [HttpTrigger(AuthorizationLevel.Function, "post", Route = "embeddings")] HttpRequestData req,
    [EmbeddingsInput("{RawText}", InputType.RawText, Model = "%EMBEDDING_MODEL_DEPLOYMENT_NAME%")] EmbeddingsContext embeddings)
{
    using StreamReader reader = new(req.Body);
    string request = await reader.ReadToEndAsync();

    EmbeddingsRequest? requestBody = JsonSerializer.Deserialize<EmbeddingsRequest>(request);

    this.logger.LogInformation(
        "Received {count} embedding(s) for input text containing {length} characters.",
        embeddings.Count,
        requestBody?.RawText?.Length);

    // TODO: Store the embeddings into a database or other storage.
}

Cet exemple montre comment récupérer des incorporations stockées dans un fichier spécifié accessible à la fonction.

[Function(nameof(GetEmbeddings_Http_FilePath))]
public async Task GetEmbeddings_Http_FilePath(
    [HttpTrigger(AuthorizationLevel.Function, "post", Route = "embeddings-from-file")] HttpRequestData req,
    [EmbeddingsInput("{FilePath}", InputType.FilePath, MaxChunkLength = 512, Model = "%EMBEDDING_MODEL_DEPLOYMENT_NAME%")] EmbeddingsContext embeddings)
{
    using StreamReader reader = new(req.Body);
    string request = await reader.ReadToEndAsync();

    EmbeddingsRequest? requestBody = JsonSerializer.Deserialize<EmbeddingsRequest>(request);
    this.logger.LogInformation(
        "Received {count} embedding(s) for input file '{path}'.",
        embeddings.Count,
        requestBody?.FilePath);

    // TODO: Store the embeddings into a database or other storage.
}

Cet exemple montre comment générer des incorporations pour une chaîne de texte brut.

@FunctionName("GenerateEmbeddingsHttpRequest")
public HttpResponseMessage generateEmbeddingsHttpRequest(
    @HttpTrigger(
        name = "req", 
        methods = {HttpMethod.POST},
        authLevel = AuthorizationLevel.ANONYMOUS,
        route = "embeddings")
    HttpRequestMessage<EmbeddingsRequest> request,
    @EmbeddingsInput(name = "Embeddings", input = "{RawText}", inputType = InputType.RawText, model = "%EMBEDDING_MODEL_DEPLOYMENT_NAME%") String embeddingsContext,
    final ExecutionContext context) {

    if (request.getBody() == null)
    {
        throw new IllegalArgumentException("Invalid request body. Make sure that you pass in {\"rawText\": value } as the request body.");
    }

    JSONObject embeddingsContextJsonObject = new JSONObject(embeddingsContext);
    
    context.getLogger().info(String.format("Received %d embedding(s) for input text containing %s characters.",
            embeddingsContextJsonObject.getJSONObject("response")
                    .getJSONArray("data")
                    .getJSONObject(0)
                    .getJSONArray("embedding").length(),
            request.getBody().getRawText().length()));

    // TODO: Store the embeddings into a database or other storage.
    return request.createResponseBuilder(HttpStatus.ACCEPTED)
            .header("Content-Type", "application/json")
            .build();
}

Cet exemple montre comment récupérer des incorporations stockées dans un fichier spécifié accessible à la fonction.

@FunctionName("GenerateEmbeddingsHttpFilePath")
public HttpResponseMessage generateEmbeddingsHttpFilePath(
    @HttpTrigger(
        name = "req", 
        methods = {HttpMethod.POST},
        authLevel = AuthorizationLevel.ANONYMOUS,
        route = "embeddings-from-file")
    HttpRequestMessage<EmbeddingsRequest> request,
    @EmbeddingsInput(name = "Embeddings", input = "{FilePath}", inputType = InputType.FilePath, maxChunkLength = 512, model = "%EMBEDDING_MODEL_DEPLOYMENT_NAME%") String embeddingsContext,
    final ExecutionContext context) {

    if (request.getBody() == null)
    {
        throw new IllegalArgumentException("Invalid request body. Make sure that you pass in {\"rawText\": value } as the request body.");
    }

    JSONObject embeddingsContextJsonObject = new JSONObject(embeddingsContext);
    
    context.getLogger().info(String.format("Received %d embedding(s) for input file %s.",
            embeddingsContextJsonObject.getJSONObject("response")
                    .getJSONArray("data")
                    .getJSONObject(0)
                    .getJSONArray("embedding").length(),
            request.getBody().getFilePath()));

    // TODO: Store the embeddings into a database or other storage.
    return request.createResponseBuilder(HttpStatus.ACCEPTED)
            .header("Content-Type", "application/json")
            .build();
}

Les exemples ne sont pas encore disponibles.

Cet exemple montre comment générer des incorporations pour une chaîne de texte brut.

const embeddingsHttpInput = input.generic({
    input: '{RawText}',
    inputType: 'RawText',
    type: 'embeddings',
    model: '%EMBEDDING_MODEL_DEPLOYMENT_NAME%'
})

app.http('generateEmbeddings', {
    methods: ['POST'],
    route: 'embeddings',
    authLevel: 'function',
    extraInputs: [embeddingsHttpInput],
    handler: async (request, context) => {
        let requestBody: EmbeddingsHttpRequest = await request.json();
        let response: any = context.extraInputs.get(embeddingsHttpInput);

        context.log(
            `Received ${response.count} embedding(s) for input text containing ${requestBody.RawText.length} characters.`
        );
        
        // TODO: Store the embeddings into a database or other storage.

        return {status: 202}
    }
});

Cet exemple montre comment récupérer des incorporations stockées dans un fichier spécifié accessible à la fonction.

const embeddingsFilePathInput = input.generic({
    input: '{FilePath}',
    inputType: 'FilePath',
    type: 'embeddings',
    maxChunkLength: 512,
    model: '%EMBEDDING_MODEL_DEPLOYMENT_NAME%'
})

app.http('getEmbeddingsFilePath', {
    methods: ['POST'],
    route: 'embeddings-from-file',
    authLevel: 'function',
    extraInputs: [embeddingsFilePathInput],
    handler: async (request, context) => {
        let requestBody: EmbeddingsFilePath = await request.json();
        let response: any = context.extraInputs.get(embeddingsFilePathInput);

        context.log(
            `Received ${response.count} embedding(s) for input file ${requestBody.FilePath}.`
        );
        
        // TODO: Store the embeddings into a database or other storage.

        return {status: 202}
    }

Cet exemple montre comment générer des incorporations pour une chaîne de texte brut.

Voici le fichier function.json pour générer les incorporations :

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "route": "embeddings",
      "methods": [
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    },
    {
      "name": "Embeddings",
      "type": "embeddings",
      "direction": "in",
      "inputType": "RawText",
      "input": "{RawText}",
      "model": "%EMBEDDING_MODEL_DEPLOYMENT_NAME%"
    }
  ]
}

Pour plus d’informations sur les propriétés du fichier function.json, consultez la section Configuration.

using namespace System.Net

param($Request, $TriggerMetadata, $Embeddings)

$input = $Request.Body.RawText

Write-Host "Received $($Embeddings.Count) embedding(s) for input text containing $($input.Length) characters."

Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
        StatusCode = [HttpStatusCode]::Accepted
})

Cet exemple montre comment générer des incorporations pour une chaîne de texte brut.

@app.function_name("GenerateEmbeddingsHttpRequest")
@app.route(route="embeddings", methods=["POST"])
@app.embeddings_input(arg_name="embeddings", input="{rawText}", input_type="rawText", model="%EMBEDDING_MODEL_DEPLOYMENT_NAME%")
def generate_embeddings_http_request(req: func.HttpRequest, embeddings: str) -> func.HttpResponse:
    user_message = req.get_json()
    embeddings_json = json.loads(embeddings)
    embeddings_request = {
        "raw_text": user_message.get("RawText"),
        "file_path": user_message.get("FilePath")
    }
    logging.info(f'Received {embeddings_json.get("count")} embedding(s) for input text '
        f'containing {len(embeddings_request.get("raw_text"))} characters.')
    # TODO: Store the embeddings into a database or other storage.
    return func.HttpResponse(status_code=200)

Attributs

Appliquez l’attribut EmbeddingsInput pour définir une liaison d’entrée d’incorporation, qui prend en charge ces paramètres :

Paramètre	Description
Entrée	La chaîne d’entrée pour laquelle générer des incorporations.
Modèle	Facultatif. L’ID du modèle à utiliser, par défaut `text-embedding-ada-002`. Vous ne devez pas modifier le modèle d’une base de données existante. Pour plus d’informations, consultez Utilisation.
MaxChunkLength	Facultatif. Le nombre maximal de caractères utilisés pour segmenter l’entrée. Pour plus d’informations, consultez Utilisation.
MaxOverlap	Facultatif. Obtient ou définit le nombre maximal de caractères à chevaucher entre les blocs.
InputType	Facultatif. Obtient le type de l’entrée.

Annotations

L’annotation EmbeddingsInput vous permet de définir une liaison d’entrée d’incorporation, qui prend en charge ces paramètres :

Élément	Description
name	Obtient ou définit le nom de la liaison d’entrée.
input	La chaîne d’entrée pour laquelle générer des incorporations.
modèle	Facultatif. L’ID du modèle à utiliser, par défaut `text-embedding-ada-002`. Vous ne devez pas modifier le modèle d’une base de données existante. Pour plus d’informations, consultez Utilisation.
maxChunkLength	Facultatif. Le nombre maximal de caractères utilisés pour segmenter l’entrée. Pour plus d’informations, consultez Utilisation.
maxOverlap	Facultatif. Obtient ou définit le nombre maximal de caractères à chevaucher entre les blocs.
inputType	Facultatif. Obtient le type de l’entrée.

Décorateurs

Pendant la préversion, définissez la liaison d’entrée en tant que liaison generic_input_binding de type embeddings, qui prend en charge ces paramètres : le décorateur embeddings prend en charge ces paramètres :

Paramètre	Description
arg_name	Le nom de la variable qui représente le paramètre de liaison.
input	La chaîne d’entrée pour laquelle générer des incorporations.
modèle	Facultatif. L’ID du modèle à utiliser, par défaut `text-embedding-ada-002`. Vous ne devez pas modifier le modèle d’une base de données existante. Pour plus d’informations, consultez Utilisation.
maxChunkLength	Facultatif. Le nombre maximal de caractères utilisés pour segmenter l’entrée. Pour plus d’informations, consultez Utilisation.
max_overlap	Facultatif. Obtient ou définit le nombre maximal de caractères à chevaucher entre les blocs.
input_type	Obtient le type de l’entrée.

Configuration

La liaison prend en charge ces propriétés de configuration que vous définissez dans le fichier function.json.

Propriété	Description
type	Doit être `EmbeddingsInput`.
direction	Doit être `in`.
name	Le nom de la liaison d’entrée.
input	La chaîne d’entrée pour laquelle générer des incorporations.
modèle	Facultatif. L’ID du modèle à utiliser, par défaut `text-embedding-ada-002`. Vous ne devez pas modifier le modèle d’une base de données existante. Pour plus d’informations, consultez Utilisation.
maxChunkLength	Facultatif. Le nombre maximal de caractères utilisés pour segmenter l’entrée. Pour plus d’informations, consultez Utilisation.
maxOverlap	Facultatif. Obtient ou définit le nombre maximal de caractères à chevaucher entre les blocs.
inputType	Facultatif. Obtient le type de l’entrée.

Configuration

La liaison prend en charge ces propriétés, qui sont définies dans votre code :

Propriété	Description
input	La chaîne d’entrée pour laquelle générer des incorporations.
modèle	Facultatif. L’ID du modèle à utiliser, par défaut `text-embedding-ada-002`. Vous ne devez pas modifier le modèle d’une base de données existante. Pour plus d’informations, consultez Utilisation.
maxChunkLength	Facultatif. Le nombre maximal de caractères utilisés pour segmenter l’entrée. Pour plus d’informations, consultez Utilisation.
maxOverlap	Facultatif. Obtient ou définit le nombre maximal de caractères à chevaucher entre les blocs.
inputType	Facultatif. Obtient le type de l’entrée.

Pour obtenir des exemples complets, consultez la section Exemple.

Utilisation

La modification du model des incorporations par défaut modifie la façon dont les incorporations sont stockées dans la base de données vectorielle. La modification du modèle par défaut peut entraîner un comportement incorrect des recherches lorsqu’elles ne correspondent pas au reste des données précédemment ingérées dans la base de données vectorielle. Le modèle par défaut pour les incorporations est text-embedding-ada-002.

Lors du calcul de la longueur maximale des caractères pour les blocs d’entrée, considérez que le nombre maximum de jetons d’entrée autorisés pour les modèles d’incorporation d’entrée de deuxième génération comme text-embedding-ada-002 est de 8191. Un seul jeton est d’environ quatre caractères de longueur (en anglais), qui se traduit par environ 32 000 caractères d’entrée (en anglais) qu’un bloc unique peut contenir.