Udostępnij za pośrednictwem

Samouczek: dodawanie wskazówek dotyczących uzupełniania tekstu w usłudze Azure OpenAI do funkcji w programie Visual Studio Code

  • Artykuł

W tym artykule pokazano, jak za pomocą programu Visual Studio Code dodać punkt końcowy HTTP do aplikacji funkcji utworzonej w poprzednim artykule Szybki start. Po wyzwoleniu ten nowy punkt końcowy HTTP używa powiązania wejściowego uzupełniania tekstu usługi Azure OpenAI, aby uzyskać wskazówki dotyczące uzupełniania tekstu z modelu danych.

Z tego samouczka dowiesz się, jak wykonywać następujące zadania:

  • Tworzenie zasobów w usłudze Azure OpenAI.
  • Wdrażanie modelu w usłudze OpenAI zasobu.
  • Ustaw uprawnienia dostępu do zasobu modelu.
  • Włącz aplikację funkcji, aby nawiązać połączenie z usługą OpenAI.
  • Dodaj powiązania OpenAI do funkcji wyzwalanej przez protokół HTTP.

1. Sprawdź wymagania wstępne

  • Uzyskaj dostęp do usługi Azure OpenAI w ramach subskrypcji platformy Azure. Jeśli jeszcze nie udzielono ci dostępu, wypełnij ten formularz , aby zażądać dostępu.
  • Zainstaluj narzędzia interfejsu wiersza polecenia platformy .NET Core.
  • Emulator magazynu Azurite. Chociaż możesz również użyć rzeczywistego konta usługi Azure Storage, w artykule założono, że używasz tego emulatora.

2. Tworzenie zasobów usługi Azure OpenAI

W poniższych krokach pokazano, jak utworzyć model danych usługi Azure OpenAI w witrynie Azure Portal.

  1. Zaloguj się przy użyciu subskrypcji platformy Azure w witrynie Azure Portal.

  2. Wybierz pozycję Utwórz zasób i wyszukaj usługę Azure OpenAI. Po zlokalizowaniu usługi wybierz pozycję Utwórz.

  3. Na stronie Tworzenie usługi Azure OpenAI podaj następujące informacje dotyczące pól na karcie Podstawy:

    Pole opis
    Subskrypcja Twoja subskrypcja, która została dołączona do korzystania z usługi Azure OpenAI.
    Grupa zasobów: Grupa zasobów utworzona dla aplikacji funkcji w poprzednim artykule. Tę nazwę grupy zasobów można znaleźć, klikając prawym przyciskiem myszy aplikację funkcji w przeglądarce Zasobów platformy Azure, wybierając właściwości, a następnie wyszukując resourceGroup ustawienie w zwróconym pliku zasobu JSON.
    Region W idealnym przypadku ta sama lokalizacja co aplikacja funkcji.
    Nazwa/nazwisko Opisowa nazwa zasobu usługi Azure OpenAI Service, taka jak mySampleOpenAI.
    Warstwa cenowa Warstwa cenowa zasobu. Obecnie tylko warstwa Standardowa jest dostępna dla usługi Azure OpenAI. Aby uzyskać więcej informacji na temat cen, odwiedź stronę cennika usługi Azure OpenAI

    Zrzut ekranu przedstawiający sposób konfigurowania zasobu usługi Azure OpenAI w witrynie Azure Portal.

  4. Wybierz pozycję Dalej dwa razy, aby zaakceptować wartości domyślne dla kart Sieć i Tagi . Utworzona usługa nie ma żadnych ograniczeń sieciowych, w tym z Internetu.

  5. Wybierz pozycję Next a final time to move to the final stage in the process: Review + submit (Dalej ), aby przejść do ostatniego etapu procesu: Przeglądanie i przesyłanie.

  6. Potwierdź ustawienia konfiguracji i wybierz pozycję Utwórz.

    W witrynie Azure Portal zostanie wyświetlone powiadomienie, gdy nowy zasób jest dostępny. Wybierz pozycję Przejdź do zasobu w powiadomieniu lub wyszukaj nowy zasób usługi Azure OpenAI według nazwy.

  7. Na stronie zasobu Azure OpenAI dla nowego zasobu wybierz pozycję Kliknij tutaj, aby wyświetlić punkty końcowe w obszarze Podstawowe>punkty końcowe. Skopiuj adres URL punktu końcowego i klucze. Zapisz te wartości. Będą one potrzebne później.

Teraz, gdy masz poświadczenia do nawiązania połączenia z modelem w usłudze Azure OpenAI, musisz ustawić te poświadczenia dostępu w ustawieniach aplikacji.

3. Wdrażanie modelu

Teraz możesz wdrożyć model. Możesz wybrać jeden z kilku dostępnych modeli w programie Azure OpenAI Studio.

