Używanie analiza tekstu dla kontenerów kondycji
Kontenery umożliwiają hostowanie analiza tekstu dla interfejsu API kondycji we własnej infrastrukturze. Jeśli masz wymagania dotyczące zabezpieczeń lub ładu danych, których nie można spełnić, wywołując analiza tekstu dla kondycji zdalnej, kontenery mogą być dobrym rozwiązaniem.
Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.
Wymagania wstępne
Przed użyciem analiza tekstu dla kontenerów kondycji należy spełnić następujące wymagania wstępne. Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.
- Platforma Docker zainstalowana na komputerze hosta. Platforma Docker musi być skonfigurowana tak, aby umożliwić kontenerom łączenie się z platformą Azure i wysyłanie danych rozliczeniowych do platformy Azure.
- W systemie Windows platforma Docker musi być również skonfigurowana do obsługi kontenerów systemu Linux.
- Musisz mieć podstawową wiedzę na temat pojęć związanych z platformą Docker.
- Zasób języka z warstwą cenową Bezpłatna (F0) lub Standardowa (S).
Zbieranie wymaganych parametrów
Wymagane są trzy podstawowe parametry dla wszystkich kontenerów sztucznej inteligencji platformy Azure. Postanowienia licencyjne dotyczące oprogramowania firmy Microsoft muszą być obecne z wartością akceptacji. Wymagany jest również identyfikator URI punktu końcowego i klucz interfejsu API.
Identyfikator URI punktu końcowego
Wartość {ENDPOINT_URI} jest dostępna na stronie Przegląd witryny Azure Portal odpowiedniego zasobu usług Azure AI. Przejdź do strony Przegląd , umieść kursor nad punktem końcowym, a zostanie wyświetlona ikona Kopiuj do schowka . Skopiuj i użyj punktu końcowego w razie potrzeby.
Klucze
Wartość {API_KEY} jest używana do uruchamiania kontenera i jest dostępna na stronie Klucze witryny Azure Portal odpowiedniego zasobu usług Azure AI. Przejdź do strony Klucze i wybierz ikonę Kopiuj do schowka .
Ważne
Te klucze subskrypcji są używane do uzyskiwania dostępu do interfejsu API usług Azure AI. Nie udostępniaj kluczy. Przechowuj je bezpiecznie. Na przykład użyj usługi Azure Key Vault. Zalecamy również regularne ponowne generowanie tych kluczy. Tylko jeden klucz jest wymagany do wykonania wywołania interfejsu API. Podczas ponownego generowania pierwszego klucza można użyć drugiego klucza w celu dalszego dostępu do usługi.
Wymagania i zalecenia dotyczące komputera hosta
Host to komputer oparty na architekturze x64 z uruchomionym kontenerem platformy Docker. Może to być komputer lokalny lub usługa hostingu platformy Docker na platformie Azure, taka jak:
- Azure Kubernetes Service.
- Azure Container Instances.
- Klaster Kubernetes wdrożony w usłudze Azure Stack. Aby uzyskać więcej informacji, zobacz Wdrażanie rozwiązania Kubernetes w usłudze Azure Stack.
W poniższej tabeli opisano minimalne i zalecane specyfikacje dla analiza tekstu dla kontenerów kondycji. Każdy rdzeń procesora CPU musi być co najmniej 2,6 gigahertz (GHz) lub szybszy. Wyświetlane są również dozwolone transakcje na sekundę (TPS).
| Minimalna specyfikacja hosta | Zalecane specyfikacje hosta | Minimalna liczba modułów TPS | Maksymalna liczba modułów TPS | |
|---|---|---|---|---|
| 1 dokument/żądanie | 4 rdzenie, 12 GB pamięci | 6 rdzeni, 12 GB pamięci | 15 | 30 |
| 10 dokumentów/żądań | 6 rdzeni, 16 GB pamięci | 8 rdzeni, 20 GB pamięci | 15 | 30 |
Rdzenie procesora CPU i pamięć odpowiadają --cpus ustawieniu i --memory , które są używane w ramach docker run polecenia .
Pobieranie obrazu kontenera za pomocą polecenia docker pull
Analiza tekstu obrazu kontenera kondycji można znaleźć w mcr.microsoft.com syndykacie rejestru kontenerów. Znajduje się on w azure-cognitive-services/textanalytics/ repozytorium i ma nazwę healthcare. W pełni kwalifikowana nazwa obrazu kontenera to mcr.microsoft.com/azure-cognitive-services/textanalytics/healthcare
Aby użyć najnowszej wersji kontenera, możesz użyć tagu latest . Pełną listę tagów można również znaleźć w mcR.
Użyj polecenia , docker pull aby pobrać ten obraz kontenera z publicznego rejestru kontenerów firmy Microsoft. Polecane tagi można znaleźć w usłudze Microsoft Container Registry
docker pull mcr.microsoft.com/azure-cognitive-services/textanalytics/healthcare:<tag-name>
Napiwek
Możesz użyć polecenia docker images , aby wyświetlić listę pobranych obrazów kontenerów. Na przykład następujące polecenie wyświetla identyfikator, repozytorium i tag każdego pobranego obrazu kontenera sformatowane jako tabela:
docker images --format "table {{.ID}}\t{{.Repository}}\t{{.Tag}}"
IMAGE ID REPOSITORY TAG
<image-id> <repository-path/name> <tag-name>
Uruchamianie kontenera za pomocą polecenia docker run
Gdy kontener znajduje się na komputerze hosta, użyj polecenia docker run , aby uruchomić kontenery. Kontener będzie nadal działać do momentu jego zatrzymania.
Ważne
- Polecenia platformy Docker w poniższych sekcjach używają ukośnika odwrotnego ,
\jako znaku kontynuacji wiersza. Zastąp lub usuń to na podstawie wymagań systemu operacyjnego hosta. - Aby
Eulauruchomić kontener, należy określić opcje ,BillingiApiKey. W przeciwnym razie kontener nie zostanie uruchomiony. Aby uzyskać więcej informacji, zobacz Rozliczenia.- Potwierdzenie odpowiedzialnej sztucznej inteligencji (RAI) musi być również obecne z wartością
accept.
- Potwierdzenie odpowiedzialnej sztucznej inteligencji (RAI) musi być również obecne z wartością
- Kontenery analizy tonacji i wykrywania języka używają interfejsu API w wersji 3 i są ogólnie dostępne. Kontener wyodrębniania kluczowych fraz używa wersji 2 interfejsu API i jest w wersji zapoznawczej.
Istnieje wiele sposobów instalowania i uruchamiania analiza tekstu dla kontenera kondycji.
- Użyj witryny Azure Portal, aby utworzyć zasób języka i użyć platformy Docker do pobrania kontenera.
- Uruchamianie kontenera przy użyciu maszyny wirtualnej platformy Azure z platformą Docker.
- Użyj następujących skryptów programu PowerShell i interfejsu wiersza polecenia platformy Azure, aby zautomatyzować wdrażanie zasobów i konfigurację kontenera.
Jeśli używasz analiza tekstu dla kontenera kondycji, dane zawarte w żądaniach i odpowiedziach interfejsu API nie są widoczne dla firmy Microsoft i nie są używane do trenowania modelu zastosowanego do danych.
Uruchamianie kontenera w środowisku lokalnym
Aby uruchomić kontener we własnym środowisku po pobraniu obrazu kontenera, wykonaj następujące docker run polecenie. Zastąp symbole zastępcze poniżej własnymi wartościami:
| Symbol zastępczy | Wartość | Formatowanie lub przykład |
|---|---|---|
| {API_KEY} | Klucz zasobu Language. Możesz go znaleźć na stronie Klucz i punkt końcowy zasobu w witrynie Azure Portal. | xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx |
| {ENDPOINT_URI} | Punkt końcowy umożliwiający uzyskiwanie dostępu do interfejsu API. Możesz go znaleźć na stronie Klucz i punkt końcowy zasobu w witrynie Azure Portal. | https://<your-custom-subdomain>.cognitiveservices.azure.com |
docker run --rm -it -p 5000:5000 --cpus 6 --memory 12g \
mcr.microsoft.com/azure-cognitive-services/textanalytics/healthcare:<tag-name> \
Eula=accept \
rai_terms=accept \
Billing={ENDPOINT_URI} \
ApiKey={API_KEY}
To polecenie:
- Uruchamia analiza tekstu kontenera kondycji z obrazu kontenera
- Przydziela 6 rdzeni procesora CPU i 12 gigabajtów (GB) pamięci
- Uwidacznia port TCP 5000 i przydziela pseudo-TTY dla kontenera
- Akceptuje warunki umowy licencyjnej użytkownika końcowego (EULA) i odpowiedzialnej sztucznej inteligencji (RAI)
- Automatycznie usuwa kontener po jego zakończeniu. Obraz kontenera jest nadal dostępny na komputerze hosta.
Pokazowy interfejs użytkownika w celu wizualizacji danych wyjściowych
Kontener udostępnia oparte na interfejsie REST interfejsy API punktu końcowego przewidywania zapytań. Udostępniliśmy również narzędzie do wizualizacji w kontenerze, które jest dostępne, dołączając /demo do punktu końcowego kontenera. Na przykład:
http://<serverURL>:5000/demo
Użyj poniższego przykładowego żądania cURL, aby przesłać zapytanie do wdrożonego kontenera, zastępując serverURL zmienną odpowiednią wartością.
curl -X POST 'http://<serverURL>:5000/text/analytics/v3.1/entities/health' --header 'Content-Type: application/json' --header 'accept: application/json' --data-binary @example.json
Instalowanie kontenera przy użyciu usługi Azure Web App for Containers
Usługa Azure Web App for Containers to zasób platformy Azure przeznaczony do uruchamiania kontenerów w chmurze. Zapewnia ona gotowe możliwości, takie jak skalowanie automatyczne, obsługa kontenerów platformy Docker i redagowanie platformy Docker, obsługa protokołu HTTPS i wiele innych.
Uwaga
Za pomocą aplikacji internetowej platformy Azure automatycznie uzyskasz domenę w postaci <appservice_name>.azurewebsites.net
Uruchom ten skrypt programu PowerShell przy użyciu interfejsu wiersza polecenia platformy Azure, aby utworzyć aplikację internetową dla kontenerów przy użyciu subskrypcji i obrazu kontenera za pośrednictwem protokołu HTTPS. Przed przesłaniem pierwszego żądania poczekaj na ukończenie skryptu (około 25–30 minut).
$subscription_name = "" # THe name of the subscription you want you resource to be created on.
$resource_group_name = "" # The name of the resource group you want the AppServicePlan
# and AppSerivce to be attached to.
$resources_location = "" # This is the location you wish the AppServicePlan to be deployed to.
# You can use the "az account list-locations -o table" command to
# get the list of available locations and location code names.
$appservice_plan_name = "" # This is the AppServicePlan name you wish to have.
$appservice_name = "" # This is the AppService resource name you wish to have.
$TEXT_ANALYTICS_RESOURCE_API_KEY = "" # This should be taken from the Language resource.
$TEXT_ANALYTICS_RESOURCE_API_ENDPOINT = "" # This should be taken from the Language resource.
$DOCKER_IMAGE_NAME = "mcr.microsoft.com/azure-cognitive-services/textanalytics/healthcare:latest"
az login
az account set -s $subscription_name
az appservice plan create -n $appservice_plan_name -g $resource_group_name --is-linux -l $resources_location --sku P3V2
az webapp create -g $resource_group_name -p $appservice_plan_name -n $appservice_name -i $DOCKER_IMAGE_NAME
az webapp config appsettings set -g $resource_group_name -n $appservice_name --settings Eula=accept rai_terms=accept Billing=$TEXT_ANALYTICS_RESOURCE_API_ENDPOINT ApiKey=$TEXT_ANALYTICS_RESOURCE_API_KEY
# Once deployment complete, the resource should be available at: https://<appservice_name>.azurewebsites.net
Instalowanie kontenera przy użyciu usługi Azure Container Instance
Możesz również użyć usługi Azure Container Instance (ACI), aby ułatwić wdrażanie. ACI to zasób, który umożliwia uruchamianie kontenerów platformy Docker na żądanie w zarządzanym, bezserwerowym środowisku platformy Azure.
Zobacz How to use Azure Container Instances (Jak używać usługi Azure Container Instances ), aby uzyskać instrukcje dotyczące wdrażania zasobu usługi ACI przy użyciu witryny Azure Portal. Możesz również użyć poniższego skryptu programu PowerShell przy użyciu interfejsu wiersza polecenia platformy Azure, który utworzy identyfikator ACI w ramach subskrypcji przy użyciu obrazu kontenera. Przed przesłaniem pierwszego żądania poczekaj na ukończenie skryptu (około 25–30 minut). Ze względu na limit maksymalnej liczby procesorów CPU na zasób usługi ACI nie wybieraj tej opcji, jeśli spodziewasz się przesłać więcej niż 5 dużych dokumentów (około 5000 znaków każdy) na żądanie. Aby uzyskać informacje o dostępności, zobacz artykuł pomocy technicznej regionalnej usługi ACI.
Uwaga
Usługa Azure Container Instances nie obejmuje obsługi protokołu HTTPS dla domen wbudowanych. Jeśli potrzebujesz protokołu HTTPS, musisz ręcznie go skonfigurować, w tym utworzyć certyfikat i zarejestrować domenę. Instrukcje, które należy wykonać, można znaleźć w poniższym temacie NGINX.
$subscription_name = "" # The name of the subscription you want you resource to be created on.
$resource_group_name = "" # The name of the resource group you want the AppServicePlan
# and AppService to be attached to.
$resources_location = "" # This is the location you wish the web app to be deployed to.
# You can use the "az account list-locations -o table" command to
# Get the list of available locations and location code names.
$azure_container_instance_name = "" # This is the AzureContainerInstance name you wish to have.
$TEXT_ANALYTICS_RESOURCE_API_KEY = "" # This should be taken from the Language resource.
$TEXT_ANALYTICS_RESOURCE_API_ENDPOINT = "" # This should be taken from the Language resource.
$DNS_LABEL = "" # This is the DNS label name you wish your ACI will have
$DOCKER_IMAGE_NAME = "mcr.microsoft.com/azure-cognitive-services/textanalytics/healthcare:latest"
az login
az account set -s $subscription_name
az container create --resource-group $resource_group_name --name $azure_container_instance_name --image $DOCKER_IMAGE_NAME --cpu 4 --memory 12 --port 5000 --dns-name-label $DNS_LABEL --environment-variables Eula=accept rai_terms=accept Billing=$TEXT_ANALYTICS_RESOURCE_API_ENDPOINT ApiKey=$TEXT_ANALYTICS_RESOURCE_API_KEY
# Once deployment complete, the resource should be available at: http://<unique_dns_label>.<resource_group_region>.azurecontainer.io:5000
Bezpieczna łączność Z usługą ACI
Domyślnie nie ma żadnych zabezpieczeń w przypadku korzystania z usługi ACI z interfejsem API kontenera. Dzieje się tak, ponieważ zazwyczaj kontenery będą uruchamiane jako część zasobnika, który jest chroniony z zewnątrz przez mostek sieciowy. Można jednak zmodyfikować kontener za pomocą składnika frontonu, zachowując prywatny punkt końcowy kontenera. Poniższe przykłady używają serwera NGINX jako bramy ruchu przychodzącego do obsługi uwierzytelniania HTTPS/SSL i certyfikatu klienta.
Uwaga
Serwer NGINX to serwer HTTP o wysokiej wydajności typu open source i serwer proxy. Kontener NGINX może służyć do przerwania połączenia TLS dla pojedynczego kontenera. Bardziej złożone rozwiązania zakończenia protokołu TLS oparte na ruchu przychodzącym NGINX są również możliwe.
Konfigurowanie serwera NGINX jako bramy ruchu przychodzącego
Serwer NGINX używa plików konfiguracji do włączania funkcji w czasie wykonywania. Aby włączyć zakończenie protokołu TLS dla innej usługi, należy określić certyfikat SSL, aby przerwać połączenie TLS i proxy_pass określić adres dla usługi. Poniżej przedstawiono przykład.
Uwaga
ssl_certificate oczekuje, że ścieżka zostanie określona w lokalnym systemie plików kontenera NGINX. Adres określony dla proxy_pass musi być dostępny z poziomu sieci kontenera NGINX.
Kontener NGINX załaduje wszystkie pliki w folderze _.conf_ zainstalowanym w /etc/nginx/conf.d/ ścieżce konfiguracji HTTP.
server {
listen 80;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl;
# replace with .crt and .key paths
ssl_certificate /cert/Local.crt;
ssl_certificate_key /cert/Local.key;
location / {
proxy_pass http://cognitive-service:5000;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Real-IP $remote_addr;
}
}
Przykładowy plik docker compose
W poniższym przykładzie pokazano, jak można utworzyć plik docker compose w celu wdrożenia kontenerów NGINX i kondycji:
version: "3.7"
services:
cognitive-service:
image: {IMAGE_ID}
ports:
- 5000:5000
environment:
- eula=accept
- billing={ENDPOINT_URI}
- apikey={API_KEY}
volumes:
# replace with path to logs folder
- <path-to-logs-folder>:/output
nginx:
image: nginx
ports:
- 443:443
volumes:
# replace with paths for certs and conf folders
- <path-to-certs-folder>:/cert
- <path-to-conf-folder>:/etc/nginx/conf.d/
Aby zainicjować ten plik docker compose, wykonaj następujące polecenie z konsoli na poziomie głównym pliku:
docker-compose up
Aby uzyskać więcej informacji, zobacz dokumentację serwera NGINX dotyczącą kończenia żądań protokołu SSL NGINX.
Uruchamianie wielu kontenerów na tym samym hoście
Jeśli zamierzasz uruchomić wiele kontenerów z uwidocznionych portów, upewnij się, że każdy kontener ma inny uwidoczniony port. Na przykład uruchom pierwszy kontener na porcie 5000 i drugi kontener na porcie 5001.
Ten kontener i inny kontener usług Azure AI mogą być uruchomione razem na hoście. Można również mieć wiele kontenerów tego samego kontenera usług Azure AI, na których działa.
Wykonywanie zapytania dotyczącego punktu końcowego przewidywania kontenera
Kontener udostępnia oparte na interfejsie REST interfejsy API punktu końcowego przewidywania zapytań.
Użyj hosta http://localhost:5000 dla interfejsów API kontenera.
Sprawdzanie, czy kontener jest uruchomiony
Istnieje kilka sposobów sprawdzania, czy kontener jest uruchomiony. Znajdź zewnętrzny adres IP i uwidoczniony port danego kontenera i otwórz ulubioną przeglądarkę internetową. Użyj różnych adresów URL żądań, które są zgodne z instrukcjami, aby sprawdzić, czy kontener jest uruchomiony. Przykładowe adresy URL żądań wymienione w tym miejscu to http://localhost:5000, ale określony kontener może się różnić. Upewnij się, że korzystasz z zewnętrznego adresu IP kontenera i uwidocznij port.
| Adres URL żądania | Purpose |
|---|---|
http://localhost:5000/ |
Kontener zawiera stronę główną. |
http://localhost:5000/ready |
Żądany przy użyciu polecenia GET ten adres URL zapewnia weryfikację, że kontener jest gotowy do akceptowania zapytania względem modelu. To żądanie może służyć do sond gotowości i gotowości platformy Kubernetes. |
http://localhost:5000/status |
Ten adres URL sprawdza również, czy klucz api-key używany do uruchamiania kontenera jest prawidłowy bez powodowania zapytania punktu końcowego. To żądanie może służyć do sond gotowości i gotowości platformy Kubernetes. |
http://localhost:5000/swagger |
Kontener zawiera pełen zestaw dokumentacji dla punktów końcowych oraz funkcję Wypróbuj. Dzięki tej funkcji możesz wprowadzić ustawienia w formularzu HTML opartym na sieci Web i utworzyć zapytanie bez konieczności pisania kodu. Po powrocie zapytania zostanie udostępnione przykładowe polecenie CURL, aby zademonstrować wymagane nagłówki HTTP i format treści. |
Tworzenie struktury żądania interfejsu API dla kontenera
Możesz użyć narzędzia Postman lub przykładowego żądania cURL poniżej, aby przesłać zapytanie do wdrożonego kontenera, zastępując serverURL zmienną odpowiednią wartością. Zwróć uwagę, że wersja interfejsu API w adresie URL kontenera różni się od hostowanego interfejsu API.
Uwaga
Funkcja Fast Healthcare Interoperability Resources (FHIR) jest dostępna w najnowszym kontenerze i jest dostępna za pośrednictwem nowego interfejsu API REST języka.
curl -i -X POST 'http://<serverURL>:5000/language/analyze-text/jobs?api-version=2022-04-01-preview' --header 'Content-Type: application/json' --header --data-binary @example.json
Poniższy kod JSON jest przykładem pliku JSON dołączonego do treści POST żądania języka:
example.json
{
"analysisInput": {
"documents": [
{
"text": "The doctor prescried 200mg Ibuprofen.",
"language": "en",
"id": "1"
}
]
},
"tasks": [
{
"taskName": "analyze 1",
"kind": "Healthcare",
"parameters": {
"fhirVersion": "4.0.1"
}
}
]
}
Treść odpowiedzi kontenera
Poniższy kod JSON jest przykładem treści odpowiedzi Language z konteneryzowanego wywołania synchronicznego:
{
"jobId": "{JOB-ID}",
"lastUpdateDateTime": "2022-04-18T15:50:16Z",
"createdDateTime": "2022-04-18T15:50:14Z",
"expirationDateTime": "2022-04-19T15:50:14Z",
"status": "succeeded",
"errors": [],
"tasks": {
"completed": 1,
"failed": 0,
"inProgress": 0,
"total": 1,
"items": [
{
"kind": "HealthcareLROResults",
"taskName": "analyze 1",
"lastUpdateDateTime": "2022-04-18T15:50:16.7046515Z",
"status": "succeeded",
"results": {
"documents": [
{
"id": "1",
"entities": [
{
"offset": 4,
"length": 6,
"text": "doctor",
"category": "HealthcareProfession",
"confidenceScore": 0.76
},
{
"offset": 21,
"length": 5,
"text": "200mg",
"category": "Dosage",
"confidenceScore": 0.99
},
{
"offset": 27,
"length": 9,
"text": "Ibuprofen",
"category": "MedicationName",
"confidenceScore": 1.0,
"name": "ibuprofen",
"links": [
{ "dataSource": "UMLS", "id": "C0020740" },
{ "dataSource": "AOD", "id": "0000019879" },
{ "dataSource": "ATC", "id": "M01AE01" },
{ "dataSource": "CCPSS", "id": "0046165" },
{ "dataSource": "CHV", "id": "0000006519" },
{ "dataSource": "CSP", "id": "2270-2077" },
{ "dataSource": "DRUGBANK", "id": "DB01050" },
{ "dataSource": "GS", "id": "1611" },
{ "dataSource": "LCH_NW", "id": "sh97005926" },
{ "dataSource": "LNC", "id": "LP16165-0" },
{ "dataSource": "MEDCIN", "id": "40458" },
{ "dataSource": "MMSL", "id": "d00015" },
{ "dataSource": "MSH", "id": "D007052" },
{ "dataSource": "MTHSPL", "id": "WK2XYI10QM" },
{ "dataSource": "NCI", "id": "C561" },
{ "dataSource": "NCI_CTRP", "id": "C561" },
{ "dataSource": "NCI_DCP", "id": "00803" },
{ "dataSource": "NCI_DTP", "id": "NSC0256857" },
{ "dataSource": "NCI_FDA", "id": "WK2XYI10QM" },
{ "dataSource": "NCI_NCI-GLOSS", "id": "CDR0000613511" },
{ "dataSource": "NDDF", "id": "002377" },
{ "dataSource": "PDQ", "id": "CDR0000040475" },
{ "dataSource": "RCD", "id": "x02MO" },
{ "dataSource": "RXNORM", "id": "5640" },
{ "dataSource": "SNM", "id": "E-7772" },
{ "dataSource": "SNMI", "id": "C-603C0" },
{ "dataSource": "SNOMEDCT_US", "id": "387207008" },
{ "dataSource": "USP", "id": "m39860" },
{ "dataSource": "USPMG", "id": "MTHU000060" },
{ "dataSource": "VANDF", "id": "4017840" }
]
}
],
"relations": [
{
"relationType": "DosageOfMedication",
"entities": [
{
"ref": "#/results/documents/0/entities/1",
"role": "Dosage"
},
{
"ref": "#/results/documents/0/entities/2",
"role": "Medication"
}
]
}
],
"warnings": [],
"fhirBundle": {
"resourceType": "Bundle",
"id": "bae9d4e0-191e-48e6-9c24-c1ff6097c439",
"meta": {
"profile": [
"http://hl7.org/fhir/4.0.1/StructureDefinition/Bundle"
]
},
"identifier": {
"system": "urn:ietf:rfc:3986",
"value": "urn:uuid:bae9d4e0-191e-48e6-9c24-c1ff6097c439"
},
"type": "document",
"entry": [
{
"fullUrl": "Composition/9044c2cc-dcec-4b9d-b005-bfa8be978aa8",
"resource": {
"resourceType": "Composition",
"id": "9044c2cc-dcec-4b9d-b005-bfa8be978aa8",
"status": "final",
"type": {
"coding": [
{
"system": "http://loinc.org",
"code": "11526-1",
"display": "Pathology study"
}
],
"text": "Pathology study"
},
"subject": {
"reference": "Patient/5c554347-4290-4b05-83ac-6637ff3bfb40",
"type": "Patient"
},
"encounter": {
"reference": "Encounter/6fe12f5b-e35c-4c92-a492-96feda5a1a3b",
"type": "Encounter",
"display": "unknown"
},
"date": "2022-04-18",
"author": [
{
"reference": "Practitioner/fb5da4d8-e0f0-4434-8d29-4419b065c4d7",
"type": "Practitioner",
"display": "Unknown"
}
],
"title": "Pathology study",
"section": [
{
"title": "General",
"code": {
"coding": [
{
"system": "",
"display": "Unrecognized Section"
}
],
"text": "General"
},
"text": {
"div": "<div>\r\n\t\t\t\t\t\t\t<h1>General</h1>\r\n\t\t\t\t\t\t\t<p>The doctor prescried 200mg Ibuprofen.</p>\r\n\t\t\t\t\t</div>"
},
"entry": [
{
"reference": "List/db388912-b5fb-4073-a74c-2751fd3374dd",
"type": "List",
"display": "General"
}
]
}
]
}
},
{
"fullUrl": "Practitioner/fb5da4d8-e0f0-4434-8d29-4419b065c4d7",
"resource": {
"resourceType": "Practitioner",
"id": "fb5da4d8-e0f0-4434-8d29-4419b065c4d7",
"extension": [
{
"extension": [
{ "url": "offset", "valueInteger": -1 },
{ "url": "length", "valueInteger": 7 }
],
"url": "http://hl7.org/fhir/StructureDefinition/derivation-reference"
}
],
"name": [{ "text": "Unknown", "family": "Unknown" }]
}
},
{
"fullUrl": "Patient/5c554347-4290-4b05-83ac-6637ff3bfb40",
"resource": {
"resourceType": "Patient",
"id": "5c554347-4290-4b05-83ac-6637ff3bfb40",
"gender": "unknown"
}
},
{
"fullUrl": "Encounter/6fe12f5b-e35c-4c92-a492-96feda5a1a3b",
"resource": {
"resourceType": "Encounter",
"id": "6fe12f5b-e35c-4c92-a492-96feda5a1a3b",
"meta": {
"profile": [
"http://hl7.org/fhir/us/core/StructureDefinition/us-core-encounter"
]
},
"status": "finished",
"class": {
"system": "http://terminology.hl7.org/CodeSystem/v3-ActCode",
"display": "unknown"
},
"subject": {
"reference": "Patient/5c554347-4290-4b05-83ac-6637ff3bfb40",
"type": "Patient"
}
}
},
{
"fullUrl": "MedicationStatement/24e860ce-2fdc-4745-aa9e-7d30bb487c4e",
"resource": {
"resourceType": "MedicationStatement",
"id": "24e860ce-2fdc-4745-aa9e-7d30bb487c4e",
"extension": [
{
"extension": [
{ "url": "offset", "valueInteger": 27 },
{ "url": "length", "valueInteger": 9 }
],
"url": "http://hl7.org/fhir/StructureDefinition/derivation-reference"
}
],
"status": "active",
"medicationCodeableConcept": {
"coding": [
{
"system": "http://www.nlm.nih.gov/research/umls",
"code": "C0020740",
"display": "Ibuprofen"
},
{
"system": "http://www.nlm.nih.gov/research/umls/aod",
"code": "0000019879"
},
{
"system": "http://www.whocc.no/atc",
"code": "M01AE01"
},
{
"system": "http://www.nlm.nih.gov/research/umls/ccpss",
"code": "0046165"
},
{
"system": "http://www.nlm.nih.gov/research/umls/chv",
"code": "0000006519"
},
{
"system": "http://www.nlm.nih.gov/research/umls/csp",
"code": "2270-2077"
},
{
"system": "http://www.nlm.nih.gov/research/umls/drugbank",
"code": "DB01050"
},
{
"system": "http://www.nlm.nih.gov/research/umls/gs",
"code": "1611"
},
{
"system": "http://www.nlm.nih.gov/research/umls/lch_nw",
"code": "sh97005926"
},
{ "system": "http://loinc.org", "code": "LP16165-0" },
{
"system": "http://www.nlm.nih.gov/research/umls/medcin",
"code": "40458"
},
{
"system": "http://www.nlm.nih.gov/research/umls/mmsl",
"code": "d00015"
},
{
"system": "http://www.nlm.nih.gov/research/umls/msh",
"code": "D007052"
},
{
"system": "http://www.nlm.nih.gov/research/umls/mthspl",
"code": "WK2XYI10QM"
},
{
"system": "http://ncimeta.nci.nih.gov",
"code": "C561"
},
{
"system": "http://www.nlm.nih.gov/research/umls/nci_ctrp",
"code": "C561"
},
{
"system": "http://www.nlm.nih.gov/research/umls/nci_dcp",
"code": "00803"
},
{
"system": "http://www.nlm.nih.gov/research/umls/nci_dtp",
"code": "NSC0256857"
},
{
"system": "http://www.nlm.nih.gov/research/umls/nci_fda",
"code": "WK2XYI10QM"
},
{
"system": "http://www.nlm.nih.gov/research/umls/nci_nci-gloss",
"code": "CDR0000613511"
},
{
"system": "http://www.nlm.nih.gov/research/umls/nddf",
"code": "002377"
},
{
"system": "http://www.nlm.nih.gov/research/umls/pdq",
"code": "CDR0000040475"
},
{
"system": "http://www.nlm.nih.gov/research/umls/rcd",
"code": "x02MO"
},
{
"system": "http://www.nlm.nih.gov/research/umls/rxnorm",
"code": "5640"
},
{
"system": "http://snomed.info/sct",
"code": "E-7772"
},
{
"system": "http://snomed.info/sct/900000000000207008",
"code": "C-603C0"
},
{
"system": "http://snomed.info/sct/731000124108",
"code": "387207008"
},
{
"system": "http://www.nlm.nih.gov/research/umls/usp",
"code": "m39860"
},
{
"system": "http://www.nlm.nih.gov/research/umls/uspmg",
"code": "MTHU000060"
},
{
"system": "http://hl7.org/fhir/ndfrt",
"code": "4017840"
}
],
"text": "Ibuprofen"
},
"subject": {
"reference": "Patient/5c554347-4290-4b05-83ac-6637ff3bfb40",
"type": "Patient"
},
"context": {
"reference": "Encounter/6fe12f5b-e35c-4c92-a492-96feda5a1a3b",
"type": "Encounter",
"display": "unknown"
},
"dosage": [
{
"text": "200mg",
"doseAndRate": [{ "doseQuantity": { "value": 200 } }]
}
]
}
},
{
"fullUrl": "List/db388912-b5fb-4073-a74c-2751fd3374dd",
"resource": {
"resourceType": "List",
"id": "db388912-b5fb-4073-a74c-2751fd3374dd",
"status": "current",
"mode": "snapshot",
"title": "General",
"subject": {
"reference": "Patient/5c554347-4290-4b05-83ac-6637ff3bfb40",
"type": "Patient"
},
"encounter": {
"reference": "Encounter/6fe12f5b-e35c-4c92-a492-96feda5a1a3b",
"type": "Encounter",
"display": "unknown"
},
"entry": [
{
"item": {
"reference": "MedicationStatement/24e860ce-2fdc-4745-aa9e-7d30bb487c4e",
"type": "MedicationStatement",
"display": "Ibuprofen"
}
}
]
}
}
]
}
}
],
"errors": [],
"modelVersion": "2022-03-01"
}
}
]
}
}
Uruchamianie kontenera z obsługą biblioteki klienta
Począwszy od wersji 3.0.017010001-onprem-amd64 kontenera (lub jeśli używasz latest kontenera), możesz uruchomić analiza tekstu dla kontenera kondycji przy użyciu biblioteki klienta. W tym celu dodaj następujący parametr do docker run polecenia :
enablelro=true
Następnie podczas uwierzytelniania obiektu klienta użyj punktu końcowego, na którym działa kontener:
http://localhost:5000
Jeśli na przykład używasz języka C#, użyj następującego kodu:
var client = new TextAnalyticsClient("http://localhost:5000", "your-text-analytics-key");
Zatrzymywanie kontenera
Aby zamknąć kontener, w środowisku wiersza polecenia, w którym jest uruchomiony kontener, wybierz klawisze Ctrl+C.
Rozwiązywanie problemów
Jeśli uruchamiasz kontener z włączoną instalacją danych wyjściowych i rejestrowaniem, kontener generuje pliki dziennika, które są pomocne w rozwiązywaniu problemów występujących podczas uruchamiania lub uruchamiania kontenera.
Napiwek
Aby uzyskać więcej informacji na temat rozwiązywania problemów i wskazówek, zobacz Często zadawane pytania dotyczące kontenerów usługi Azure AI.
Rozliczenia
analiza tekstu dla kontenerów kondycji wysyłają informacje rozliczeniowe na platformę Azure przy użyciu Zasób językowy na koncie platformy Azure.
Zapytania do kontenera są rozliczane w warstwie cenowej zasobu platformy Azure używanego dla parametru ApiKey .
Kontenery usług AI platformy Azure nie są licencjonowane do uruchamiania bez połączenia z punktem końcowym pomiaru użytkowania ani rozliczeń. Należy zezwolić kontenerom na komunikowanie informacji rozliczeniowych z punktem końcowym rozliczeń przez cały czas. Kontenery usług AI platformy Azure nie wysyłają do firmy Microsoft danych klientów, takich jak obraz lub tekst analizowany.
Łączenie się z platformą Azure
Do uruchomienia kontenera potrzebne są wartości argumentów rozliczeniowych. Te wartości umożliwiają kontenerowi łączenie się z punktem końcowym rozliczeń. Kontener raportuje użycie co około 10 do 15 minut. Jeśli kontener nie łączy się z platformą Azure w dozwolonym przedziale czasu, kontener będzie nadal działać, ale nie obsługuje zapytań, dopóki punkt końcowy rozliczeń nie zostanie przywrócony. Próba nawiązania połączenia jest podejmowana 10 razy w tym samym przedziale czasu od 10 do 15 minut. Jeśli nie może nawiązać połączenia z punktem końcowym rozliczeń w ciągu 10 prób, kontener przestanie obsługiwać żądania. Zobacz często zadawane pytania dotyczące kontenera usług AI platformy Azure, aby uzyskać przykład informacji wysyłanych do firmy Microsoft na potrzeby rozliczeń.
Argumenty rozliczeniowe
Polecenie docker run uruchomi kontener, gdy wszystkie trzy z następujących opcji są dostarczane z prawidłowymi wartościami:
| Opcja | Opis |
|---|---|
ApiKey |
Klucz interfejsu API zasobu usług Azure AI używany do śledzenia informacji rozliczeniowych. Wartość tej opcji musi być ustawiona na klucz interfejsu API dla zaaprowizowanego zasobu określonego w pliku Billing. |
Billing |
Punkt końcowy zasobu usług Azure AI używany do śledzenia informacji rozliczeniowych. Wartość tej opcji musi być ustawiona na identyfikator URI punktu końcowego aprowizowanego zasobu platformy Azure. |
Eula |
Wskazuje, że zaakceptowano licencję dla kontenera. Wartość tej opcji należy ustawić tak, aby akceptowała. |
Podsumowanie
W tym artykule przedstawiono pojęcia i przepływ pracy dotyczące pobierania, instalowania i uruchamiania analiza tekstu dla kontenerów kondycji. Podsumowując:
- analiza tekstu dla kondycji zapewnia kontener systemu Linux dla platformy Docker
- Obrazy kontenerów są pobierane z usługi Microsoft Container Registry (MCR).
- Obrazy kontenerów są uruchamiane na platformie Docker.
- Za pomocą interfejsu API REST lub zestawu SDK można wywoływać operacje w analiza tekstu dla kontenerów kondycji, określając identyfikator URI hosta kontenera.
- Podczas tworzenia wystąpienia kontenera należy określić informacje o rozliczeniach.
Ważne
Kontenery sztucznej inteligencji platformy Azure nie mają licencji na uruchamianie bez nawiązywania połączenia z platformą Azure na potrzeby pomiaru użytkowania. Klienci muszą umożliwić kontenerom komunikowanie informacji rozliczeniowych z usługą pomiarów przez cały czas. Kontenery sztucznej inteligencji platformy Azure nie wysyłają danych klienta (np. tekstu analizowanego) do firmy Microsoft.
Następne kroki
- Zobacz Konfigurowanie kontenerów pod kątem ustawień konfiguracji.