Udostępnij za pomocą

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.

internal class EmbeddingsRequest
{
    [JsonPropertyName("rawText")]
    public string? RawText { get; set; }

    [JsonPropertyName("filePath")]
    public string? FilePath { get; set; }

    [JsonPropertyName("url")]
    public string? Url { get; set; }
}

/// <summary>
/// Example showing how to use the <see cref="EmbeddingsAttribute"/> input binding to generate embeddings 
/// for a raw text string.
/// </summary>
[Function(nameof(GenerateEmbeddings_Http_RequestAsync))]
public async Task GenerateEmbeddings_Http_RequestAsync(
    [HttpTrigger(AuthorizationLevel.Function, "post", Route = "embeddings")] HttpRequestData req,
    [EmbeddingsInput("{rawText}", InputType.RawText, EmbeddingsModel = "%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, EmbeddingsModel = "%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, embeddingsModel = "%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.get("count"),
            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, embeddingsModel = "%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 {\"filePath\": value } as the request body.");
    }

    JSONObject embeddingsContextJsonObject = new JSONObject(embeddingsContext);

    context.getLogger().info(String.format("Received %d embedding(s) for input file %s.",
            embeddingsContextJsonObject.get("count"),
            request.getBody().getFilePath()));

    // 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 wygenerować osadzanie dla nieprzetworzonego ciągu tekstowego.

const embeddingsHttpInput = input.generic({
    input: '{rawText}',
    inputType: 'RawText',
    type: 'embeddings',
    embeddingsModel: '%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}
    }
});

interface EmbeddingsHttpRequest {
    RawText?: string;
}

const embeddingsHttpInput = input.generic({
    input: '{rawText}',
    inputType: 'RawText',
    type: 'embeddings',
    embeddingsModel: '%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 wygenerować osadzanie dla nieprzetworzonego ciągu tekstowego.

const embeddingsFilePathInput = input.generic({
    input: '{filePath}',
    inputType: 'FilePath',
    type: 'embeddings',
    maxChunkLength: 512,
    embeddingsModel: '%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,
    embeddingsModel: '%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}",
      "embeddingsModel": "%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",
    embeddings_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.
AIConnectionName Opcjonalne. Pobiera lub ustawia nazwę sekcji konfiguracji dla ustawień łączności usługi sztucznej inteligencji. W przypadku usługi Azure OpenAI: w przypadku określenia wyszukaj wartości "Endpoint" i "Key" w tej sekcji konfiguracji. Jeśli nie zostanie określona lub sekcja nie istnieje, wróć do zmiennych środowiskowych: AZURE_OPENAI_ENDPOINT i AZURE_OPENAI_KEY. W przypadku uwierzytelniania tożsamości zarządzanej przypisanej przez użytkownika ta właściwość jest wymagana. W przypadku usługi OpenAI (spoza platformy Azure) ustaw zmienną środowiskową OPENAI_API_KEY.
EmbeddingsModel 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:

Składnik Opis
nazwa Pobiera lub ustawia nazwę powiązania wejściowego.
wkład Ciąg wejściowy, dla którego mają być generowane osadzanie.
aiConnectionName Opcjonalne. Pobiera lub ustawia nazwę sekcji konfiguracji dla ustawień łączności usługi sztucznej inteligencji. W przypadku usługi Azure OpenAI: w przypadku określenia wyszukaj wartości "Endpoint" i "Key" w tej sekcji konfiguracji. Jeśli nie zostanie określona lub sekcja nie istnieje, wróć do zmiennych środowiskowych: AZURE_OPENAI_ENDPOINT i AZURE_OPENAI_KEY. W przypadku uwierzytelniania tożsamości zarządzanej przypisanej przez użytkownika ta właściwość jest wymagana. W przypadku usługi OpenAI (spoza platformy Azure) ustaw zmienną środowiskową OPENAI_API_KEY.
embeddingsModel 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.
ai_connection_name Opcjonalne. Pobiera lub ustawia nazwę sekcji konfiguracji dla ustawień łączności usługi sztucznej inteligencji. W przypadku usługi Azure OpenAI: w przypadku określenia wyszukaj wartości "Endpoint" i "Key" w tej sekcji konfiguracji. Jeśli nie zostanie określona lub sekcja nie istnieje, wróć do zmiennych środowiskowych: AZURE_OPENAI_ENDPOINT i AZURE_OPENAI_KEY. W przypadku uwierzytelniania tożsamości zarządzanej przypisanej przez użytkownika ta właściwość jest wymagana. W przypadku usługi OpenAI (spoza platformy Azure) ustaw zmienną środowiskową OPENAI_API_KEY.
embeddings_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
typ Musi mieć wartość EmbeddingsInput.
kierunek Musi mieć wartość in.
nazwa Nazwa powiązania wejściowego.
wkład Ciąg wejściowy, dla którego mają być generowane osadzanie.
aiConnectionName Opcjonalne. Pobiera lub ustawia nazwę sekcji konfiguracji dla ustawień łączności usługi sztucznej inteligencji. W przypadku usługi Azure OpenAI: w przypadku określenia wyszukaj wartości "Endpoint" i "Key" w tej sekcji konfiguracji. Jeśli nie zostanie określona lub sekcja nie istnieje, wróć do zmiennych środowiskowych: AZURE_OPENAI_ENDPOINT i AZURE_OPENAI_KEY. W przypadku uwierzytelniania tożsamości zarządzanej przypisanej przez użytkownika ta właściwość jest wymagana. W przypadku usługi OpenAI (spoza platformy Azure) ustaw zmienną środowiskową OPENAI_API_KEY.
embeddingsModel 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.
aiConnectionName Opcjonalne. Pobiera lub ustawia nazwę sekcji konfiguracji dla ustawień łączności usługi sztucznej inteligencji. W przypadku usługi Azure OpenAI: w przypadku określenia wyszukaj wartości "Endpoint" i "Key" w tej sekcji konfiguracji. Jeśli nie zostanie określona lub sekcja nie istnieje, wróć do zmiennych środowiskowych: AZURE_OPENAI_ENDPOINT i AZURE_OPENAI_KEY. W przypadku uwierzytelniania tożsamości zarządzanej przypisanej przez użytkownika ta właściwość jest wymagana. W przypadku usługi OpenAI (spoza platformy Azure) ustaw zmienną środowiskową OPENAI_API_KEY.
embeddingsModel 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ść

  • Last updated on