Udostępnij za pośrednictwem

biblioteka klienta Bezpieczeństwo zawartości platformy Azure AI dla języka Python — wersja 1.0.0

  • Artykuł

Bezpieczeństwo zawartości platformy Azure AI wykrywa szkodliwą zawartość wygenerowaną przez użytkownika i sztuczną inteligencję w aplikacjach i usługach. Bezpieczeństwo zawartości obejmuje interfejsy API tekstu i obrazu, które umożliwiają wykrywanie materiałów szkodliwych:

  • Interfejs API analizy tekstu: skanuje tekst pod kątem treści seksualnych, przemocy, nienawiści i samookaleczenia za pomocą poziomów wieloostrzytnych.
  • Interfejs API analizy obrazów: skanuje obrazy pod kątem zawartości seksualnej, przemocy, nienawiści i samookaleczenia za pomocą poziomów wieloostrzytnych.
  • Interfejsy API zarządzania listą bloków tekstu: domyślne klasyfikatory sztucznej inteligencji są wystarczające dla większości potrzeb dotyczących bezpieczeństwa zawartości; może być jednak konieczne wyświetlanie terminów specyficznych dla danego przypadku użycia. Listę bloków warunków do użycia z interfejsem API tekstu można utworzyć.

Dokumentacja

Dostępna jest różne dokumenty ułatwiające rozpoczęcie pracy

Wprowadzenie

Wymagania wstępne

Instalowanie pakietu

pip install azure-ai-contentsafety

Uwierzytelnianie klienta

Pobieranie punktu końcowego

Punkt końcowy zasobu usługi Bezpieczeństwo zawartości platformy Azure AI można znaleźć przy użyciu witryny Azure Portal lub interfejsu wiersza polecenia platformy Azure:

# Get the endpoint for the Azure AI Content Safety service resource
az cognitiveservices account show --name "resource-name" --resource-group "resource-group-name" --query "properties.endpoint"

Tworzenie elementu ContentSafetyClient/BlocklistClient przy użyciu klucza interfejsu API

Aby użyć klucza interfejsu API jako parametru credential .

  • Krok 1. Pobieranie klucza interfejsu API. Klucz interfejsu API można znaleźć w witrynie Azure Portal lub za pomocą następującego polecenia interfejsu wiersza polecenia platformy Azure :

    az cognitiveservices account keys list --name "<resource-name>" --resource-group "<resource-group-name>"

  • Krok 2. Przekazanie klucza jako ciągu do wystąpienia elementu AzureKeyCredential.

    from azure.core.credentials import AzureKeyCredential
from azure.ai.contentsafety import ContentSafetyClient, BlocklistClient

endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/"
credential = AzureKeyCredential("<api_key>")
content_safety_client = ContentSafetyClient(endpoint, credential)
blocklist_client = BlocklistClient(endpoint, credential)

Tworzenie elementu ContentSafetyClient/BlocklistClient z poświadczeniami tokenu identyfikatora Microsoft Entra

  • Krok 1. Włączanie identyfikatora Microsoft Entra dla zasobu. Zapoznaj się z tym dokumentem Uwierzytelnianie przy użyciu identyfikatora Microsoft Entra, aby uzyskać instrukcje umożliwiające włączenie identyfikatora Microsoft Entra zasobu.

    Główne kroki to:

    • Utwórz zasób przy użyciu niestandardowej poddomeny.
    • Utwórz jednostkę usługi i przypisz do niej rolę użytkownika usług Cognitive Services.

  • Krok 2. Ustaw wartości identyfikatora klienta, identyfikatora dzierżawy i wpisu tajnego klienta aplikacji Microsoft Entra jako zmienne środowiskowe: AZURE_CLIENT_ID, , AZURE_TENANT_IDAZURE_CLIENT_SECRET.

    Wartość domyślnaAzureCredential będzie używać wartości z tych zmiennych środowiskowych.

    from azure.identity import DefaultAzureCredential
from azure.ai.contentsafety import ContentSafetyClient, BlocklistClient

endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/"
credential = DefaultAzureCredential()
content_safety_client = ContentSafetyClient(endpoint, credential)
blocklist_client = BlocklistClient(endpoint, credential)

Kluczowe pojęcia

Dostępne funkcje

W tej usłudze są dostępne różne typy analiz. W poniższej tabeli opisano obecnie dostępne interfejsy API.

Cecha Opis
Interfejs API analizy tekstu Skanuje tekst pod kątem treści seksualnych, przemocy, nienawiści i samookaleczenia z wieloma poziomami ważności.
Interfejs API analizy obrazów Skanuje obrazy pod kątem treści seksualnych, przemocy, nienawiści i samookaleczenia z wieloma poziomami ważności.
Interfejsy API zarządzania listą bloków tekstowych Domyślne klasyfikatory sztucznej inteligencji są wystarczające dla większości potrzeb dotyczących bezpieczeństwa zawartości. Jednak może być konieczne wyświetlanie terminów specyficznych dla danego przypadku użycia. Listę bloków warunków do użycia z interfejsem API tekstu można utworzyć.

Kategorie szkód

Bezpieczeństwo zawartości rozpoznaje cztery odrębne kategorie niepożądanej zawartości.

Kategoria Opis
Nienawidzić Szkody związane z nienawiścią i sprawiedliwością odnoszą się do wszelkich treści, które atakują lub używają języka pejoracyjnego lub dyskryminującego z odniesieniem do osoby lub grupy tożsamości w oparciu o pewne atrybuty różnicowe tych grup, w tym rasę, pochodzenie etniczne, narodowość, tożsamość płci i wyrażenie, orientację seksualną, religię, status imigracji, status zdolności, wygląd osobisty i rozmiar ciała.
Seksualne Seksualny opisuje język związany z anatomicznymi narządami i genitaliami, romantycznymi relacjami, aktami przedstawianymi w kategoriach erotycznych lub czułych, ciąży, fizycznych aktów seksualnych, w tym tych przedstawianych jako napaść lub wymuszony akt przemocy seksualnej przeciwko woli, prostytucji, pornografii i nadużyć.
Przemocy Przemoc opisuje język związany z działaniami fizycznymi przeznaczonymi do zranienia, obrażeń, uszkodzenia lub zabicia kogoś lub czegoś; opisuje broń, broń i powiązane jednostki, takie jak producenci, stowarzyszenia, ustawodawstwo itd.
Samookaleczenia Samookaleczenia opisuje język związany z działaniami fizycznymi przeznaczonymi do celowego zranienia, obrażeń, uszkodzenia ciała lub zabicia siebie.

Klasyfikacja może być oznaczona wieloma etykietami. Na przykład gdy przykład tekstu przechodzi przez model moderowania tekstu, może być klasyfikowany zarówno jako zawartość seksualna, jak i przemoc.

Poziomy ważności

Każda kategoria szkody, która ma zastosowanie, ma również ocenę poziomu ważności. Poziom ważności ma wskazywać ważność konsekwencji wyświetlania oflagowanych zawartości.

Tekst: bieżąca wersja modelu tekstu obsługuje pełną skalę ważności 0–7. Domyślnie odpowiedź będzie zwracać 4 wartości: 0, 2, 4 i 6. Każdy dwa sąsiadujące poziomy są mapowane na jeden poziom. Użytkownicy mogą użyć wartości "outputType" w żądaniu i ustawić ją jako "EightSeverityLevels", aby uzyskać 8 wartości w danych wyjściowych: 0,1,2,3,4,5,6,7. Aby uzyskać szczegółowe informacje, możesz zapoznać się z definicjami poziomów ważności zawartości tekstowej .

  • [0,1] -> 0
  • [2,3] -> 2
  • [4,5] -> 4
  • [6,7] -> 6

Obraz: Bieżąca wersja modelu obrazu obsługuje przyciętą wersję pełnej skali ważności 0–7. Klasyfikator zwraca tylko ważność 0, 2, 4 i 6; każdy z dwóch sąsiednich poziomów jest mapowany na jeden poziom. Szczegółowe informacje można znaleźć w definicjach poziomów ważności zawartości obrazu .

  • [0,1] -> 0
  • [2,3] -> 2
  • [4,5] -> 4
  • [6,7] -> 6

