Udostępnij za pośrednictwem

Biblioteka klienta analizy dokumentów usługi Azure AI dla języka Python — wersja 1.0.0b1

  • Artykuł

Azure AI Document Intelligence (wcześniej znana jako Form Recognizer) to usługa w chmurze, która korzysta z uczenia maszynowego do analizowania tekstu i danych strukturalnych z dokumentów. Zawiera ona następujące główne funkcje:

  • Układ — wyodrębnianie zawartości i struktury (np. wyrazów, znaczników zaznaczenia, tabel) z dokumentów.
  • Dokument — analizowanie par klucz-wartość oprócz ogólnego układu z dokumentów.
  • Odczyt — odczyt informacji o stronie z dokumentów.
  • Wstępnie utworzone — wyodrębnianie wspólnych wartości pól z wybranych typów dokumentów (np. paragonów, faktur, wizytówek, dokumentów identyfikacyjnych, dokumentów podatkowych w USA W-2, między innymi) przy użyciu wstępnie utworzonych modeli.
  • Niestandardowe — twórz modele niestandardowe z własnych danych, aby wyodrębniać dostosowane wartości pól oprócz ogólnego układu z dokumentów.
  • Klasyfikatory — twórz niestandardowe modele klasyfikacji, które łączą funkcje układu i języka w celu dokładnego wykrywania i identyfikowania dokumentów przetwarzanych w aplikacji.
  • Możliwości dodatku — wyodrębnianie kodów kreskowych/kodów QR, formuł, czcionki/stylu itp. lub włączanie trybu wysokiej rozdzielczości dla dużych dokumentów z opcjonalnymi parametrami.

Wprowadzenie

Instalowanie pakietu

python -m pip install azure-ai-documentintelligence

Wymagania wstępne

  • Do korzystania z tego pakietu jest wymagany język Python w wersji 3.7 lub nowszej.
  • Do korzystania z tego pakietu potrzebna jest subskrypcja platformy Azure .
  • Istniejące wystąpienie analizy dokumentów usługi Azure AI.

Tworzenie zasobu usług Cognitive Services lub analizy dokumentów

Analiza dokumentów obsługuje zarówno dostęp do wielu usług, jak i z jedną usługą. Utwórz zasób usług Cognitive Services, jeśli planujesz dostęp do wielu usług Cognitive Services w ramach jednego punktu końcowego/klucza. W przypadku dostępu tylko do analizy dokumentów utwórz zasób analizy dokumentów. Należy pamiętać, że jeśli zamierzasz używać uwierzytelniania usługi Azure Active Directory, potrzebny będzie zasób z jedną usługą.

Możesz utworzyć dowolny zasób przy użyciu:

Poniżej przedstawiono przykład tworzenia zasobu analizy dokumentów przy użyciu interfejsu wiersza polecenia:

# Create a new resource group to hold the Document Intelligence resource
# if using an existing resource group, skip this step
az group create --name <your-resource-name> --location <location>

# Create the Document Intelligence resource
az cognitiveservices account create \
    --name <your-resource-name> \
    --resource-group <your-resource-group-name> \
    --kind FormRecognizer \
    --sku <sku> \
    --location <location> \
    --yes

Aby uzyskać więcej informacji na temat tworzenia zasobu lub sposobu uzyskiwania informacji o lokalizacji i jednostce SKU, zobacz tutaj.

Uwierzytelnianie klienta

Aby wchodzić w interakcje z usługą Analizy dokumentów, należy utworzyć wystąpienie klienta. Punkt końcowy i poświadczenia są niezbędne do utworzenia wystąpienia obiektu klienta.

Uzyskiwanie punktu końcowego

Punkt końcowy zasobu analizy dokumentów można znaleźć za pomocą witryny Azure Portal lub interfejsu wiersza polecenia platformy Azure:

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

Do uwierzytelniania można użyć regionalnego punktu końcowego lub poddomeny niestandardowej. Są one sformatowane w następujący sposób:

