Klientská knihovna Azure Analýza textu pro Python – verze 5.3.0

  • Článek

Azure Cognitive Service for Language je cloudová služba, která poskytuje funkce zpracování přirozeného jazyka (NLP) pro pochopení a analýzu textu a obsahuje následující hlavní funkce:

  • Analýza mínění
  • Rozpoznávání pojmenovaných entit
  • Rozpoznávání jazyka
  • Extrakce klíčových frází
  • Entity Linking
  • Vícenásobná analýza
  • Detekce identifikovatelných osobních údajů
  • Analýza textu pro zdravotnictví
  • Vlastní rozpoznávání pojmenovaných entit
  • Vlastní klasifikace textu
  • Shrnutí extrahovaného textu
  • Shrnutí abstraktního textu

Zdrojový kód | Balíček (PyPI) | Balíček (Conda) | Referenční dokumentace k | rozhraní APIDokumentace k | produktuVzorky

Začínáme

Požadavky

Vytvoření prostředku služby Cognitive Services nebo jazykové služby

Služba Language podporuje přístup k více službám i k přístupu s jednou službou. Pokud plánujete přístup k více kognitivním službám v rámci jednoho koncového bodu nebo klíče, vytvořte prostředek Cognitive Services. Pouze pro přístup ke službě jazyka vytvořte prostředek služby jazyka. Prostředek můžete vytvořit pomocí webu Azure Portal nebo Azure CLI podle kroků v tomto dokumentu.

Interakce se službou pomocí klientské knihovny začíná klientem . K vytvoření objektu klienta budete potřebovat službu Cognitive Services nebo Language pro váš prostředek a credential službuendpoint, která vám umožní přístup k:

from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

credential = AzureKeyCredential("<api_key>")
text_analytics_client = TextAnalyticsClient(endpoint="https://<resource-name>.cognitiveservices.azure.com/", credential=credential)

Všimněte si, že u některých prostředků služeb Cognitive Services může koncový bod vypadat jinak než výše uvedený fragment kódu. Například, https://<region>.api.cognitive.microsoft.com/.

Instalace balíčku

Nainstalujte klientskou knihovnu Azure Analýza textu pro Python pomocí pipu:

pip install azure-ai-textanalytics

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient
endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]

text_analytics_client = TextAnalyticsClient(endpoint, AzureKeyCredential(key))

Všimněte si, že 5.2.X a novější cílí na rozhraní AZURE Cognitive Service for Language API. Tato rozhraní API zahrnují funkce pro analýzu textu a zpracování přirozeného jazyka, které najdete v předchozích verzích klientské knihovny Analýza textu. Kromě toho se rozhraní API služby změnilo ze sémantických verzí na správu verzí na základě data. Tato verze klientské knihovny má ve výchozím nastavení nejnovější podporovanou verzi rozhraní API, která je 2023-04-01aktuálně .

Tato tabulka ukazuje vztah mezi verzemi sady SDK a podporovanými verzemi rozhraní API služby.

SDK version (Verze sady SDK) Podporovaná verze služby ROZHRANÍ API
5.3.X – nejnovější stabilní verze 3.0, 3.1, 2022-05-01, 2023-04-01 (výchozí)
5.2.X 3.0, 3.1, 2022-05-01 (výchozí)
5.1.0 3.0, 3.1 (výchozí)
5.0.0 3.0

Verzi rozhraní API je možné vybrat předáním argumentu api_version klíčového slova do klienta. U nejnovějších funkcí služby Language zvažte výběr nejnovější beta verze rozhraní API. Pro produkční scénáře se doporučuje nejnovější stabilní verze. Nastavení na starší verzi může mít za následek snížení kompatibility funkcí.

Ověření klienta

Získání koncového bodu

Koncový bod pro prostředek jazykové služby můžete najít pomocí webu Azure Portal nebo Azure CLI:

# Get the endpoint for the Language service resource
az cognitiveservices account show --name "resource-name" --resource-group "resource-group-name" --query "properties.endpoint"

Získání klíče rozhraní API

Klíč rozhraní API můžete získat z prostředku služeb Cognitive Services nebo Language Service na webu Azure Portal. Případně můžete pomocí fragmentu kódu Azure CLI níže získat klíč rozhraní API vašeho prostředku.

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