Zarządzanie listą bloków tekstowych

Następujące operacje są obsługiwane do zarządzania listą bloków tekstowych:

  • Tworzenie lub modyfikowanie listy bloków
  • Wyświetlanie listy wszystkich list bloków
  • Pobieranie listy bloków według blocklistName
  • Dodawanie elementu blocklistItems do listy bloków
  • Usuwanie elementu blocklistItems z listy bloków
  • Wyświetl listę wszystkich blokowychItems na liście bloków według blocklistName
  • Pobieranie elementu blocklistItem na liście bloków według parametrów blocklistItemId i blocklistName
  • Usuwanie listy bloków i wszystkich jej listy blokówItems

Możesz ustawić listy bloków, których chcesz użyć podczas analizowania tekstu, a następnie uzyskać wynik dopasowania listy bloków z zwróconej odpowiedzi.

Przykłady

W poniższej sekcji przedstawiono kilka fragmentów kodu obejmujących niektóre z najbardziej typowych zadań usługi bezpieczeństwa zawartości, w tym:

Zapoznaj się z przykładowymi danymi używanymi tutaj. Aby uzyskać więcej przykładów, zapoznaj się z przykładami.

Analizowanie tekstu

Analizowanie tekstu bez list bloków


    import os
    from azure.ai.contentsafety import ContentSafetyClient
    from azure.ai.contentsafety.models import TextCategory
    from azure.core.credentials import AzureKeyCredential
    from azure.core.exceptions import HttpResponseError
    from azure.ai.contentsafety.models import AnalyzeTextOptions

    key = os.environ["CONTENT_SAFETY_KEY"]
    endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]

    # Create a Content Safety client
    client = ContentSafetyClient(endpoint, AzureKeyCredential(key))

    # Construct a request
    request = AnalyzeTextOptions(text="You are an idiot")

    # Analyze text
    try:
        response = client.analyze_text(request)
    except HttpResponseError as e:
        print("Analyze text failed.")
        if e.error:
            print(f"Error code: {e.error.code}")
            print(f"Error message: {e.error.message}")
            raise
        print(e)
        raise

    hate_result = next(item for item in response.categories_analysis if item.category == TextCategory.HATE)
    self_harm_result = next(item for item in response.categories_analysis if item.category == TextCategory.SELF_HARM)
    sexual_result = next(item for item in response.categories_analysis if item.category == TextCategory.SEXUAL)
    violence_result = next(item for item in response.categories_analysis if item.category == TextCategory.VIOLENCE)

    if hate_result:
        print(f"Hate severity: {hate_result.severity}")
    if self_harm_result:
        print(f"SelfHarm severity: {self_harm_result.severity}")
    if sexual_result:
        print(f"Sexual severity: {sexual_result.severity}")
    if violence_result:
        print(f"Violence severity: {violence_result.severity}")

Analizowanie tekstu przy użyciu list zablokowanych


    import os
    from azure.ai.contentsafety import ContentSafetyClient
    from azure.core.credentials import AzureKeyCredential
    from azure.ai.contentsafety.models import AnalyzeTextOptions
    from azure.core.exceptions import HttpResponseError

    key = os.environ["CONTENT_SAFETY_KEY"]
    endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]

    # Create a Content Safety client
    client = ContentSafetyClient(endpoint, AzureKeyCredential(key))

    blocklist_name = "TestBlocklist"
    input_text = "I h*te you and I want to k*ll you."

    try:
        # After you edit your blocklist, it usually takes effect in 5 minutes, please wait some time before analyzing with blocklist after editing.
        analysis_result = client.analyze_text(
            AnalyzeTextOptions(text=input_text, blocklist_names=[blocklist_name], halt_on_blocklist_hit=False)
        )
        if analysis_result and analysis_result.blocklists_match:
            print("\nBlocklist match results: ")
            for match_result in analysis_result.blocklists_match:
                print(
                    f"BlocklistName: {match_result.blocklist_name}, BlockItemId: {match_result.blocklist_item_id}, "
                    f"BlockItemText: {match_result.blocklist_item_text}"
                )
    except HttpResponseError as e:
        print("\nAnalyze text failed: ")
        if e.error:
            print(f"Error code: {e.error.code}")
            print(f"Error message: {e.error.message}")
            raise
        print(e)
        raise