Regional endpoint: https://<region>.api.cognitive.microsoft.com/
Custom subdomain: https://<resource-name>.cognitiveservices.azure.com/

Regionalny punkt końcowy jest taki sam dla każdego zasobu w regionie. Pełną listę obsługiwanych regionalnych punktów końcowych można znaleźć tutaj. Należy pamiętać, że regionalne punkty końcowe nie obsługują uwierzytelniania usługi AAD.

Z drugiej strony niestandardowa poddomena to nazwa unikatowa dla zasobu analiza dokumentów. Mogą być używane tylko przez zasoby z jedną usługą.

Pobieranie klucza interfejsu API

Klucz interfejsu API można znaleźć w witrynie Azure Portal lub uruchamiając następujące polecenie interfejsu wiersza polecenia platformy Azure:

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

Tworzenie klienta za pomocą elementu AzureKeyCredential

Aby użyć klucza interfejsu API jako parametru credential , przekaż klucz jako ciąg do wystąpienia obiektu AzureKeyCredential.

from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient

endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/"
credential = AzureKeyCredential("<api_key>")
document_analysis_client = DocumentIntelligenceClient(endpoint, credential)

Tworzenie klienta przy użyciu poświadczeń usługi Azure Active Directory

AzureKeyCredential uwierzytelnianie jest używane w przykładach w tym przewodniku wprowadzającym, ale można również uwierzytelniać się w usłudze Azure Active Directory przy użyciu biblioteki azure-identity . Należy pamiętać, że regionalne punkty końcowe nie obsługują uwierzytelniania usługi AAD. Utwórz niestandardową nazwę poddomeny dla zasobu, aby użyć tego typu uwierzytelniania.

Aby użyć poniższego typu DefaultAzureCredential lub innych typów poświadczeń dostarczonych z zestawem Azure SDK, zainstaluj azure-identity pakiet:

pip install azure-identity

Należy również zarejestrować nową aplikację usługi AAD i udzielić dostępu do analizy dokumentów, przypisując "Cognitive Services User" rolę do jednostki usługi.

Po zakończeniu ustaw wartości identyfikatora klienta, identyfikatora dzierżawy i klucza tajnego klienta aplikacji usługi AAD jako zmienne środowiskowe: AZURE_CLIENT_ID, AZURE_TENANT_ID. AZURE_CLIENT_SECRET

"""DefaultAzureCredential will use the values from these environment
variables: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET
"""
from azure.ai.documentintelligence import DocumentIntelligenceClient
from azure.identity import DefaultAzureCredential

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

document_analysis_client = DocumentIntelligenceClient(endpoint, credential)

Kluczowe pojęcia

DocumentIntelligenceClient

DocumentIntelligenceClient Udostępnia operacje analizowania dokumentów wejściowych przy użyciu wstępnie utworzonych i niestandardowych modeli za pośrednictwem interfejsu begin_analyze_document API. Użyj parametru , model_id aby wybrać typ modelu do analizy. Zobacz pełną listę obsługiwanych modeli tutaj. Zapewnia DocumentIntelligenceClient również operacje klasyfikowania dokumentów za pośrednictwem interfejsu begin_classify_document API. Niestandardowe modele klasyfikacji mogą klasyfikować każdą stronę w pliku wejściowym, aby identyfikować dokumenty w obrębie programu , a także identyfikować wiele dokumentów lub wiele wystąpień pojedynczego dokumentu w pliku wejściowym.

Przykładowe fragmenty kodu są udostępniane w celu zilustrowania przykładów documentIntelligenceClient tutaj. Więcej informacji na temat analizowania dokumentów, w tym obsługiwanych funkcji, ustawień regionalnych i typów dokumentów, można znaleźć w dokumentacji usługi.

DocumentIntelligenceAdministrationClient

