Powiązanie wejściowe osadzania interfejsu Azure OpenAI dla usługi Azure Functions

Ważne

Rozszerzenie Azure OpenAI dla usługi Azure Functions jest obecnie dostępne w wersji zapoznawczej.

Powiązanie wejściowe osadzania interfejsu Azure OpenAI umożliwia generowanie osadzonych danych wejściowych. Powiązanie może generować osadzanie z plików lub nieprzetworzonych danych wejściowych tekstu.

Aby uzyskać informacje na temat konfigurowania i konfigurowania rozszerzenia Azure OpenAI, zobacz Azure OpenAI extensions for Azure Functions (Rozszerzenia azure OpenAI dla usługi Azure Functions). Aby dowiedzieć się więcej na temat osadzania w usłudze Azure OpenAI Service, zobacz Omówienie osadzania w usłudze Azure OpenAI Service.

Uwaga

Odwołania i przykłady są udostępniane tylko dla modelu Node.js w wersji 4.

Uwaga

Odwołania i przykłady są udostępniane tylko dla modelu języka Python w wersji 2.

Uwaga

Chociaż oba modele procesów języka C# są obsługiwane, udostępniane są tylko izolowane przykłady modeli procesów roboczych.

Przykład

W tym przykładzie pokazano, jak wygenerować osadzanie dla nieprzetworzonego ciągu tekstowego.

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

W tym przykładzie pokazano, jak pobrać osadzanie przechowywane w określonym pliku, który jest dostępny dla funkcji.

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

W tym przykładzie pokazano, jak wygenerować osadzanie dla nieprzetworzonego ciągu tekstowego.

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

W tym przykładzie pokazano, jak pobrać osadzanie przechowywane w określonym pliku, który jest dostępny dla funkcji.

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

Przykłady nie są jeszcze dostępne.

W tym przykładzie pokazano, jak wygenerować osadzanie dla nieprzetworzonego ciągu tekstowego.

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

W tym przykładzie pokazano, jak pobrać osadzanie przechowywane w określonym pliku, który jest dostępny dla funkcji.

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

W tym przykładzie pokazano, jak wygenerować osadzanie dla nieprzetworzonego ciągu tekstowego.

Oto plik function.json do generowania osadzania:

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

Aby uzyskać więcej informacji na temat function.json właściwości pliku, zobacz sekcję Konfiguracja.

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

W tym przykładzie pokazano, jak wygenerować osadzanie dla nieprzetworzonego ciągu tekstowego.

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

Atrybuty

Zastosuj atrybut, EmbeddingsInput aby zdefiniować powiązanie wejściowe osadzania, które obsługuje następujące parametry:

Parametr	Opis
Dane wejściowe	Ciąg wejściowy, dla którego mają być generowane osadzanie.
Model	Opcjonalne. Identyfikator modelu do użycia, który domyślnie ma wartość text-embedding-ada-002. Nie należy zmieniać modelu dla istniejącej bazy danych. Aby uzyskać więcej informacji, zobacz Użycie.
MaxChunkLength	Opcjonalne. Maksymalna liczba znaków używanych do fragmentowania danych wejściowych. Aby uzyskać więcej informacji, zobacz Użycie.
MaxOverlap	Opcjonalne. Pobiera lub ustawia maksymalną liczbę znaków nakładających się między fragmentami.
InputType	Opcjonalne. Pobiera typ danych wejściowych.

Adnotacje

Adnotacja EmbeddingsInput umożliwia zdefiniowanie powiązania wejściowego osadzania, które obsługuje następujące parametry:

Element	opis
name	Pobiera lub ustawia nazwę powiązania wejściowego.
wkład	Ciąg wejściowy, dla którego mają być generowane osadzanie.
model	Opcjonalne. Identyfikator modelu do użycia, który domyślnie ma wartość text-embedding-ada-002. Nie należy zmieniać modelu dla istniejącej bazy danych. Aby uzyskać więcej informacji, zobacz Użycie.
maxChunkLength	Opcjonalne. Maksymalna liczba znaków używanych do fragmentowania danych wejściowych. Aby uzyskać więcej informacji, zobacz Użycie.
maxOverlap	Opcjonalne. Pobiera lub ustawia maksymalną liczbę znaków nakładających się między fragmentami.
inputType	Opcjonalne. Pobiera typ danych wejściowych.