Vytvoření Objektu TextAnalyticsClient s přihlašovacími údaji klíče rozhraní API

Jakmile budete mít hodnotu pro klíč rozhraní API, můžete ho předat jako řetězec do instance AzureKeyCredential. K ověření klienta použijte klíč jako parametr přihlašovacích údajů:

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient
endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]

text_analytics_client = TextAnalyticsClient(endpoint, AzureKeyCredential(key))

Vytvoření objektu TextAnalyticsClient s přihlašovacími údaji Azure Active Directory

Pokud chcete použít přihlašovací údaje tokenu Azure Active Directory (AAD), zadejte instanci požadovaného typu přihlašovacích údajů získaného z knihovny azure-identity . Upozorňujeme, že místní koncové body nepodporují ověřování AAD. Vytvořte vlastní název subdomény pro váš prostředek, abyste mohli použít tento typ ověřování.

Ověřování pomocí AAD vyžaduje počáteční nastavení:

Po nastavení můžete zvolit, který typ přihlašovacích údajů z azure.identity chcete použít. Jako příklad lze k ověření klienta použít DefaultAzureCredential :

Nastavte hodnoty ID klienta, ID tenanta a tajného klíče klienta aplikace AAD jako proměnné prostředí: AZURE_CLIENT_ID, AZURE_TENANT_ID AZURE_CLIENT_SECRET

K ověření klienta použijte vrácené přihlašovací údaje tokenu:

import os
from azure.ai.textanalytics import TextAnalyticsClient
from azure.identity import DefaultAzureCredential

endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
credential = DefaultAzureCredential()

text_analytics_client = TextAnalyticsClient(endpoint, credential=credential)

Klíčové koncepty

TextAnalyticsClient

Klientská knihovna Analýza textu poskytuje TextAnalyticsClient pro analýzu v dávkách dokumentů. Poskytuje synchronní i asynchronní operace pro přístup ke konkrétnímu použití analýzy textu, jako je rozpoznávání jazyka nebo extrakce klíčových frází.

Vstup

Dokument je jedna jednotka, kterou mají analyzovat prediktivní modely ve službě Language. Vstup pro každou operaci se předává jako seznam dokumentů.

Každý dokument je možné předat jako řetězec v seznamu, např.

documents = ["I hated the movie. It was so slow!", "The movie made it into my top ten favorites. What a great movie!"]

nebo pokud chcete předat dokument id pro jednotlivé položky nebo languagecountry_hint/, mohou být předány jako seznam DetectLanguageInput nebo TextDocumentInput nebo jako diktování reprezentace objektu:

documents = [
    {"id": "1", "language": "en", "text": "I hated the movie. It was so slow!"},
    {"id": "2", "language": "en", "text": "The movie made it into my top ten favorites. What a great movie!"},
]

Projděte si omezení služby pro vstup, včetně omezení délky dokumentu, maximální velikosti dávky a podporovaného kódování textu.

Návratová hodnota

Vrácenou hodnotou pro jeden dokument může být výsledek nebo objekt chyby. Z každé operace se vrátí heterogenní seznam obsahující kolekci objektů výsledků a chyb. Tyto výsledky nebo chyby jsou indexovány podle pořadí poskytnutých dokumentů.

Výsledek, například AnalyzeSentimentResult, je výsledkem operace textové analýzy a obsahuje predikci nebo předpovědi týkající se vstupu do dokumentu.

Objekt chybyDocumentError označuje, že služba měla potíže se zpracováním dokumentu, a obsahuje důvod neúspěchu.

Zpracování chyb dokumentu

Pomocí atributu můžete filtrovat objekt výsledku nebo chyby v seznamu is_error . U objektu výsledku je to vždy False a u chyby DocumentError je Trueto .

Pokud chcete například vyfiltrovat všechny chyby DocumentError, můžete použít porozumění seznamu:

response = text_analytics_client.analyze_sentiment(documents)
successful_responses = [doc for doc in response if not doc.is_error]

Atribut můžete použít kind také k filtrování mezi typy výsledků:

poller = text_analytics_client.begin_analyze_actions(documents, actions)
response = poller.result()
for result in response:
    if result.kind == "SentimentAnalysis":
        print(f"Sentiment is {result.sentiment}")
    elif result.kind == "KeyPhraseExtraction":
        print(f"Key phrases: {result.key_phrases}")
    elif result.is_error is True:
        print(f"Document error: {result.code}, {result.message}")

operace Long-Running

Dlouhotrvající operace jsou operace, které se skládají z počátečního požadavku odeslaného službě na spuštění operace a následného dotazování služby v intervalech, aby se zjistilo, jestli se operace dokončila nebo selhala, a pokud byla úspěšná, aby se získal výsledek.

Metody, které podporují analýzu zdravotní péče, vlastní analýzu textu nebo více analýz, se modelují jako dlouhotrvající operace. Klient zveřejňuje metodu begin_<method-name> , která vrací objekt poller. Volající by měli počkat na dokončení operace voláním result() objektu poller vráceného begin_<method-name> z metody. Ukázkové fragmenty kódu jsou k dispozici pro ilustraci použití dlouhotrvajících operací níže.

Příklady

Následující část obsahuje několik fragmentů kódu, které pokrývají některé z nejběžnějších úloh služby Language, mezi které patří:

Analýza mínění

analyze_sentiment se podívá na vstupní text a určí, jestli je jeho mínění kladné, záporné, neutrální nebo smíšené. Její odpověď zahrnuje analýzu mínění pro jednotlivé věty a skóre spolehlivosti.

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]

text_analytics_client = TextAnalyticsClient(endpoint=endpoint, credential=AzureKeyCredential(key))

documents = [
    """I had the best day of my life. I decided to go sky-diving and it made me appreciate my whole life so much more.
    I developed a deep-connection with my instructor as well, and I feel as if I've made a life-long friend in her.""",
    """This was a waste of my time. All of the views on this drop are extremely boring, all I saw was grass. 0/10 would
    not recommend to any divers, even first timers.""",
    """This was pretty good! The sights were ok, and I had fun with my instructors! Can't complain too much about my experience""",
    """I only have one word for my experience: WOW!!! I can't believe I have had such a wonderful skydiving company right
    in my backyard this whole time! I will definitely be a repeat customer, and I want to take my grandmother skydiving too,
    I know she'll love it!"""
]


result = text_analytics_client.analyze_sentiment(documents, show_opinion_mining=True)
docs = [doc for doc in result if not doc.is_error]

print("Let's visualize the sentiment of each of these documents")
for idx, doc in enumerate(docs):
    print(f"Document text: {documents[idx]}")
    print(f"Overall sentiment: {doc.sentiment}")

Vrácená odpověď je heterogenní seznam objektů výsledku a chyb: list[AnalyzeSentimentResult, DocumentError]

Koncepční diskuzi o analýze mínění najdete v dokumentaci ke službě. Pokud chcete zjistit, jak provést podrobnější analýzu názorů souvisejících s jednotlivými aspekty (například atributy produktu nebo služby) v textu, podívejte se tady.

Rozpoznávání entit

recognize_entities ve svém vstupním textu rozpozná a zatěžuje entity jako osoby, místa, organizace, datum a čas, množství, procenta, měny a další.

import os
import typing
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]

text_analytics_client = TextAnalyticsClient(endpoint=endpoint, credential=AzureKeyCredential(key))
reviews = [
    """I work for Foo Company, and we hired Contoso for our annual founding ceremony. The food
    was amazing and we all can't say enough good words about the quality and the level of service.""",
    """We at the Foo Company re-hired Contoso after all of our past successes with the company.
    Though the food was still great, I feel there has been a quality drop since their last time
    catering for us. Is anyone else running into the same problem?""",
    """Bar Company is over the moon about the service we received from Contoso, the best sliders ever!!!!"""
]

result = text_analytics_client.recognize_entities(reviews)
result = [review for review in result if not review.is_error]
organization_to_reviews: typing.Dict[str, typing.List[str]] = {}

for idx, review in enumerate(result):
    for entity in review.entities:
        print(f"Entity '{entity.text}' has category '{entity.category}'")
        if entity.category == 'Organization':
            organization_to_reviews.setdefault(entity.text, [])
            organization_to_reviews[entity.text].append(reviews[idx])

