Vkládání vstupní vazby Azure OpenAI pro Azure Functions

Článek
05/21/2024

Důležité

Rozšíření Azure OpenAI pro Azure Functions je aktuálně ve verzi Preview.

Vstupní vazba Azure OpenAI pro vložení umožňuje vygenerovat vkládání pro vstupy. Vazba může generovat vkládání ze souborů nebo nezpracovaných textových vstupů.

Informace o nastavení a konfiguraci rozšíření Azure OpenAI najdete v tématu Rozšíření Azure OpenAI pro Azure Functions. Další informace o vkládání ve službě Azure OpenAI najdete v tématu Vysvětlení vkládání ve službě Azure OpenAI.

Poznámka:

Odkazy a příklady jsou k dispozici pouze pro model Node.js v4.

Poznámka:

Odkazy a příklady jsou k dispozici pouze pro model Pythonu v2.

Poznámka:

I když jsou podporovány oba modely procesu jazyka C#, jsou k dispozici pouze příklady izolovaného modelu pracovního procesu .

Příklad

Tento příklad ukazuje, jak vygenerovat vkládání pro nezpracovaný textový řetězec.

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

Tento příklad ukazuje, jak načíst vložené hodnoty uložené v zadaném souboru, který je přístupný pro funkci.

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

Tento příklad ukazuje, jak vygenerovat vkládání pro nezpracovaný textový řetězec.

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

Tento příklad ukazuje, jak načíst vložené hodnoty uložené v zadaném souboru, který je přístupný pro funkci.

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

Příklady ještě nejsou k dispozici.

Tento příklad ukazuje, jak vygenerovat vkládání pro nezpracovaný textový řetězec.

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

Tento příklad ukazuje, jak načíst vložené hodnoty uložené v zadaném souboru, který je přístupný pro funkci.

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

Tento příklad ukazuje, jak vygenerovat vkládání pro nezpracovaný textový řetězec.

Tady je soubor function.json pro generování vložených objektů:

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

Další informace o function.json vlastnosti souboru naleznete v části Konfigurace .

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

Tento příklad ukazuje, jak vygenerovat vkládání pro nezpracovaný textový řetězec.

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

Atributy

Pomocí atributu EmbeddingsInput definujte vstupní vazbu embeddings, která podporuje tyto parametry:

Parametr	Popis
Vstup	Vstupní řetězec, pro který se mají generovat vložené hodnoty.
Model	Volitelné. ID modelu, který se má použít, což je výchozí `text-embedding-ada-002`hodnota . Model pro existující databázi byste neměli měnit. Další informace najdete v tématu Využití.
MaxChunkLength	Volitelné. Maximální počet znaků použitých pro vytváření bloků vstupu. Další informace najdete v tématu Využití.
MaxOverlap	Volitelné. Získá nebo nastaví maximální počet znaků, které se mají překrývat mezi bloky dat.
InputType	Volitelné. Získá typ vstupu.

Poznámky

Poznámka EmbeddingsInput umožňuje definovat vstupní vazbu vkládání, která podporuje tyto parametry:

Element (Prvek)	Popis
Jméno	Získá nebo nastaví název vstupní vazby.
vstup	Vstupní řetězec, pro který se mají generovat vložené hodnoty.
model	Volitelné. ID modelu, který se má použít, což je výchozí `text-embedding-ada-002`hodnota . Model pro existující databázi byste neměli měnit. Další informace najdete v tématu Využití.
maxChunkLength	Volitelné. Maximální počet znaků použitých pro vytváření bloků vstupu. Další informace najdete v tématu Využití.
maxOverlap	Volitelné. Získá nebo nastaví maximální počet znaků, které se mají překrývat mezi bloky dat.
inputType	Volitelné. Získá typ vstupu.

Dekoratéry

Během období Preview definujte vstupní vazbu jako generic_input_binding vazbu typu embeddings, která podporuje tyto parametry: embeddings dekorátor podporuje tyto parametry:

Parametr	Popis
arg_name	Název proměnné, která představuje parametr vazby.
vstup	Vstupní řetězec, pro který se mají generovat vložené hodnoty.
model	Volitelné. ID modelu, který se má použít, což je výchozí `text-embedding-ada-002`hodnota . Model pro existující databázi byste neměli měnit. Další informace najdete v tématu Využití.
maxChunkLength	Volitelné. Maximální počet znaků použitých pro vytváření bloků vstupu. Další informace najdete v tématu Využití.
max_overlap	Volitelné. Získá nebo nastaví maximální počet znaků, které se mají překrývat mezi bloky dat.
input_type	Získá typ vstupu.

Konfigurace

Vazba podporuje tyto vlastnosti konfigurace, které jste nastavili v souboru function.json.

Vlastnost	Popis
type	Musí být `EmbeddingsInput`.
direction	Musí být `in`.
Jméno	Název vstupní vazby.
vstup	Vstupní řetězec, pro který se mají generovat vložené hodnoty.
model	Volitelné. ID modelu, který se má použít, což je výchozí `text-embedding-ada-002`hodnota . Model pro existující databázi byste neměli měnit. Další informace najdete v tématu Využití.
maxChunkLength	Volitelné. Maximální počet znaků použitých pro vytváření bloků vstupu. Další informace najdete v tématu Využití.
maxOverlap	Volitelné. Získá nebo nastaví maximální počet znaků, které se mají překrývat mezi bloky dat.
inputType	Volitelné. Získá typ vstupu.

Konfigurace

Vazba podporuje tyto vlastnosti, které jsou definovány v kódu:

Vlastnost	Popis
vstup	Vstupní řetězec, pro který se mají generovat vložené hodnoty.
model	Volitelné. ID modelu, který se má použít, což je výchozí `text-embedding-ada-002`hodnota . Model pro existující databázi byste neměli měnit. Další informace najdete v tématu Využití.
maxChunkLength	Volitelné. Maximální počet znaků použitých pro vytváření bloků vstupu. Další informace najdete v tématu Využití.
maxOverlap	Volitelné. Získá nebo nastaví maximální počet znaků, které se mají překrývat mezi bloky dat.
inputType	Volitelné. Získá typ vstupu.

Kompletní příklady najdete v části Příklad.

Využití

Změna výchozích vkládání model změní způsob, jakým se vkládání ukládají do vektorové databáze. Změna výchozího modelu může způsobit, že se vyhledávání začnou chovat nesprávně, když neodpovídají zbývajícím datům, která byla dříve ingestovaná do vektorové databáze. Výchozí model pro vkládání je text-embedding-ada-002.

Při výpočtu maximální délky znaků vstupních bloků vezměte v úvahu, že maximální vstupní tokeny povolené pro modely vkládání vstupu druhé generace, jako text-embedding-ada-002 je 8191. Jeden token je přibližně čtyři znaky v délce (v angličtině), což znamená přibližně 32 000 znaků vstupu, které se dají umístit do jednoho bloku.