Analizowanie obrazu


    import os
    from azure.ai.contentsafety import ContentSafetyClient
    from azure.ai.contentsafety.models import ImageCategory
    from azure.core.credentials import AzureKeyCredential
    from azure.core.exceptions import HttpResponseError
    from azure.ai.contentsafety.models import AnalyzeImageOptions, ImageData

    key = os.environ["CONTENT_SAFETY_KEY"]
    endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]
    image_path = os.path.abspath(os.path.join(os.path.abspath(__file__), "..", "./sample_data/image.jpg"))

    # Create a Content Safety client
    client = ContentSafetyClient(endpoint, AzureKeyCredential(key))

    # Build request
    with open(image_path, "rb") as file:
        request = AnalyzeImageOptions(image=ImageData(content=file.read()))

    # Analyze image
    try:
        response = client.analyze_image(request)
    except HttpResponseError as e:
        print("Analyze image failed.")
        if e.error:
            print(f"Error code: {e.error.code}")
            print(f"Error message: {e.error.message}")
            raise
        print(e)
        raise

    hate_result = next(item for item in response.categories_analysis if item.category == ImageCategory.HATE)
    self_harm_result = next(item for item in response.categories_analysis if item.category == ImageCategory.SELF_HARM)
    sexual_result = next(item for item in response.categories_analysis if item.category == ImageCategory.SEXUAL)
    violence_result = next(item for item in response.categories_analysis if item.category == ImageCategory.VIOLENCE)

    if hate_result:
        print(f"Hate severity: {hate_result.severity}")
    if self_harm_result:
        print(f"SelfHarm severity: {self_harm_result.severity}")
    if sexual_result:
        print(f"Sexual severity: {sexual_result.severity}")
    if violence_result:
        print(f"Violence severity: {violence_result.severity}")

Zarządzanie listą bloków tekstowych

Tworzenie lub aktualizowanie listy bloków tekstu


    import os
    from azure.ai.contentsafety import BlocklistClient
    from azure.ai.contentsafety.models import TextBlocklist
    from azure.core.credentials import AzureKeyCredential
    from azure.core.exceptions import HttpResponseError

    key = os.environ["CONTENT_SAFETY_KEY"]
    endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]

    # Create a Blocklist client
    client = BlocklistClient(endpoint, AzureKeyCredential(key))

    blocklist_name = "TestBlocklist"
    blocklist_description = "Test blocklist management."

    try:
        blocklist = client.create_or_update_text_blocklist(
            blocklist_name=blocklist_name,
            options=TextBlocklist(blocklist_name=blocklist_name, description=blocklist_description),
        )
        if blocklist:
            print("\nBlocklist created or updated: ")
            print(f"Name: {blocklist.blocklist_name}, Description: {blocklist.description}")
    except HttpResponseError as e:
        print("\nCreate or update text blocklist failed: ")
        if e.error:
            print(f"Error code: {e.error.code}")
            print(f"Error message: {e.error.message}")
            raise
        print(e)
        raise

Lista bloków tekstowych


    import os
    from azure.ai.contentsafety import BlocklistClient
    from azure.core.credentials import AzureKeyCredential
    from azure.core.exceptions import HttpResponseError

    key = os.environ["CONTENT_SAFETY_KEY"]
    endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]

    # Create a Blocklist client
    client = BlocklistClient(endpoint, AzureKeyCredential(key))

    try:
        blocklists = client.list_text_blocklists()
        if blocklists:
            print("\nList blocklists: ")
            for blocklist in blocklists:
                print(f"Name: {blocklist.blocklist_name}, Description: {blocklist.description}")
    except HttpResponseError as e:
        print("\nList text blocklists failed: ")
        if e.error:
            print(f"Error code: {e.error.code}")
            print(f"Error message: {e.error.message}")
            raise
        print(e)
        raise

