Dela via

Azure OpenAI-inbäddningsindatabindning för Azure Functions

  • Artikel

Viktigt!

Azure OpenAI-tillägget för Azure Functions är för närvarande i förhandsversion.

Med azure OpenAI-inbäddningsindatabindningen kan du generera inbäddningar för indata. Bindningen kan generera inbäddningar från filer eller råtextindata.

Information om konfiguration och konfigurationsinformation för Azure OpenAI-tillägget finns i Azure OpenAI-tillägg för Azure Functions. Mer information om inbäddningar i Azure OpenAI-tjänsten finns i Förstå inbäddningar i Azure OpenAI Service.

Kommentar

Referenser och exempel tillhandahålls endast för modellen Node.js v4.

Kommentar

Referenser och exempel tillhandahålls endast för Python v2-modellen.

Kommentar

Båda C#-processmodellerna stöds, men endast exempel på isolerade arbetsmodeller tillhandahålls.

Exempel

Det här exemplet visar hur du genererar inbäddningar för en rå textsträng.

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

Det här exemplet visar hur du hämtar inbäddningar som lagras i en angiven fil som är tillgänglig för funktionen.

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

Det här exemplet visar hur du genererar inbäddningar för en rå textsträng.

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

Det här exemplet visar hur du hämtar inbäddningar som lagras i en angiven fil som är tillgänglig för funktionen.

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

Det här exemplet visar hur du genererar inbäddningar för en rå textsträng.

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 = await request.json();
        let response = 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}
    }
});

const embeddingsFilePathInput = input.generic({
    input: '{filePath}',
    inputType: 'FilePath',

interface EmbeddingsHttpRequest {
    RawText?: string;
}

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

Det här exemplet visar hur du genererar inbäddningar för en rå textsträng.

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 = await request.json();
        let response = 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}
    }
});

interface EmbeddingsFilePath {
    FilePath?: string;
}

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

Det här exemplet visar hur du genererar inbäddningar för en rå textsträng.

Här är function.json-filen för att generera inbäddningarna:

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

Mer information om function.json filegenskaper finns i avsnittet Konfiguration .

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

Det här exemplet visar hur du genererar inbäddningar för en rå textsträng.

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

Attribut

EmbeddingsInput Använd attributet för att definiera en inbäddningsindatabindning som stöder följande parametrar:

Parameter Description
Indata Den indatasträng som du vill generera inbäddningar för.
Modell Valfritt. ID:t för modellen som ska användas, som standard är text-embedding-ada-002. Du bör inte ändra modellen för en befintlig databas. Mer information finns i Användning.
MaxChunkLength Valfritt. Det maximala antalet tecken som används för segmentering av indata. Mer information finns i Användning.
MaxOverlap Valfritt. Hämtar eller anger det maximala antalet tecken som ska överlappa mellan segment.
InputType Valfritt. Hämtar indatatypen.

Kommentarer

Med anteckningen EmbeddingsInput kan du definiera en inbäddningsindatabindning som stöder följande parametrar:

Element Description
Namn Hämtar eller anger namnet på indatabindningen.
inmatning Den indatasträng som du vill generera inbäddningar för.
modell Valfritt. ID:t för modellen som ska användas, som standard är text-embedding-ada-002. Du bör inte ändra modellen för en befintlig databas. Mer information finns i Användning.
maxChunkLength Valfritt. Det maximala antalet tecken som används för segmentering av indata. Mer information finns i Användning.
maxOverlap Valfritt. Hämtar eller anger det maximala antalet tecken som ska överlappa mellan segment.
inputType Valfritt. Hämtar indatatypen.

Dekoratörer

Under förhandsversionen definierar du indatabindningen som en generic_input_binding bindning av typen embeddings, som stöder följande parametrar: embeddings dekoratör stöder följande parametrar:

Parameter Description
arg_name Namnet på variabeln som representerar bindningsparametern.
inmatning Den indatasträng som du vill generera inbäddningar för.
modell Valfritt. ID:t för modellen som ska användas, som standard är text-embedding-ada-002. Du bör inte ändra modellen för en befintlig databas. Mer information finns i Användning.
maxChunkLength Valfritt. Det maximala antalet tecken som används för segmentering av indata. Mer information finns i Användning.
max_overlap Valfritt. Hämtar eller anger det maximala antalet tecken som ska överlappa mellan segment.
input_type Hämtar indatatypen.

Konfiguration

Bindningen stöder de konfigurationsegenskaper som du anger i filen function.json.

Property Beskrivning
typ Måste vara EmbeddingsInput.
riktning Måste vara in.
Namn Namnet på indatabindningen.
inmatning Den indatasträng som du vill generera inbäddningar för.
modell Valfritt. ID:t för modellen som ska användas, som standard är text-embedding-ada-002. Du bör inte ändra modellen för en befintlig databas. Mer information finns i Användning.
maxChunkLength Valfritt. Det maximala antalet tecken som används för segmentering av indata. Mer information finns i Användning.
maxOverlap Valfritt. Hämtar eller anger det maximala antalet tecken som ska överlappa mellan segment.
inputType Valfritt. Hämtar indatatypen.

Konfiguration

Bindningen stöder dessa egenskaper, som definieras i koden:

Property beskrivning
inmatning Den indatasträng som du vill generera inbäddningar för.
modell Valfritt. ID:t för modellen som ska användas, som standard är text-embedding-ada-002. Du bör inte ändra modellen för en befintlig databas. Mer information finns i Användning.
maxChunkLength Valfritt. Det maximala antalet tecken som används för segmentering av indata. Mer information finns i Användning.
maxOverlap Valfritt. Hämtar eller anger det maximala antalet tecken som ska överlappa mellan segment.
inputType Valfritt. Hämtar indatatypen.

Se avsnittet Exempel för fullständiga exempel.

Förbrukning

Om du ändrar standardbäddningarna model ändras hur inbäddningar lagras i vektordatabasen. Om du ändrar standardmodellen kan sökningarna börja bete sig felaktigt när de inte matchar resten av de data som tidigare matades in i vektordatabasen. Standardmodellen för inbäddningar är text-embedding-ada-002.

När du beräknar den maximala teckenlängden för indatasegment bör du tänka på att de maximala indatatoken som tillåts för andra generationens inbäddningsmodeller som text-embedding-ada-002 är 8191. En enskild token är ungefär fyra tecken lång (på engelska), vilket innebär ungefär 32 000 tecken (engelska) indata som får plats i ett enda segment.

Relaterat innehåll