DocumentIntelligenceAdministrationClient udostępnia operacje dla:

  • Tworzenie modeli niestandardowych w celu analizowania określonych pól określonych przez etykietowanie dokumentów niestandardowych. Zwracany DocumentModelDetails jest element wskazujący typy dokumentów, które model może analizować, a także szacowaną pewność dla każdego pola. Zapoznaj się z dokumentacją usługi , aby uzyskać bardziej szczegółowe wyjaśnienie.
  • Tworzenie złożonego modelu na podstawie kolekcji istniejących modeli.
  • Zarządzanie modelami utworzonymi na koncie.
  • Wyświetlanie listy operacji lub pobieranie określonej operacji modelu utworzonej w ciągu ostatnich 24 godzin.
  • Kopiowanie modelu niestandardowego z jednego zasobu analizy dokumentów do innego.
  • Tworzenie niestandardowego modelu klasyfikacji i zarządzanie nim w celu klasyfikowania dokumentów przetwarzanych w aplikacji.

Należy pamiętać, że modele można również tworzyć przy użyciu graficznego interfejsu użytkownika, takiego jak Document Intelligence Studio.

Przykładowe fragmenty kodu są udostępniane w celu zilustrowania przykładów elementu DocumentIntelligenceAdministrationClient tutaj.

Długotrwałe operacje

Długotrwałe operacje to operacje, które składają się z początkowego żądania wysłanego do usługi w celu uruchomienia operacji, a następnie sondowania usługi w odstępach czasu w celu ustalenia, czy operacja została ukończona, czy nie powiodła się, i jeśli zakończyła się pomyślnie, aby uzyskać wynik.

Metody analizujące dokumenty, modele kompilacji lub modele kopiowania/redagowania są modelowane jako długotrwałe operacje. Klient uwidacznia metodę zwracającą begin_<method-name> element LROPoller lub AsyncLROPoller. Obiekty wywołujące powinny czekać na zakończenie operacji przez wywołanie result() obiektu poller zwróconego begin_<method-name> z metody . Przykładowe fragmenty kodu są udostępniane w celu zilustrowania użycia długotrwałych operacji .

Przykłady

Poniższa sekcja zawiera kilka fragmentów kodu obejmujących niektóre z najbardziej typowych zadań analizy dokumentów, w tym:

Wyodrębnianie układu

Wyodrębnij tekst, znaczniki zaznaczenia, style tekstu i struktury tabel wraz ze współrzędnymi regionów ograniczenia z dokumentów.

from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient

endpoint = os.environ["DOCUMENTINTELLIGENCE_ENDPOINT"]
key = os.environ["DOCUMENTINTELLIGENCE_API_KEY"]

document_intelligence_client = DocumentIntelligenceClient(
    endpoint=endpoint, credential=AzureKeyCredential(key)
)
with open(path_to_sample_documents, "rb") as f:
    poller = document_intelligence_client.begin_analyze_document(
        "prebuilt-layout", analyze_request=f, content_type="application/octet-stream"
    )
result = poller.result()

for idx, style in enumerate(result.styles):
    print(
        "Document contains {} content".format(
            "handwritten" if style.is_handwritten else "no handwritten"
        )
    )

for page in result.pages:
    print("----Analyzing layout from page #{}----".format(page.page_number))
    print(
        "Page has width: {} and height: {}, measured with unit: {}".format(
            page.width, page.height, page.unit
        )
    )

    for line_idx, line in enumerate(page.lines):
        words = line.get_words()
        print(
            "...Line # {} has word count {} and text '{}' within bounding polygon '{}'".format(
                line_idx,
                len(words),
                line.content,
                line.polygon,
            )
        )

        for word in words:
            print(
                "......Word '{}' has a confidence of {}".format(
                    word.content, word.confidence
                )
            )

    for selection_mark in page.selection_marks:
        print(
            "...Selection mark is '{}' within bounding polygon '{}' and has a confidence of {}".format(
                selection_mark.state,
                selection_mark.polygon,
                selection_mark.confidence,
            )
        )