Dekoratory

W wersji zapoznawczej zdefiniuj powiązanie wejściowe jako generic_input_binding powiązanie typu embeddings, które obsługuje następujące parametry: embeddings dekorator obsługuje następujące parametry:

Parametr	Opis
arg_name	Nazwa zmiennej reprezentującej parametr powiązania.
wkład	Ciąg wejściowy, dla którego mają być generowane osadzanie.
model	Opcjonalne. Identyfikator modelu do użycia, który domyślnie ma wartość text-embedding-ada-002. Nie należy zmieniać modelu dla istniejącej bazy danych. Aby uzyskać więcej informacji, zobacz Użycie.
maxChunkLength	Opcjonalne. Maksymalna liczba znaków używanych do fragmentowania danych wejściowych. Aby uzyskać więcej informacji, zobacz Użycie.
max_overlap	Opcjonalne. Pobiera lub ustawia maksymalną liczbę znaków nakładających się między fragmentami.
input_type	Pobiera typ danych wejściowych.

Konfigurowanie

Powiązanie obsługuje te właściwości konfiguracji ustawione w pliku function.json.

Właściwości	Opis
type	Musi mieć wartość EmbeddingsInput.
direction	Musi mieć wartość in.
name	Nazwa powiązania wejściowego.
wkład	Ciąg wejściowy, dla którego mają być generowane osadzanie.
model	Opcjonalne. Identyfikator modelu do użycia, który domyślnie ma wartość text-embedding-ada-002. Nie należy zmieniać modelu dla istniejącej bazy danych. Aby uzyskać więcej informacji, zobacz Użycie.
maxChunkLength	Opcjonalne. Maksymalna liczba znaków używanych do fragmentowania danych wejściowych. Aby uzyskać więcej informacji, zobacz Użycie.
maxOverlap	Opcjonalne. Pobiera lub ustawia maksymalną liczbę znaków nakładających się między fragmentami.
inputType	Opcjonalne. Pobiera typ danych wejściowych.

Konfigurowanie

Powiązanie obsługuje te właściwości zdefiniowane w kodzie:

Właściwości	opis
wkład	Ciąg wejściowy, dla którego mają być generowane osadzanie.
model	Opcjonalne. Identyfikator modelu do użycia, który domyślnie ma wartość text-embedding-ada-002. Nie należy zmieniać modelu dla istniejącej bazy danych. Aby uzyskać więcej informacji, zobacz Użycie.
maxChunkLength	Opcjonalne. Maksymalna liczba znaków używanych do fragmentowania danych wejściowych. Aby uzyskać więcej informacji, zobacz Użycie.
maxOverlap	Opcjonalne. Pobiera lub ustawia maksymalną liczbę znaków nakładających się między fragmentami.
inputType	Opcjonalne. Pobiera typ danych wejściowych.

Zobacz sekcję Przykład, aby zapoznać się z kompletnymi przykładami.

Użycie

Zmiana domyślnych osadzeń model zmienia sposób przechowywania osadzania w bazie danych wektorów. Zmiana modelu domyślnego może spowodować, że wyszukiwanie zacznie działać nieprawidłowo, gdy nie są zgodne z resztą danych, które zostały wcześniej pozyskane do bazy danych wektorów. Domyślnym modelem osadzania jest text-embedding-ada-002.

Podczas obliczania maksymalnej długości znaków dla fragmentów wejściowych należy wziąć pod uwagę, że maksymalne tokeny wejściowe dozwolone dla modeli osadzania danych wejściowych drugiej generacji, takich jak text-embedding-ada-002 .8191 Pojedynczy token ma długość około czterech znaków (w języku angielskim), co przekłada się na około 32 000 znaków danych wejściowych, które mogą mieścić się w jednym kawałku.

Powiązana zawartość

• Przykłady osadzania
• Rozszerzenia usługi Azure OpenAI dla usługi Azure Functions