Pobieranie listy bloków tekstu


    import os
    from azure.ai.contentsafety import BlocklistClient
    from azure.core.credentials import AzureKeyCredential
    from azure.core.exceptions import HttpResponseError

    key = os.environ["CONTENT_SAFETY_KEY"]
    endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]

    # Create a Blocklist client
    client = BlocklistClient(endpoint, AzureKeyCredential(key))

    blocklist_name = "TestBlocklist"

    try:
        blocklist = client.get_text_blocklist(blocklist_name=blocklist_name)
        if blocklist:
            print("\nGet blocklist: ")
            print(f"Name: {blocklist.blocklist_name}, Description: {blocklist.description}")
    except HttpResponseError as e:
        print("\nGet text blocklist failed: ")
        if e.error:
            print(f"Error code: {e.error.code}")
            print(f"Error message: {e.error.message}")
            raise
        print(e)
        raise

Usuń listę bloków tekstowych


    import os
    from azure.ai.contentsafety import BlocklistClient
    from azure.core.credentials import AzureKeyCredential
    from azure.core.exceptions import HttpResponseError

    key = os.environ["CONTENT_SAFETY_KEY"]
    endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]

    # Create a Blocklist client
    client = BlocklistClient(endpoint, AzureKeyCredential(key))

    blocklist_name = "TestBlocklist"

    try:
        client.delete_text_blocklist(blocklist_name=blocklist_name)
        print(f"\nDeleted blocklist: {blocklist_name}")
    except HttpResponseError as e:
        print("\nDelete blocklist failed:")
        if e.error:
            print(f"Error code: {e.error.code}")
            print(f"Error message: {e.error.message}")
            raise
        print(e)
        raise

Dodawanie elementu blockItems


    import os
    from azure.ai.contentsafety import BlocklistClient
    from azure.ai.contentsafety.models import AddOrUpdateTextBlocklistItemsOptions, TextBlocklistItem
    from azure.core.credentials import AzureKeyCredential
    from azure.core.exceptions import HttpResponseError

    key = os.environ["CONTENT_SAFETY_KEY"]
    endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]

    # Create a Blocklist client
    client = BlocklistClient(endpoint, AzureKeyCredential(key))

    blocklist_name = "TestBlocklist"
    block_item_text_1 = "k*ll"
    block_item_text_2 = "h*te"

    block_items = [TextBlocklistItem(text=block_item_text_1), TextBlocklistItem(text=block_item_text_2)]
    try:
        result = client.add_or_update_blocklist_items(
            blocklist_name=blocklist_name, options=AddOrUpdateTextBlocklistItemsOptions(blocklist_items=block_items)
        )
        for block_item in result.blocklist_items:
            print(
                f"BlockItemId: {block_item.blocklist_item_id}, Text: {block_item.text}, Description: {block_item.description}"
            )
    except HttpResponseError as e:
        print("\nAdd block items failed: ")
        if e.error:
            print(f"Error code: {e.error.code}")
            print(f"Error message: {e.error.message}")
            raise
        print(e)
        raise

Lista bloków


    import os
    from azure.ai.contentsafety import BlocklistClient
    from azure.core.credentials import AzureKeyCredential
    from azure.core.exceptions import HttpResponseError

    key = os.environ["CONTENT_SAFETY_KEY"]
    endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]

    # Create a Blocklist client
    client = BlocklistClient(endpoint, AzureKeyCredential(key))

    blocklist_name = "TestBlocklist"

    try:
        block_items = client.list_text_blocklist_items(blocklist_name=blocklist_name)
        if block_items:
            print("\nList block items: ")
            for block_item in block_items:
                print(
                    f"BlockItemId: {block_item.blocklist_item_id}, Text: {block_item.text}, "
                    f"Description: {block_item.description}"
                )
    except HttpResponseError as e:
        print("\nList block items failed: ")
        if e.error:
            print(f"Error code: {e.error.code}")
            print(f"Error message: {e.error.message}")
            raise
        print(e)
        raise