for organization, reviews in organization_to_reviews.items():
    print(
        "\n\nOrganization '{}' has left us the following review(s): {}".format(
            organization, "\n\n".join(reviews)
        )
    )

Vrácená odpověď je heterogenní seznam objektů výsledku a chyb: list[RecognizeEntitiesResult, DocumentError]

Koncepční diskuzi o rozpoznávání pojmenovaných entit a podporovaných typech najdete v dokumentaci ke službě.

Rozpoznávání propojených entit

recognize_linked_entities rozpoznává a nejednoznačuje identitu každé entity nalezené ve vstupním textu (například určuje, zda výskyt slova Mars odkazuje na planetu nebo na římského boha války). Rozpoznané entity jsou přidružené k adresám URL k dobře známému znalostní báze, jako je Wikipedie.

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]

text_analytics_client = TextAnalyticsClient(endpoint=endpoint, credential=AzureKeyCredential(key))
documents = [
    """
    Microsoft was founded by Bill Gates with some friends he met at Harvard. One of his friends,
    Steve Ballmer, eventually became CEO after Bill Gates as well. Steve Ballmer eventually stepped
    down as CEO of Microsoft, and was succeeded by Satya Nadella.
    Microsoft originally moved its headquarters to Bellevue, Washington in January 1979, but is now
    headquartered in Redmond.
    """
]

result = text_analytics_client.recognize_linked_entities(documents)
docs = [doc for doc in result if not doc.is_error]

print(
    "Let's map each entity to it's Wikipedia article. I also want to see how many times each "
    "entity is mentioned in a document\n\n"
)
entity_to_url = {}
for doc in docs:
    for entity in doc.entities:
        print("Entity '{}' has been mentioned '{}' time(s)".format(
            entity.name, len(entity.matches)
        ))
        if entity.data_source == "Wikipedia":
            entity_to_url[entity.name] = entity.url

Vrácená odpověď je heterogenní seznam objektů výsledku a chyb: list[RecognizeLinkedEntitiesResult, DocumentError]

Koncepční diskuzi o propojení entit a podporovaných typech najdete v dokumentaci ke službě.

Rozpoznávání entit PII

recognize_pii_entities ve svém vstupním textu rozpozná a zařadí entity identifikovatelných osobních údajů (PII), jako jsou čísla sociálního pojištění, informace o bankovním účtu, čísla platebních karet a další.

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]

text_analytics_client = TextAnalyticsClient(
    endpoint=endpoint, credential=AzureKeyCredential(key)
)
documents = [
    """Parker Doe has repaid all of their loans as of 2020-04-25.
    Their SSN is 859-98-0987. To contact them, use their phone number
    555-555-5555. They are originally from Brazil and have Brazilian CPF number 998.214.865-68"""
]

result = text_analytics_client.recognize_pii_entities(documents)
docs = [doc for doc in result if not doc.is_error]

print(
    "Let's compare the original document with the documents after redaction. "
    "I also want to comb through all of the entities that got redacted"
)
for idx, doc in enumerate(docs):
    print(f"Document text: {documents[idx]}")
    print(f"Redacted document text: {doc.redacted_text}")
    for entity in doc.entities:
        print("...Entity '{}' with category '{}' got redacted".format(
            entity.text, entity.category
        ))

Vrácená odpověď je heterogenní seznam objektů výsledků a chyb: list[RecognizePiiEntitiesResult, DocumentError]

Podporované typy entit pii najdete v dokumentaci ke službě.

Poznámka: Služba Recognize PII Entities je k dispozici v rozhraní API verze 3.1 a novějších.

Extrakce klíčových frází

extract_key_phrases určuje hlavní body ve vstupním textu. Například pro vstupní text "Jídlo bylo chutné a tam byl skvělý personál", rozhraní API vrátí: "jídlo" a "báječný personál".

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]

text_analytics_client = TextAnalyticsClient(endpoint=endpoint, credential=AzureKeyCredential(key))
articles = [
    """
    Washington, D.C. Autumn in DC is a uniquely beautiful season. The leaves fall from the trees
    in a city chock-full of forests, leaving yellow leaves on the ground and a clearer view of the
    blue sky above...
    """,
    """
    Redmond, WA. In the past few days, Microsoft has decided to further postpone the start date of
    its United States workers, due to the pandemic that rages with no end in sight...
    """,
    """
    Redmond, WA. Employees at Microsoft can be excited about the new coffee shop that will open on campus
    once workers no longer have to work remotely...
    """
]