Aby wdrożyć model, wykonaj następujące kroki:

  1. Zaloguj się do programu Azure OpenAI Studio.

  2. Wybierz subskrypcję i utworzony zasób usługi Azure OpenAI, a następnie wybierz pozycję Użyj zasobu.

  3. W obszarze Zarządzanie wybierz pozycję Wdrożenia.

  4. Wybierz pozycję Utwórz nowe wdrożenie i skonfiguruj następujące pola:

    Pole opis
    Nazwa wdrożenia Starannie wybierz nazwę. Nazwa wdrożenia jest używana w kodzie do wywoływania modelu przy użyciu bibliotek klienckich i interfejsów API REST, dlatego należy zapisać go do użycia później.
    Wybieranie modelu Dostępność różni się w zależności od regionu Aby uzyskać listę dostępnych modeli na region, zobacz Tabela podsumowania modelu i dostępność regionów.

    Ważne

    W przypadku uzyskiwania dostępu do modelu za pośrednictwem interfejsu API należy odwołać się do nazwy wdrożenia, a nie bazowej nazwy modelu w wywołaniach interfejsu API, co jest jedną z kluczowych różnic między interfejsem OpenAI i usługą Azure OpenAI. Interfejs OpenAI wymaga tylko nazwy modelu. Interfejs Azure OpenAI zawsze wymaga nazwy wdrożenia, nawet jeśli używasz parametru modelu. W naszych dokumentach często mamy przykłady, w których nazwy wdrożeń są reprezentowane jako identyczne z nazwami modeli, aby pomóc wskazać, który model działa z określonym punktem końcowym interfejsu API. Ostatecznie nazwy wdrożeń mogą być zgodne z dowolną konwencją nazewnictwa najlepszą dla twojego przypadku użycia.

  5. Zaakceptuj wartości domyślne pozostałych ustawień i wybierz pozycję Utwórz.

    W tabeli deployments (Wdrożenia) przedstawiono nowy wpis odpowiadający nowo utworzonemu modelowi.

Masz teraz wszystko, czego potrzebujesz, aby dodać do aplikacji funkcji uzupełnianie tekstu opartego na usłudze Azure OpenAI.

4. Aktualizowanie ustawień aplikacji

  1. W programie Visual Studio Code otwórz projekt kodu lokalnego utworzony po ukończeniu poprzedniego artykułu.

  2. W pliku local.settings.json w folderze głównym projektu zaktualizuj AzureWebJobsStorage ustawienie na UseDevelopmentStorage=true. Ten krok można pominąć, jeśli AzureWebJobsStorage ustawienie w local.settings.json jest ustawione na parametry połączenia dla istniejącego konta usługi Azure Storage zamiast UseDevelopmentStorage=true.

  3. W pliku local.settings.json dodaj następujące wartości ustawień:

    • AZURE_OPENAI_ENDPOINT: wymagane przez rozszerzenie powiązania. Ustaw tę wartość na punkt końcowy utworzonego wcześniej zasobu usługi Azure OpenAI.
    • AZURE_OPENAI_KEY: wymagane przez rozszerzenie powiązania. Ustaw tę wartość na klucz zasobu usługi Azure OpenAI.
    • CHAT_MODEL_DEPLOYMENT_NAME: służy do definiowania powiązania wejściowego. Ustaw tę wartość na nazwę wybraną dla wdrożenia modelu.

  4. Zapisz plik. Podczas wdrażania na platformie Azure należy również dodać te ustawienia do aplikacji funkcji.

5. Rejestrowanie rozszerzeń powiązań

Ponieważ używasz powiązania wyjściowego usługi Azure OpenAI, przed uruchomieniem projektu musisz mieć zainstalowane odpowiednie rozszerzenie powiązań.

Z wyjątkiem wyzwalaczy HTTP i czasomierza powiązania są implementowane jako pakiety rozszerzeń. Aby dodać pakiet rozszerzenia Azure OpenAI do projektu, uruchom to polecenie dotnet add package w oknie terminalu:

dotnet add package Microsoft.Azure.Functions.Worker.Extensions.OpenAI --prerelease

5. Aktualizowanie pakietu rozszerzeń

Aby uzyskać dostęp do powiązań usługi Azure OpenAI w wersji zapoznawczej, należy użyć wersji zapoznawczej pakietu rozszerzenia zawierającego to rozszerzenie.

Zastąp extensionBundle ustawienie w bieżącym host.json pliku następującym kodem JSON:

 "extensionBundle": {
   "id": "Microsoft.Azure.Functions.ExtensionBundle.Preview",
   "version": "[4.*, 5.0.0)"
 }

Teraz możesz użyć powiązania wyjściowego usługi Azure OpenAI w projekcie.

6. Zwracanie uzupełniania tekstu z modelu