Uzyskiwanie elementu blockItem


    import os
    from azure.ai.contentsafety import BlocklistClient
    from azure.core.credentials import AzureKeyCredential
    from azure.ai.contentsafety.models import TextBlocklistItem, AddOrUpdateTextBlocklistItemsOptions
    from azure.core.exceptions import HttpResponseError

    key = os.environ["CONTENT_SAFETY_KEY"]
    endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]

    # Create a Blocklist client
    client = BlocklistClient(endpoint, AzureKeyCredential(key))

    blocklist_name = "TestBlocklist"
    block_item_text_1 = "k*ll"

    try:
        # Add a blockItem
        add_result = client.add_or_update_blocklist_items(
            blocklist_name=blocklist_name,
            options=AddOrUpdateTextBlocklistItemsOptions(blocklist_items=[TextBlocklistItem(text=block_item_text_1)]),
        )
        if not add_result or not add_result.blocklist_items or len(add_result.blocklist_items) <= 0:
            raise RuntimeError("BlockItem not created.")
        block_item_id = add_result.blocklist_items[0].blocklist_item_id

        # Get this blockItem by blockItemId
        block_item = client.get_text_blocklist_item(blocklist_name=blocklist_name, blocklist_item_id=block_item_id)
        print("\nGet blockitem: ")
        print(
            f"BlockItemId: {block_item.blocklist_item_id}, Text: {block_item.text}, Description: {block_item.description}"
        )
    except HttpResponseError as e:
        print("\nGet block item failed: ")
        if e.error:
            print(f"Error code: {e.error.code}")
            print(f"Error message: {e.error.message}")
            raise
        print(e)
        raise

Usuń blokiItems


    import os
    from azure.ai.contentsafety import BlocklistClient
    from azure.core.credentials import AzureKeyCredential
    from azure.ai.contentsafety.models import (
        TextBlocklistItem,
        AddOrUpdateTextBlocklistItemsOptions,
        RemoveTextBlocklistItemsOptions,
    )
    from azure.core.exceptions import HttpResponseError

    key = os.environ["CONTENT_SAFETY_KEY"]
    endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]

    # Create a Blocklist client
    client = BlocklistClient(endpoint, AzureKeyCredential(key))

    blocklist_name = "TestBlocklist"
    block_item_text_1 = "k*ll"

    try:
        # Add a blockItem
        add_result = client.add_or_update_blocklist_items(
            blocklist_name=blocklist_name,
            options=AddOrUpdateTextBlocklistItemsOptions(blocklist_items=[TextBlocklistItem(text=block_item_text_1)]),
        )
        if not add_result or not add_result.blocklist_items or len(add_result.blocklist_items) <= 0:
            raise RuntimeError("BlockItem not created.")
        block_item_id = add_result.blocklist_items[0].blocklist_item_id

        # Remove this blockItem by blockItemId
        client.remove_blocklist_items(
            blocklist_name=blocklist_name, options=RemoveTextBlocklistItemsOptions(blocklist_item_ids=[block_item_id])
        )
        print(f"\nRemoved blockItem: {add_result.blocklist_items[0].blocklist_item_id}")
    except HttpResponseError as e:
        print("\nRemove block item failed: ")
        if e.error:
            print(f"Error code: {e.error.code}")
            print(f"Error message: {e.error.message}")
            raise
        print(e)
        raise

Rozwiązywanie problemów

Ogólne

Bezpieczeństwo zawartości platformy Azure AI biblioteka klienta zgłosi wyjątki zdefiniowane w usłudze Azure Core. Kody błędów są zdefiniowane w następujący sposób:

Kod błędu Możliwe przyczyny Sugestie
InvalidRequestBody Co najmniej jedno pole w treści żądania nie jest zgodne z definicją interfejsu API. 1. Sprawdź wersję interfejsu API określoną w wywołaniu interfejsu API.
2. Sprawdź odpowiednią definicję interfejsu API dla wybranej wersji interfejsu API.
InvalidResourceName Nazwa zasobu określona w adresie URL nie spełnia wymagań, takich jak nazwa listy blokowej, identyfikator terminu listy blokowej itp. 1. Sprawdź wersję interfejsu API określoną w wywołaniu interfejsu API.
2. Sprawdź, czy dana nazwa ma nieprawidłowe znaki zgodnie z definicją interfejsu API.
ResourceNotFound Zasób określony w adresie URL może nie istnieć, taki jak nazwa listy bloków. 1. Sprawdź wersję interfejsu API określoną w wywołaniu interfejsu API.
2. Dokładnie sprawdź istnienie zasobu określonego w adresie URL.
InternalError Niektóre nieoczekiwane sytuacje po stronie serwera zostały wyzwolone. 1. Możesz spróbować ponowić próbę kilka razy po małym okresie i zobaczyć, że problem występuje ponownie.
2. Skontaktuj się z pomocą techniczną platformy Azure, jeśli ten problem będzie się powtarzać.
ServerBusy Po stronie serwera nie można tymczasowo przetworzyć żądania. 1. Możesz spróbować ponowić próbę kilka razy po małym okresie i zobaczyć, że problem występuje ponownie.
2.Skontaktuj się z pomocą techniczną platformy Azure, jeśli ten problem będzie się powtarzać.
TooManyRequests Bieżąca usługa RPS przekroczyła limit przydziału dla bieżącej jednostki SKU. 1. Sprawdź tabelę cenową, aby zrozumieć limit przydziału usługi RPS.
2.Skontaktuj się z pomocą techniczną platformy Azure, jeśli potrzebujesz większej liczby QPS.

Rejestrowanie

Ta biblioteka używa standardowej biblioteki rejestrowania do rejestrowania.

Podstawowe informacje o sesjach HTTP (adresach URL, nagłówkach itp.) są rejestrowane na INFO poziomie.

Szczegółowe DEBUG rejestrowanie na poziomie, w tym treści żądań/odpowiedzi i nieredagowanych nagłówków, można włączyć na kliencie lub na operację za pomocą argumentu słowa kluczowego logging_enable .

Zobacz pełną dokumentację rejestrowania zestawu SDK z przykładami tutaj.

Konfiguracja opcjonalna

Opcjonalne argumenty słów kluczowych można przekazać na poziomie klienta i na poziomie operacji. W dokumentacji referencyjnej platformy Azure opisano dostępne konfiguracje ponownych prób, rejestrowania, protokołów transportowych i nie tylko.

Następne kroki

Dodatkowa dokumentacja

Aby uzyskać bardziej obszerną dokumentację dotyczącą zabezpieczeń zawartości platformy Azure, zobacz Bezpieczeństwo zawartości platformy Azure AI w docs.microsoft.com.

Współtworzenie

W tym projekcie zachęcamy do współtworzenia i zgłaszania sugestii. Współtworzenie w większości przypadków wymaga zgody na umowę licencyjną dotyczącą współautorów (CLA, Contributor License Agreement), zgodnie z którą współautor ma prawo udzielić i faktycznie udziela nam praw do używania wytworzonej przez siebie zawartości. Aby uzyskać szczegółowe informacje, odwiedź stronę https://cla.microsoft.com.

Po przesłaniu żądania ściągnięcia robot CLA automatycznie określi, czy musisz przekazać umowę CLA, i doda odpowiednie informacje do tego żądania (na przykład etykietę czy komentarz). Po prostu postępuj zgodnie z instrukcjami robota. Wystarczy zrobić to raz dla wszystkich repozytoriów, w przypadku których jest używana nasza umowa CLA.

W tym projekcie przyjęto Kodeks postępowania oprogramowania Open Source firmy Microsoft. Aby uzyskać więcej informacji, zobacz artykuł Code of Conduct FAQ (Często zadawane pytania dotyczące kodeksu postępowania). Jeśli będziesz mieć jeszcze jakieś pytania lub komentarze, wyślij wiadomość e-mail na adres opencode@microsoft.com.