result = text_analytics_client.extract_key_phrases(articles)
for idx, doc in enumerate(result):
    if not doc.is_error:
        print("Key phrases in article #{}: {}".format(
            idx + 1,
            ", ".join(doc.key_phrases)
        ))

Vrácená odpověď je heterogenní seznam objektů výsledku a chyb: list[ExtractKeyPhrasesResult, DocumentError]

Koncepční diskuzi o extrakci klíčových frází najdete v dokumentaci ke službě.

Rozpoznání jazyka

detect_language určuje jazyk vstupního textu, včetně skóre spolehlivosti predikovaného jazyka.

import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient

endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]

text_analytics_client = TextAnalyticsClient(endpoint=endpoint, credential=AzureKeyCredential(key))
documents = [
    """
    The concierge Paulette was extremely helpful. Sadly when we arrived the elevator was broken, but with Paulette's help we barely noticed this inconvenience.
    She arranged for our baggage to be brought up to our room with no extra charge and gave us a free meal to refurbish all of the calories we lost from
    walking up the stairs :). Can't say enough good things about my experience!
    """,
    """
    最近由于工作压力太大，我们决定去富酒店度假。那儿的温泉实在太舒服了，我跟我丈夫都完全恢复了工作前的青春精神！加油！
    """
]

result = text_analytics_client.detect_language(documents)
reviewed_docs = [doc for doc in result if not doc.is_error]

print("Let's see what language each review is in!")

for idx, doc in enumerate(reviewed_docs):
    print("Review #{} is in '{}', which has ISO639-1 name '{}'\n".format(
        idx, doc.primary_language.name, doc.primary_language.iso6391_name
    ))

Vrácená odpověď je heterogenní seznam objektů výsledků a chyb: list[DetectLanguageResult, DocumentError]

Koncepční diskuzi o rozpoznávání jazyka a podpoře jazyka a oblasti najdete v dokumentaci ke službě.

Analýza zdravotnických entit

Dlouhotrvající operacebegin_analyze_healthcare_entities extrahuje entity rozpoznané v rámci domény zdravotnictví a identifikuje vztahy mezi entitami v rámci vstupního dokumentu a odkazuje na známé zdroje informací v různých dobře známých databázích, jako je UMLS, CHV, MSH atd.

import os
import typing
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import TextAnalyticsClient, HealthcareEntityRelation

endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]

text_analytics_client = TextAnalyticsClient(
    endpoint=endpoint,
    credential=AzureKeyCredential(key),
)

documents = [
    """
    Patient needs to take 100 mg of ibuprofen, and 3 mg of potassium. Also needs to take
    10 mg of Zocor.
    """,
    """
    Patient needs to take 50 mg of ibuprofen, and 2 mg of Coumadin.
    """
]

poller = text_analytics_client.begin_analyze_healthcare_entities(documents)
result = poller.result()

docs = [doc for doc in result if not doc.is_error]

print("Let's first visualize the outputted healthcare result:")
for doc in docs:
    for entity in doc.entities:
        print(f"Entity: {entity.text}")
        print(f"...Normalized Text: {entity.normalized_text}")
        print(f"...Category: {entity.category}")
        print(f"...Subcategory: {entity.subcategory}")
        print(f"...Offset: {entity.offset}")
        print(f"...Confidence score: {entity.confidence_score}")
        if entity.data_sources is not None:
            print("...Data Sources:")
            for data_source in entity.data_sources:
                print(f"......Entity ID: {data_source.entity_id}")
                print(f"......Name: {data_source.name}")
        if entity.assertion is not None:
            print("...Assertion:")
            print(f"......Conditionality: {entity.assertion.conditionality}")
            print(f"......Certainty: {entity.assertion.certainty}")
            print(f"......Association: {entity.assertion.association}")
    for relation in doc.entity_relations:
        print(f"Relation of type: {relation.relation_type} has the following roles")
        for role in relation.roles:
            print(f"...Role '{role.name}' with entity '{role.entity.text}'")
    print("------------------------------------------")