Dodany kod tworzy whois punkt końcowy funkcji HTTP w istniejącym projekcie. W tej funkcji dane przekazywane w parametrze ADRESU URL name żądania GET są używane do dynamicznego tworzenia monitu o ukończenie. Ten dynamiczny monit jest powiązany z powiązaniem wejściowym uzupełniania tekstu, które zwraca odpowiedź z modelu na podstawie monitu. Ukończenie modelu jest zwracane w odpowiedzi HTTP.

  1. W istniejącym HttpExample pliku klasy dodaj następującą using instrukcję:

    using Microsoft.Azure.Functions.Worker.Extensions.OpenAI.TextCompletion;

  2. W tym samym pliku dodaj ten kod, który definiuje nowy punkt końcowy wyzwalacza HTTP o nazwie whois:

    [Function(nameof(WhoIs))]
public IActionResult WhoIs([HttpTrigger(AuthorizationLevel.Function, Route = "whois/{name}")] HttpRequest req,
[TextCompletionInput("Who is {name}?", Model = "%CHAT_MODEL_DEPLOYMENT_NAME%")] TextCompletionResponse response)
{
    if(!String.IsNullOrEmpty(response.Content))
    {
        return new OkObjectResult(response.Content);
    }
    else
    {
        return new NotFoundObjectResult("Something went wrong.");
    }
}

  1. Zaktualizuj plik projektu, pom.xml aby dodać to odwołanie do properties kolekcji:

    <azure-functions-java-library-openai>0.2.0-preview</azure-functions-java-library-openai>

  2. W tym samym pliku dodaj tę zależność do dependencies kolekcji:

    <dependency>
    <groupId>com.microsoft.azure.functions</groupId>
    <artifactId>azure-functions-java-library-openai</artifactId>
    <version>${azure-functions-java-library-openai}</version>
</dependency>

  3. W istniejącym Function.java pliku projektu dodaj następujące import instrukcje:

    import com.microsoft.azure.functions.openai.annotation.textcompletion.TextCompletion;
import com.microsoft.azure.functions.openai.annotation.textcompletion.TextCompletionResponse;

  4. W tym samym pliku dodaj ten kod, który definiuje nowy punkt końcowy wyzwalacza HTTP o nazwie whois:

    @FunctionName("WhoIs")
public HttpResponseMessage whoIs(
    @HttpTrigger(
        name = "req", 
        methods = {HttpMethod.GET},
        authLevel = AuthorizationLevel.ANONYMOUS, 
        route = "whois/{name}") 
        HttpRequestMessage<Optional<String>> request,
    @BindingName("name") String name,
    @TextCompletion(prompt = "Who is {name}?", model = "%CHAT_MODEL_DEPLOYMENT_NAME%", name = "response") TextCompletionResponse response,
    final ExecutionContext context) {
    return request.createResponseBuilder(HttpStatus.OK)
        .header("Content-Type", "application/json")
        .body(response.getContent())
        .build();
}

  1. W programie Visual Studio Code naciśnij F1 i w palecie poleceń wpisz Azure Functions: Create Function...wyzwalacz HTTP, wpisz nazwę whoisfunkcji i naciśnij Enter.

  2. W nowym whois.js pliku kodu zastąp zawartość pliku następującym kodem:

    const { app, input } = require("@azure/functions");

// This OpenAI completion input requires a {name} binding value.
const openAICompletionInput = input.generic({
    prompt: 'Who is {name}?',
    maxTokens: '100',
    type: 'textCompletion',
    model: '%CHAT_MODEL_DEPLOYMENT_NAME%'
})

app.http('whois', {
    methods: ['GET'],
    route: 'whois/{name}',
    authLevel: 'function',
    extraInputs: [openAICompletionInput],
    handler: async (_request, context) => {
        var response = context.extraInputs.get(openAICompletionInput)
        return { body: response.content.trim() }
    }
});

  1. W programie Visual Studio Code naciśnij F1 i w palecie poleceń wpisz Azure Functions: Create Function...wyzwalacz HTTP, wpisz nazwę whoisfunkcji i naciśnij Enter.

  2. W nowym whois.ts pliku kodu zastąp zawartość pliku następującym kodem:

    import { app, input } from "@azure/functions";

// This OpenAI completion input requires a {name} binding value.
const openAICompletionInput = input.generic({
    prompt: 'Who is {name}?',
    maxTokens: '100',
    type: 'textCompletion',
    model: '%CHAT_MODEL_DEPLOYMENT_NAME%'
})