for table_idx, table in enumerate(result.tables):
    print(
        "Table # {} has {} rows and {} columns".format(
            table_idx, table.row_count, table.column_count
        )
    )
    for region in table.bounding_regions:
        print(
            "Table # {} location on page: {} is {}".format(
                table_idx,
                region.page_number,
                region.polygon,
            )
        )
    for cell in table.cells:
        print(
            "...Cell[{}][{}] has content '{}'".format(
                cell.row_index,
                cell.column_index,
                cell.content,
            )
        )
        for region in cell.bounding_regions:
            print(
                "...content on page {} is within bounding polygon '{}'".format(
                    region.page_number,
                    region.polygon,
                )
            )

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

Korzystanie ze wstępnie utworzonych modeli

Wyodrębnij pola z wybranych typów dokumentów, takich jak paragony, faktury, wizytówki, dokumenty tożsamości i dokumenty podatkowe w USA W-2, korzystając ze wstępnie utworzonych modeli dostarczanych przez usługę Analizy dokumentów.

Aby na przykład analizować pola z paragonu sprzedaży, użyj wstępnie utworzonego modelu paragonu dostarczonego begin_analyze_document przez przekazanie model_id="prebuilt-receipt" metody :

from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient

endpoint = os.environ["DOCUMENTINTELLIGENCE_ENDPOINT"]
key = os.environ["DOCUMENTINTELLIGENCE_API_KEY"]

document_analysis_client = DocumentIntelligenceClient(endpoint=endpoint, credential=AzureKeyCredential(key))
with open(path_to_sample_documents, "rb") as f:
    poller = document_analysis_client.begin_analyze_document(
        "prebuilt-receipt", analyze_request=f, locale="en-US", content_type="application/octet-stream"
    )
receipts = poller.result()

for idx, receipt in enumerate(receipts.documents):
    print(f"--------Analysis of receipt #{idx + 1}--------")
    print(f"Receipt type: {receipt.doc_type if receipt.doc_type else 'N/A'}")
    merchant_name = receipt.fields.get("MerchantName")
    if merchant_name:
        print(f"Merchant Name: {merchant_name.get('valueString')} has confidence: " f"{merchant_name.confidence}")
    transaction_date = receipt.fields.get("TransactionDate")
    if transaction_date:
        print(
            f"Transaction Date: {transaction_date.get('valueDate')} has confidence: "
            f"{transaction_date.confidence}"
        )
    if receipt.fields.get("Items"):
        print("Receipt items:")
        for idx, item in enumerate(receipt.fields.get("Items").get("valueArray")):
            print(f"...Item #{idx + 1}")
            item_description = item.get("valueObject").get("Description")
            if item_description:
                print(
                    f"......Item Description: {item_description.get('valueString')} has confidence: "
                    f"{item_description.confidence}"
                )
            item_quantity = item.get("valueObject").get("Quantity")
            if item_quantity:
                print(
                    f"......Item Quantity: {item_quantity.get('valueString')} has confidence: "
                    f"{item_quantity.confidence}"
                )
            item_total_price = item.get("valueObject").get("TotalPrice")
            if item_total_price:
                print(
                    f"......Total Item Price: {format_price(item_total_price.get('valueCurrency'))} has confidence: "
                    f"{item_total_price.confidence}"
                )
    subtotal = receipt.fields.get("Subtotal")
    if subtotal:
        print(f"Subtotal: {format_price(subtotal.get('valueCurrency'))} has confidence: {subtotal.confidence}")
    tax = receipt.fields.get("TotalTax")
    if tax:
        print(f"Total tax: {format_price(tax.get('valueCurrency'))} has confidence: {tax.confidence}")
    tip = receipt.fields.get("Tip")
    if tip:
        print(f"Tip: {format_price(tip.get('valueCurrency'))} has confidence: {tip.confidence}")
    total = receipt.fields.get("Total")
    if total:
        print(f"Total: {format_price(total.get('valueCurrency'))} has confidence: {total.confidence}")
    print("--------------------------------------")

Nie jesteś ograniczony do paragonów! Istnieje kilka wstępnie utworzonych modeli do wyboru, z których każdy ma własny zestaw obsługiwanych pól. Zobacz inne obsługiwane wstępnie utworzone modele tutaj.