print("Now, let's get all of medication dosage relations from the documents")
dosage_of_medication_relations = [
    entity_relation
    for doc in docs
    for entity_relation in doc.entity_relations if entity_relation.relation_type == HealthcareEntityRelation.DOSAGE_OF_MEDICATION
]

Poznámka: Analýza zdravotnických entit je k dispozici pouze s rozhraním API verze 3.1 a novější.

Vícenásobná analýza

Dlouhotrvající operacebegin_analyze_actions provádí více analýz v rámci jedné sady dokumentů v jednom požadavku. V současné době se podporuje pomocí jakékoli kombinace následujících jazykových rozhraní API v jednom požadavku:

  • Rozpoznávání entit
  • Rozpoznávání entit PII
  • Rozpoznávání propojených entit
  • Extrakce klíčových frází
  • Analýza mínění
  • Vlastní rozpoznávání entit (rozhraní API verze 2022-05-01 a novější)
  • Vlastní klasifikace s jedním popiskem (rozhraní API verze 2022-05-01 a novější)
  • Vlastní klasifikace více popisků (rozhraní API verze 2022-05-01 a novější)
  • Healthcare Entities Analysis (rozhraní API verze 2022-05-01 a novější)
  • Extrahované shrnutí (rozhraní API verze 2023-04-01 a novější)
  • Abstrakce shrnutí (rozhraní API verze 2023-04-01 a novější)
import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.textanalytics import (
    TextAnalyticsClient,
    RecognizeEntitiesAction,
    RecognizeLinkedEntitiesAction,
    RecognizePiiEntitiesAction,
    ExtractKeyPhrasesAction,
    AnalyzeSentimentAction,
)

endpoint = os.environ["AZURE_LANGUAGE_ENDPOINT"]
key = os.environ["AZURE_LANGUAGE_KEY"]

text_analytics_client = TextAnalyticsClient(
    endpoint=endpoint,
    credential=AzureKeyCredential(key),
)

documents = [
    'We went to Contoso Steakhouse located at midtown NYC last week for a dinner party, and we adore the spot! '
    'They provide marvelous food and they have a great menu. The chief cook happens to be the owner (I think his name is John Doe) '
    'and he is super nice, coming out of the kitchen and greeted us all.'
    ,

    'We enjoyed very much dining in the place! '
    'The Sirloin steak I ordered was tender and juicy, and the place was impeccably clean. You can even pre-order from their '
    'online menu at www.contososteakhouse.com, call 312-555-0176 or send email to order@contososteakhouse.com! '
    'The only complaint I have is the food didn\'t come fast enough. Overall I highly recommend it!'
]

poller = text_analytics_client.begin_analyze_actions(
    documents,
    display_name="Sample Text Analysis",
    actions=[
        RecognizeEntitiesAction(),
        RecognizePiiEntitiesAction(),
        ExtractKeyPhrasesAction(),
        RecognizeLinkedEntitiesAction(),
        AnalyzeSentimentAction(),
    ],
)

document_results = poller.result()
for doc, action_results in zip(documents, document_results):
    print(f"\nDocument text: {doc}")
    for result in action_results:
        if result.kind == "EntityRecognition":
            print("...Results of Recognize Entities Action:")
            for entity in result.entities:
                print(f"......Entity: {entity.text}")
                print(f".........Category: {entity.category}")
                print(f".........Confidence Score: {entity.confidence_score}")
                print(f".........Offset: {entity.offset}")

        elif result.kind == "PiiEntityRecognition":
            print("...Results of Recognize PII Entities action:")
            for pii_entity in result.entities:
                print(f"......Entity: {pii_entity.text}")
                print(f".........Category: {pii_entity.category}")
                print(f".........Confidence Score: {pii_entity.confidence_score}")

        elif result.kind == "KeyPhraseExtraction":
            print("...Results of Extract Key Phrases action:")
            print(f"......Key Phrases: {result.key_phrases}")

        elif result.kind == "EntityLinking":
            print("...Results of Recognize Linked Entities action:")
            for linked_entity in result.entities:
                print(f"......Entity name: {linked_entity.name}")
                print(f".........Data source: {linked_entity.data_source}")
                print(f".........Data source language: {linked_entity.language}")
                print(
                    f".........Data source entity ID: {linked_entity.data_source_entity_id}"
                )
                print(f".........Data source URL: {linked_entity.url}")
                print(".........Document matches:")
                for match in linked_entity.matches:
                    print(f"............Match text: {match.text}")
                    print(f"............Confidence Score: {match.confidence_score}")
                    print(f"............Offset: {match.offset}")
                    print(f"............Length: {match.length}")

        elif result.kind == "SentimentAnalysis":
            print("...Results of Analyze Sentiment action:")
            print(f"......Overall sentiment: {result.sentiment}")
            print(
                f"......Scores: positive={result.confidence_scores.positive}; \
                neutral={result.confidence_scores.neutral}; \
                negative={result.confidence_scores.negative} \n"
            )

        elif result.is_error is True:
            print(
                f"...Is an error with code '{result.error.code}' and message '{result.error.message}'"
            )

    print("------------------------------------------")