app.http('whois', {
    methods: ['GET'],
    route: 'whois/{name}',
    authLevel: 'function',
    extraInputs: [openAICompletionInput],
    handler: async (_request, context) => {
        var response: any = context.extraInputs.get(openAICompletionInput)
        return { body: response.content.trim() }
    }
});

  1. W istniejącym function_app.py pliku projektu dodaj następującą import instrukcję:

    import json

  2. W tym samym pliku dodaj ten kod, który definiuje nowy punkt końcowy wyzwalacza HTTP o nazwie whois:

    @app.route(route="whois/{name}", methods=["GET"])
@app.text_completion_input(arg_name="response", prompt="Who is {name}?", max_tokens="100", model = "%CHAT_MODEL_DEPLOYMENT_NAME%")
def whois(req: func.HttpRequest, response: str) -> func.HttpResponse:
    response_json = json.loads(response)
    return func.HttpResponse(response_json["content"], status_code=200)


@app.route(route="genericcompletion", methods=["POST"])
@app.text_completion_input(arg_name="response", prompt="{Prompt}", model = "%CHAT_MODEL_DEPLOYMENT_NAME%")
def genericcompletion(req: func.HttpRequest, response: str) -> func.HttpResponse:
    response_json = json.loads(response)
    return func.HttpResponse(response_json["content"], status_code=200)

  1. W programie Visual Studio Code naciśnij F1 i w palecie poleceń wpisz Azure Functions: Create Function...wyzwalacz HTTP, wpisz nazwę whoisfunkcji, wybierz pozycję Anonimowe i naciśnij Enter.

  2. Otwórz nowy whois/function.json plik kodu i zastąp jego zawartość tym kodem, który dodaje definicję powiązania wejściowego TextCompletionResponse :

    {
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "route": "whois/{name}",
      "methods": [
        "get"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    },
    {
      "type": "textCompletion",
      "direction": "in",
      "name": "TextCompletionResponse",
      "prompt": "Who is {name}?",
      "maxTokens": "100",
      "model": "%CHAT_MODEL_DEPLOYMENT_NAME%"
    }
  ]
}

  3. Zastąp zawartość whois/run.ps1 pliku kodu tym kodem, który zwraca odpowiedź powiązania wejściowego:

    using namespace System.Net

param($Request, $TriggerMetadata, $TextCompletionResponse)

Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
        StatusCode = [HttpStatusCode]::OK
        Body       = $TextCompletionResponse.Content
    })

7. Uruchamianie funkcji

  1. W programie Visual Studio Code naciśnij F1 i w palecie poleceń wpisz Azurite: Start i naciśnij Enter, aby uruchomić emulator magazynu Azurite.

  2. Naciśnij F5 , aby uruchomić projekt aplikacji funkcji i narzędzia Core Tools w trybie debugowania.

  3. Po uruchomieniu narzędzi Core Tools wyślij żądanie GET do whois funkcji punktu końcowego z nazwą w ścieżce, w następujący sposób:

    http://localhost:7071/api/whois/<NAME>

    Zastąp <NAME> ciąg wartością, którą chcesz przekazać do monitu "Who is {name}?" . Musi <NAME> to być nazwa zakodowana w adresie URL osoby publicznej, na przykład Abraham%20Lincoln.

    Widoczna odpowiedź to odpowiedź na uzupełnianie tekstu z modelu usługi Azure OpenAI.

  4. Po powrocie odpowiedzi naciśnij Ctrl + C , aby zatrzymać narzędzia Core Tools.

8. Czyszczenie zasobów

Na platformie Azure zasoby odnoszą się do aplikacji funkcji, funkcji, kont magazynu itd. Są one grupowane w grupy zasobów i można usunąć wszystkie elementy w grupie, usuwając grupę.

Aby ukończyć te przewodniki Szybki start, zostały utworzone zasoby. Opłaty za te zasoby można naliczać w zależności od stanu konta i cen usług. Jeśli nie potrzebujesz już tych zasobów, oto jak możesz je usunąć:

  1. W programie Visual Studio Code naciśnij F1 , aby otworzyć paletę poleceń. W palecie poleceń wyszukaj i wybierz pozycję Azure: Open in portal.

  2. Wybierz aplikację funkcji i naciśnij Enter. Strona aplikacji funkcji zostanie otwarta w witrynie Azure Portal.

  3. Na karcie Przegląd wybierz nazwany link obok pozycji Grupa zasobów.

    Zrzut ekranu przedstawiający wybieranie grupy zasobów do usunięcia ze strony aplikacji funkcji.

  4. Na stronie Grupa zasobów przejrzyj listę uwzględnionych zasobów i sprawdź, czy są to te, które chcesz usunąć.

  5. Wybierz pozycję Usuń grupę zasobów, a następnie postępuj zgodnie z instrukcjami.

    Usuwanie może potrwać kilka minut. Po jego zakończeniu przez kilka sekund będzie widoczne powiadomienie. Możesz również wybrać ikonę dzwonka w górnej części strony, aby wyświetlić powiadomienie.

Powiązana zawartość