Tworzenie modelu niestandardowego

Tworzenie modelu niestandardowego na podstawie własnego typu dokumentu. Wynikowy model może służyć do analizowania wartości z typów dokumentów, na których został wytrenowany. Podaj adres URL sygnatury dostępu współdzielonego kontenera do kontenera obiektów blob usługi Azure Storage, w którym są przechowywane dokumenty szkoleniowe.

Więcej informacji na temat konfigurowania kontenera i wymaganej struktury plików można znaleźć w dokumentacji usługi.

from azure.ai.formrecognizer import (
    DocumentIntelligenceAdministrationClient,
    ModelBuildMode,
)
from azure.core.credentials import AzureKeyCredential

endpoint = os.environ["DOCUMENTINTELLIGENCE_ENDPOINT"]
key = os.environ["DOCUMENTINTELLIGENCE_API_KEY"]
container_sas_url = os.environ["CONTAINER_SAS_URL"]

document_model_admin_client = DocumentIntelligenceAdministrationClient(
    endpoint, AzureKeyCredential(key)
)
poller = document_model_admin_client.begin_build_document_model(
    ModelBuildMode.TEMPLATE,
    blob_container_url=container_sas_url,
    description="my model description",
)
model = poller.result()

print(f"Model ID: {model.model_id}")
print(f"Description: {model.description}")
print(f"Model created on: {model.created_on}")
print(f"Model expires on: {model.expires_on}")
print("Doc types the model can recognize:")
for name, doc_type in model.doc_types.items():
    print(
        f"Doc Type: '{name}' built with '{doc_type.build_mode}' mode which has the following fields:"
    )
    for field_name, field in doc_type.field_schema.items():
        print(
            f"Field: '{field_name}' has type '{field['type']}' and confidence score "
            f"{doc_type.field_confidence[field_name]}"
        )

Analizowanie dokumentów przy użyciu modelu niestandardowego

Analizuj pola dokumentów, tabele, znaczniki zaznaczenia i nie tylko. Te modele są trenowane przy użyciu własnych danych, dzięki czemu są dostosowane do Twoich dokumentów. Aby uzyskać najlepsze wyniki, należy analizować tylko dokumenty tego samego typu dokumentu, z którym został utworzony model niestandardowy.

from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient

endpoint = os.environ["DOCUMENTINTELLIGENCE_ENDPOINT"]
key = os.environ["DOCUMENTINTELLIGENCE_API_KEY"]
model_id = os.getenv("CUSTOM_BUILT_MODEL_ID", custom_model_id)

document_analysis_client = DocumentIntelligenceClient(endpoint=endpoint, credential=AzureKeyCredential(key))

# Make sure your document's type is included in the list of document types the custom model can analyze
with open(path_to_sample_documents, "rb") as f:
    poller = document_analysis_client.begin_analyze_document(
        model_id=model_id, analyze_request=f, content_type="application/octet-stream"
    )
result = poller.result()

for idx, document in enumerate(result.documents):
    print(f"--------Analyzing document #{idx + 1}--------")
    print(f"Document has type {document.doc_type}")
    print(f"Document has document type confidence {document.confidence}")
    print(f"Document was analyzed with model with ID {result.model_id}")
    for name, field in document.fields.items():
        field_value = field.get("valueString") if field.get("valueString") else field.content
        print(
            f"......found field of type '{field.type}' with value '{field_value}' and with confidence {field.confidence}"
        )

# iterate over tables, lines, and selection marks on each page
for page in result.pages:
    print(f"\nLines found on page {page.page_number}")
    for line in page.lines:
        print(f"...Line '{line.content}'")
    for word in page.words:
        print(f"...Word '{word.content}' has a confidence of {word.confidence}")
    if page.selection_marks:
        print(f"\nSelection marks found on page {page.page_number}")
        for selection_mark in page.selection_marks:
            print(
                f"...Selection mark is '{selection_mark.state}' and has a confidence of {selection_mark.confidence}"
            )