Vrácená odpověď je objekt zapouzdřující více iterovatelných objektů, z nichž každá představuje výsledky jednotlivých analýz.

Poznámka: Ve verzi rozhraní API v3.1 a novějších je k dispozici více analýz.

Volitelná konfigurace

Volitelné argumenty klíčových slov je možné předat na úrovni klienta a pro jednotlivé operace. Referenční dokumentace azure-core popisuje dostupné konfigurace pro opakování, protokolování, přenosové protokoly a další.

Řešení potíží

Obecné

Klient Analýza textu vyvolá výjimky definované v Azure Core.

protokolování

Tato knihovna používá k protokolování standardní knihovnu protokolování . Základní informace o relacích HTTP (adresy URL, hlavičky atd.) se protokolují na úrovni INFO.

Podrobné protokolování úrovně DEBUG, včetně těl požadavků/odpovědí a nezopravovaných hlaviček, je možné povolit v klientovi s argumentem klíčového logging_enable slova:

import sys
import logging
from azure.identity import DefaultAzureCredential
from azure.ai.textanalytics import TextAnalyticsClient

# Create a logger for the 'azure' SDK
logger = logging.getLogger('azure')
logger.setLevel(logging.DEBUG)

# Configure a console output
handler = logging.StreamHandler(stream=sys.stdout)
logger.addHandler(handler)

endpoint = "https://<resource-name>.cognitiveservices.azure.com/"
credential = DefaultAzureCredential()

# This client will log detailed information about its HTTP sessions, at DEBUG level
text_analytics_client = TextAnalyticsClient(endpoint, credential, logging_enable=True)
result = text_analytics_client.analyze_sentiment(["I did not like the restaurant. The food was too spicy."])

Podobně logging_enable může povolit podrobné protokolování pro jednu operaci, i když není povolené pro klienta:

result = text_analytics_client.analyze_sentiment(documents, logging_enable=True)

Další kroky

Další vzorový kód

Tyto ukázky kódu ukazují operace běžných scénářů s klientskou knihovnou Azure Analýza textu.

Ověřte klienta pomocí klíče rozhraní API služeb Cognitive Services nebo jazykové služby nebo přihlašovacích údajů tokenu z azure-identity:

Obvyklé scénáře

Pokročilé scénáře

Další dokumentace

Rozsáhlejší dokumentaci ke službě Azure Cognitive Service pro jazyk najdete v dokumentaci ke službě Language Service na docs.microsoft.com.

Přispívání

Tento projekt vítá příspěvky a návrhy. Většina příspěvků vyžaduje souhlas s licenční smlouvou s přispěvatelem (CLA), která stanoví, že máte právo udělit nám práva k používání vašeho příspěvku a skutečně tak činíte. Podrobnosti najdete v cla.microsoft.com.

Při odesílání žádosti o přijetí změn robot CLA automaticky určí, jestli je potřeba poskytnout smlouvu CLA, a příslušným způsobem žádost o přijetí změn upraví (např. přidáním jmenovky nebo komentáře). Stačí postupovat podle pokynů robota. Pro všechna úložiště používající naši smlouvu CLA to stačí udělat jenom jednou.

Tento projekt přijal pravidla chování pro Microsoft Open Source. Další informace najdete v nejčastějších dotazech k pravidlům chování nebo se obraťte na opencode@microsoft.com případné další dotazy nebo komentáře.