Enlace de entrada de inserciones de Azure OpenAI para Azure Functions

Artículo
05/21/2024

Importante

La extensión de Azure OpenAI para Azure Functions está actualmente en versión preliminar.

El enlace de entrada de inserciones de Azure OpenAI permite generar inserciones para las entradas. El enlace puede generar inserciones a partir de archivos o entradas de texto sin formato.

Para obtener información sobre la configuración y los detalles de configuración de la extensión de Azure OpenAI, consulte Extensiones de Azure OpenAI para Azure Functions. Para más información sobre las inserciones en Azure OpenAI Service, consulte Descripción de las inserciones en Azure OpenAI Service.

Nota:

Las referencias y ejemplos solo se proporcionan para el modelo de Node.js v4.

Nota:

Las referencias y ejemplos solo se proporcionan para el modelo de Python v2.

Nota:

Aunque se admiten ambos modelos de proceso de C#, solo se proporcionan ejemplos de modelos de trabajo aislados.

Ejemplo

En este ejemplo se muestra cómo generar inserciones para una cadena de texto sin formato.

[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.
}

En este ejemplo se muestra cómo recuperar incrustaciones almacenadas en un archivo especificado al que se puede acceder a la función.

[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.
}

En este ejemplo se muestra cómo generar inserciones para una cadena de texto sin formato.

@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();
}

En este ejemplo se muestra cómo recuperar incrustaciones almacenadas en un archivo especificado al que se puede acceder a la función.

@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();
}

Los ejemplos aún no están disponibles.

En este ejemplo se muestra cómo generar inserciones para una cadena de texto sin formato.

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}
    }
});

En este ejemplo se muestra cómo recuperar incrustaciones almacenadas en un archivo especificado al que se puede acceder a la función.

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}
    }

En este ejemplo se muestra cómo generar inserciones para una cadena de texto sin formato.

Este es el archivo function.json para generar las incrustaciones:

{
  "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%"
    }
  ]
}

Para obtener más información sobre las propiedades del archivo function.json, consulte la sección de Configuración.

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
})

En este ejemplo se muestra cómo generar inserciones para una cadena de texto sin formato.

@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")
    }
    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)

Atributos

Aplique el atributo EmbeddingsInput para definir un enlace de entrada de inserciones, que admite estos parámetros:

Parámetro	Descripción
Entrada	Cadena de entrada para la que se van a generar inserciones.
Modelo	Opcional. Identificador del modelo que se va a usar, que tiene como valor predeterminado `text-embedding-ada-002`. No debe cambiar el modelo de una base de datos existente. Para obtener más información, consulte Uso.
MaxChunkLength	Opcional. Número máximo de caracteres usados para fragmentar la entrada. Para obtener más información, consulte Uso.
MaxOverlap	Opcional. Obtiene o establece el número máximo de caracteres que se superponen entre fragmentos.
InputType	Opcional. Obtiene el tipo de la entrada.

anotaciones

La anotación EmbeddingsInput permite definir un enlace de entrada de inserciones, que admite estos parámetros:

Elemento	Descripción
name	Obtiene o establece el nombre del enlace de entrada.
input	Cadena de entrada para la que se van a generar inserciones.
model	Opcional. Identificador del modelo que se va a usar, que tiene como valor predeterminado `text-embedding-ada-002`. No debe cambiar el modelo de una base de datos existente. Para obtener más información, consulte Uso.
maxChunkLength	Opcional. Número máximo de caracteres usados para fragmentar la entrada. Para obtener más información, consulte Uso.
maxOverlap	Opcional. Obtiene o establece el número máximo de caracteres que se superponen entre fragmentos.
inputType	Opcional. Obtiene el tipo de la entrada.

Elementos Decorator

Durante la versión preliminar, defina el enlace de entrada como un enlace generic_input_binding de tipo embeddings, que admite estos parámetros: embeddings el decorador admite estos parámetros:

Parámetro	Descripción
arg_name	Nombre de la variable que representa el parámetro de enlace.
input	Cadena de entrada para la que se van a generar inserciones.
model	Opcional. Identificador del modelo que se va a usar, que tiene como valor predeterminado `text-embedding-ada-002`. No debe cambiar el modelo de una base de datos existente. Para obtener más información, consulte Uso.
maxChunkLength	Opcional. Número máximo de caracteres usados para fragmentar la entrada. Para obtener más información, consulte Uso.
max_overlap	Opcional. Obtiene o establece el número máximo de caracteres que se superponen entre fragmentos.
input_type	Obtiene el tipo de la entrada.

Configuración

El enlace admite estas propiedades de configuración que se establecen en el archivo function.json.

Propiedad	Descripción
type	Debe ser `EmbeddingsInput`.
direction	Debe ser `in`.
name	Nombre del enlace de entrada.
input	Cadena de entrada para la que se van a generar inserciones.
model	Opcional. Identificador del modelo que se va a usar, que tiene como valor predeterminado `text-embedding-ada-002`. No debe cambiar el modelo de una base de datos existente. Para obtener más información, consulte Uso.
maxChunkLength	Opcional. Número máximo de caracteres usados para fragmentar la entrada. Para obtener más información, consulte Uso.
maxOverlap	Opcional. Obtiene o establece el número máximo de caracteres que se superponen entre fragmentos.
inputType	Opcional. Obtiene el tipo de la entrada.

Configuración

El enlace admite estas propiedades, que se definen en el código:

Propiedad	Descripción
input	Cadena de entrada para la que se van a generar inserciones.
model	Opcional. Identificador del modelo que se va a usar, que tiene como valor predeterminado `text-embedding-ada-002`. No debe cambiar el modelo de una base de datos existente. Para obtener más información, consulte Uso.
maxChunkLength	Opcional. Número máximo de caracteres usados para fragmentar la entrada. Para obtener más información, consulte Uso.
maxOverlap	Opcional. Obtiene o establece el número máximo de caracteres que se superponen entre fragmentos.
inputType	Opcional. Obtiene el tipo de la entrada.

Consulte la sección de ejemplos para ver ejemplos completos.

Uso

Cambiar las inserciones predeterminadas model cambia la forma en que las inserciones se almacenan en la base de datos vectorial. Cambiar el modelo predeterminado puede hacer que las búsquedas empiecen a comportarse mal cuando no coincidan con el resto de los datos ingeridos anteriormente en la base de datos vectorial. El modelo predeterminado para las inserciones es text-embedding-ada-002.

Al calcular la longitud máxima de caracteres para los fragmentos de entrada, tenga en cuenta que el número máximo de tokens de entrada permitidos para los modelos de inserción de entrada de segunda generación como text-embedding-ada-002 es 8191. Un solo token tiene aproximadamente cuatro caracteres de longitud (en inglés), lo cual se traduce a aproximadamente 32 000 caracteres de entrada que pueden caber en un único fragmento.