for i, table in enumerate(result.tables):
    print(f"\nTable {i + 1} can be found on page:")
    for region in table.bounding_regions:
        print(f"...{region.page_number}")
    for cell in table.cells:
        print(f"...Cell[{cell.row_index}][{cell.column_index}] has text '{cell.content}'")
print("-----------------------------------")

Ponadto adres URL dokumentu można również użyć do analizowania begin_analyze_document dokumentów przy użyciu metody .

from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient
from azure.ai.documentintelligence.models import AnalyzeDocumentRequest

endpoint = os.environ["DOCUMENTINTELLIGENCE_ENDPOINT"]
key = os.environ["DOCUMENTINTELLIGENCE_API_KEY"]

document_analysis_client = DocumentIntelligenceClient(endpoint=endpoint, credential=AzureKeyCredential(key))
url = "https://raw.githubusercontent.com/Azure/azure-sdk-for-python/main/sdk/documentintelligence/azure-ai-documentintelligence/tests/sample_forms/receipt/contoso-receipt.png"
poller = document_analysis_client.begin_analyze_document("prebuilt-receipt", AnalyzeDocumentRequest(url_source=url))
receipts = poller.result()

Zarządzanie modelami

Zarządzanie modelami niestandardowymi dołączonymi do konta.

from azure.ai.documentintelligence import DocumentIntelligenceAdministrationClient
from azure.core.credentials import AzureKeyCredential
from azure.core.exceptions import ResourceNotFoundError

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

document_model_admin_client = DocumentIntelligenceAdministrationClient(endpoint, credential)

account_details = document_model_admin_client.get_resource_info()
print("Our account has {} custom models, and we can have at most {} custom models".format(
    account_details.custom_document_models.count, account_details.custom_document_models.limit
))

# Here we get a paged list of all of our models
models = document_model_admin_client.list_models()
print("We have models with the following ids: {}".format(
    ", ".join([m.model_id for m in models])
))

# Replace with the custom model ID from the "Build a model" sample
model_id = "<model_id from the Build a Model sample>"

custom_model = document_model_admin_client.get_model(model_id=model_id)
print("Model ID: {}".format(custom_model.model_id))
print("Description: {}".format(custom_model.description))
print("Model created on: {}\n".format(custom_model.created_on))

# Finally, we will delete this model by ID
document_model_admin_client.delete_model(model_id=custom_model.model_id)

try:
    document_model_admin_client.get_model(model_id=custom_model.model_id)
except ResourceNotFoundError:
    print("Successfully deleted model with id {}".format(custom_model.model_id))

Możliwości dodatku

Analiza dokumentów obsługuje bardziej zaawansowane możliwości analizy. Te funkcje opcjonalne można włączać i wyłączać w zależności od scenariusza wyodrębniania dokumentu.

Następujące funkcje dodatku są dostępne dla wersji 2023-07-31 (GA) i nowszych:

Pamiętaj, że niektóre funkcje dodatku będą naliczać dodatkowe opłaty. Zobacz cennik: https://azure.microsoft.com/pricing/details/ai-document-intelligence/.

Rozwiązywanie problemów

Ogólne

Biblioteka klienta analizy dokumentów zgłosi wyjątki zdefiniowane w usłudze Azure Core. Kody błędów i komunikaty zgłaszane przez usługę Analizy dokumentów można znaleźć w dokumentacji usługi.

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ę z argumentem 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 dotyczące ponownych prób, rejestrowania, protokołów transportowych i nie tylko.

Następne kroki

Więcej przykładów kodu

Zobacz przykładowy plik README zawierający kilka fragmentów kodu ilustrujących typowe wzorce używane w interfejsie API języka Python analizy dokumentów.

Dodatkowa dokumentacja

Aby uzyskać bardziej obszerną dokumentację dotyczącą analizy dokumentów sztucznej inteligencji platformy Azure, zobacz dokumentację analizy dokumentów dotyczącą 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.