Installera och köra Docker-containrar för LUIS

Artikel
01/19/2024

Viktigt!

LUIS dras tillbaka den 1 oktober 2025 och från och med den 1 april 2023 kommer du inte att kunna skapa nya LUIS-resurser. Vi rekommenderar att du migrerar dina LUIS-program till förståelse för konversationsspråk för att dra nytta av fortsatt produktsupport och flerspråkiga funktioner.

Kommentar

Platsen för containeravbildningen har nyligen ändrats. Läs den här artikeln om du vill se den uppdaterade platsen för den här containern.

Med containrar kan du använda LUIS i din egen miljö. Containrar är bra för specifika säkerhets- och datastyrningskrav. I den här artikeln får du lära dig hur du laddar ned, installerar och kör en LUIS-container.

Containern Language Understanding (LUIS) läser in din tränade eller publicerade Language Understanding-modell. Som EN LUIS-app ger Docker-containern åtkomst till frågeförutsägelserna från containerns API-slutpunkter. Du kan samla in frågeloggar från containern och ladda upp dem tillbaka till Language Understanding-appen för att förbättra appens förutsägelsenoggrannhet.

Följande video visar hur du använder den här containern.

Om du inte har någon Azure-prenumeration skapar du ett kostnadsfritt konto innan du börjar.

Förutsättningar

Observera följande förutsättningar för att köra LUIS-containern:

Docker installerat på en värddator. Docker måste konfigureras så att containrarna kan ansluta till och skicka faktureringsdata till Azure.
- I Windows måste Docker också konfigureras för att stödja Linux-containrar.
- Du bör ha en grundläggande förståelse för Docker-begrepp.
En LUIS-resurs med den kostnadsfria prisnivån (F0) eller standard (S).
En tränad eller publicerad app som paketeras som en monterad indata till containern med tillhörande app-ID. Du kan hämta den paketerade filen från LUIS-portalen eller redigerings-API:erna. Om du får LUIS-paketerad app från redigerings-API:erna behöver du även redigeringsnyckeln.

Samla in obligatoriska parametrar

Tre primära parametrar för alla Azure AI-containrar krävs. Licensvillkoren för Programvara från Microsoft måste finnas med värdet accept. En slutpunkts-URI och API-nyckel behövs också.

Slutpunkts-URI

Värdet {ENDPOINT_URI} är tillgängligt på översiktssidan för Azure-portalen för motsvarande Azure AI-tjänstresurs. Gå till sidan Översikt , hovra över slutpunkten och ikonen Kopiera till Urklipp visas. Kopiera och använd slutpunkten där det behövs.

Skärmbild som visar insamling av slutpunkts-URI för senare användning.

Nycklar

Värdet {API_KEY} används för att starta containern och är tillgängligt på sidan Nycklar i Azure-portalen för motsvarande Azure AI-tjänstresurs. Gå till sidan Nycklar och välj ikonen Kopiera till Urklipp .

Skärmbild som visar hur du hämtar en av de två nycklarna för senare användning.

Viktigt!

Dessa prenumerationsnycklar används för att komma åt ditt Azure AI-tjänst-API. Dela inte dina nycklar. Lagra dem på ett säkert sätt. Använd till exempel Azure Key Vault. Vi rekommenderar också att du återskapar dessa nycklar regelbundet. Endast en nyckel krävs för att göra ett API-anrop. När du återskapar den första nyckeln kan du använda den andra nyckeln för fortsatt åtkomst till tjänsten.

App-ID `{APP_ID}`

Det här ID:t används för att välja appen. Du hittar app-ID:t i LUIS-portalen genom att klicka på Hantera överst på skärmen för din app och sedan Inställningar.

Redigeringsnyckel `{AUTHORING_KEY}`

Den här nyckeln används för att hämta den paketerade appen från LUIS-tjänsten i molnet och ladda upp frågeloggarna tillbaka till molnet. Du behöver din redigeringsnyckel om du exporterar din app med hjälp av REST-API:et, som beskrivs senare i artikeln.

Du kan hämta redigeringsnyckeln från LUIS-portalen genom att klicka på Hantera överst på skärmen för din app och sedan azure-resurser.

Redigera API:er för paketfil

Redigera API:er för paketerade appar:

Värddatorn

Värden är en x64-baserad dator som kör Docker-containern. Det kan vara en dator lokalt eller en Docker-värdtjänst i Azure, till exempel:

Azure Kubernetes Service.
Azure Container Instances.
Ett Kubernetes-kluster som distribuerats till Azure Stack. Mer information finns i Distribuera Kubernetes till Azure Stack.

Krav och rekommendationer för containrar

I tabellen nedan visas lägsta och rekommenderade värden för containervärden. Dina krav kan ändras beroende på trafikvolym.

Container	Lägsta	Rekommenderas	TPS (Minimum, Maximum)
LUIS	1 kärna, 2 GB minne	1 kärna, 4 GB minne	20, 40

Varje kärna måste vara minst 2,6 gigahertz (GHz) eller snabbare.
TPS – transaktioner per sekund

Kärna och minne motsvarar --cpus inställningarna och --memory som används som en del av docker run kommandot.

Hämta containeravbildningen med `docker pull`

LUIS-containeravbildningen finns i mcr.microsoft.com containerregistersyndikatet. Den finns på lagringsplatsen azure-cognitive-services/language och heter luis. Det fullständigt kvalificerade containeravbildningsnamnet är , mcr.microsoft.com/azure-cognitive-services/language/luis.

Om du vill använda den senaste versionen av containern kan du använda taggen latest . Du hittar också en fullständig lista över taggar på MCR.

docker pull Använd kommandot för att ladda ned en containeravbildning från lagringsplatsenmcr.microsoft.com/azure-cognitive-services/language/luis:

docker pull mcr.microsoft.com/azure-cognitive-services/language/luis:latest

En fullständig beskrivning av tillgängliga taggar, till exempel används latest i föregående kommando, finns i LUIS på Docker Hub.

Dricks

Du kan använda kommandot docker images för att visa en lista över dina nedladdade containeravbildningar. Följande kommando visar till exempel ID, lagringsplats och tagg för varje nedladdad containeravbildning, formaterad som en tabell:

docker images --format "table {{.ID}}\t{{.Repository}}\t{{.Tag}}"

IMAGE ID         REPOSITORY                TAG
<image-id>       <repository-path/name>    <tag-name>

Så här använder du containern

När containern finns på värddatorn använder du följande process för att arbeta med containern.

Process för att använda LUIS-container (Language Understanding)

Exportera paket för container från LUIS-portalen eller LUIS-API:er.
Flytta paketfilen till den nödvändiga indatakatalogen på värddatorn. Byt inte namn på, ändra, skriva över eller dekomprimera LUIS-paketfilen.
Kör containern med nödvändig indatamontering och faktureringsinställningar. Fler exempel på docker run kommandot är tillgängliga.
Köra frågor mot containerns förutsägelseslutpunkt.
När du är klar med containern importerar du slutpunktsloggarna från utdatamonteringen i LUIS-portalen och stoppar containern.
Använd LUIS-portalens aktiva inlärning på sidan Granska slutpunktsyttranden för att förbättra appen.

Det går inte att ändra appen som körs i containern. För att kunna ändra appen i containern måste du ändra appen i LUIS-tjänsten med hjälp av LUIS-portalen eller använda LUIS-redigerings-API :erna. Träna och/eller publicera och ladda sedan ned ett nytt paket och kör containern igen.

LUIS-appen i containern kan inte exporteras tillbaka till LUIS-tjänsten. Endast frågeloggarna kan laddas upp.

Exportera paketerad app från LUIS

LUIS-containern kräver en tränad eller publicerad LUIS-app för att besvara förutsägelsefrågor för användaryttranden. För att hämta LUIS-appen använder du antingen det tränade eller publicerade paket-API:et.

Standardplatsen är underkatalogen input i förhållande till var du kör docker run kommandot.

Placera paketfilen i en katalog och referera till den här katalogen som indatamontering när du kör Docker-containern.

Pakettyper

Indatamonteringskatalogen kan innehålla modellerna Produktion, Mellanlagring och Version av appen samtidigt. Alla paket monteras.

Pakettyp	Frågeslutpunkts-API	Frågetillgänglighet	Filnamnsformat för paket
Versionshanterad	GET, POST	Endast container	`{APP_ID}_v{APP_VERSION}.gz`
Mellanlagring	GET, POST	Azure och container	`{APP_ID}_STAGING.gz`
Produktion	GET, POST	Azure och container	`{APP_ID}_PRODUCTION.gz`

Viktigt!

Byt inte namn på, ändra, skriva över eller dekomprimera LUIS-paketfilerna.

Krav för paketering

Innan du paketerar ett LUIS-program måste du ha följande:

Paketeringskrav	Details
Azure Azure AI Services-resursinstans	Bland de regioner som stöds finns USA, västra (`westus`) Europa, västra (`westeurope`) Australien, östra (`australiaeast`)
Tränad eller publicerad LUIS-app	Utan beroenden som inte stöds.
Åtkomst till värddatorns filsystem	Värddatorn måste tillåta en indatamontering.

Exportera apppaket från LUIS-portalen

LUIS-portalen ger möjlighet att exportera den tränade eller publicerade appens paket.

Exportera publicerade appars paket från LUIS-portalen

Den publicerade appens paket är tillgängligt från sidan Mina appar lista.

Logga in på LUIS-portalen.
Markera kryssrutan till vänster om appnamnet i listan.
Välj objektet Exportera i det kontextuella verktygsfältet ovanför listan.
Välj Exportera för container (GZIP).
Välj miljön för produktionsplatsen eller mellanlagringsplatsen.
Paketet laddas ned från webbläsaren.

Exportera det publicerade paketet för containern från appsidans exportmeny

Exportera versionsappens paket från LUIS-portalen

Versionsappens paket är tillgängligt från sidan Versionslista .

Logga in på LUIS-portalen.
Välj appen i listan.
Välj Hantera i appens navigeringsfält.
Välj Versioner i det vänstra navigeringsfältet.
Markera kryssrutan till vänster om versionsnamnet i listan.
Välj objektet Exportera i det kontextuella verktygsfältet ovanför listan.
Välj Exportera för container (GZIP).
Paketet laddas ned från webbläsaren.

Exportera det tränade paketet för containern från sidan Versioners Export-meny

Exportera publicerade appars paket från API

Använd följande REST API-metod för att paketera en LUIS-app som du redan har publicerat. Ersätta dina egna lämpliga värden för platshållarna i API-anropet med hjälp av tabellen under HTTP-specifikationen.

GET /luis/api/v2.0/package/{APP_ID}/slot/{SLOT_NAME}/gzip HTTP/1.1
Host: {AZURE_REGION}.api.cognitive.microsoft.com
Ocp-Apim-Subscription-Key: {AUTHORING_KEY}

Platshållare	Värde
{APP_ID}	Program-ID för den publicerade LUIS-appen.
{SLOT_NAME}	Miljön för den publicerade LUIS-appen. Använd något av följande värden: `PRODUCTION` `STAGING`
{AUTHORING_KEY}	Redigeringsnyckeln för LUIS-kontot för den publicerade LUIS-appen. Du kan hämta redigeringsnyckeln från sidan Användare Inställningar på LUIS-portalen.
{AZURE_REGION}	Lämplig Azure-region: `westus` - USA, västra `westeurope` - Europa, västra `australiaeast` - Australien, östra

Om du vill ladda ned det publicerade paketet läser du API-dokumentationen här. Om det har laddats ned är svaret en LUIS-paketfil. Spara filen på den lagringsplats som angetts för indatamonteringen för containern.

Exportera version av appens paket från API

Använd följande REST API-metod för att paketera ett LUIS-program som du redan har tränat. Ersätta dina egna lämpliga värden för platshållarna i API-anropet med hjälp av tabellen under HTTP-specifikationen.

GET /luis/api/v2.0/package/{APP_ID}/versions/{APP_VERSION}/gzip HTTP/1.1
Host: {AZURE_REGION}.api.cognitive.microsoft.com
Ocp-Apim-Subscription-Key: {AUTHORING_KEY}

Platshållare	Värde
{APP_ID}	Program-ID för den tränade LUIS-appen.
{APP_VERSION}	Programversionen av den tränade LUIS-appen.
{AUTHORING_KEY}	Redigeringsnyckeln för LUIS-kontot för den publicerade LUIS-appen. Du kan hämta redigeringsnyckeln från sidan Användare Inställningar på LUIS-portalen.
{AZURE_REGION}	Lämplig Azure-region: `westus` - USA, västra `westeurope` - Europa, västra `australiaeast` - Australien, östra

Om du vill ladda ned det versionshanterade paketet läser du API-dokumentationen här. Om det har laddats ned är svaret en LUIS-paketfil. Spara filen på den lagringsplats som angetts för indatamonteringen för containern.

Kör containern med `docker run`

Använd kommandot docker run för att köra containern. Mer information om hur du hämtar {ENDPOINT_URI} värdena och {API_KEY} finns i samla in obligatoriska parametrar.

Exempel på docker run kommandot är tillgängliga.

docker run --rm -it -p 5000:5000 ^
--memory 4g ^
--cpus 2 ^
--mount type=bind,src=c:\input,target=/input ^
--mount type=bind,src=c:\output\,target=/output ^
mcr.microsoft.com/azure-cognitive-services/language/luis ^
Eula=accept ^
Billing={ENDPOINT_URI} ^
ApiKey={API_KEY}

I det här exemplet används katalogen utanför C: enheten för att undvika eventuella behörighetskonflikter i Windows. Om du behöver använda en specifik katalog som indatakatalog kan du behöva bevilja docker-tjänsten behörighet.
Ändra inte ordningen på argumenten om du inte är bekant med Docker-containrar.
Om du använder ett annat operativsystem använder du rätt konsol/terminal, mappsyntax för monteringar och radfortsättningstecken för systemet. Dessa exempel förutsätter en Windows-konsol med ett radfortsättningstecken ^. Eftersom containern är ett Linux-operativsystem använder målmonteringen en mappsyntax i Linux-stil.

Det här kommandot:

Kör en container från LUIS-containeravbildningen
Läser in LUIS-appen från indatamonteringen på C:\input, som finns på containervärden
Allokerar två CPU-kärnor och 4 gigabyte (GB) minne
Exponerar TCP-port 5000 och allokerar en pseudo-TTY för containern
Sparar container- och LUIS-loggar till utdatamontering på C:\output, som finns på containervärden
Tar automatiskt bort containern när den har avslutats. Containeravbildningen är fortfarande tillgänglig på värddatorn.

Fler exempel på docker run kommandot är tillgängliga.

Viktigt!

Alternativen Eula, Billingoch ApiKey måste anges för att köra containern. Annars startar inte containern. Mer information finns i Fakturering. ApiKey-värdet är nyckeln från sidan Azure-resurser i LUIS-portalen och är också tillgängligt på sidan Azure-resursnycklar Azure AI services .

Köra flera containrar på samma värd

Om du tänker köra flera containrar med exponerade portar ska du köra varje container med en annan exponerad port. Kör till exempel den första containern på port 5000 och den andra containern på port 5001.

Du kan ha den här containern och en annan Azure AI-tjänstcontainer som körs på VÄRDEN tillsammans. Du kan också ha flera containrar av samma Azure AI-tjänstcontainer som körs.

Slutpunkts-API:er som stöds av containern

Både V2- och V3-versioner av API:et är tillgängliga med containern.

Köra frågor mot containerns förutsägelseslutpunkt

Containern innehåller REST-baserade slutpunkts-API:er för frågeförutsägelse. Slutpunkter för publicerade appar (mellanlagring eller produktion) har en annan väg än slutpunkter för versionsbaserade appar.

Använd värden, http://localhost:5000, för container-API:er.

Pakettyp	HTTP-verb	Flöde	Frågeparametrar
Publicerad	GET, POST	`/luis/v3.0/apps/{appId}/slots/{slotName}/predict?` `/luis/prediction/v3.0/apps/{appId}/slots/{slotName}/predict?`	`query={query}` [`&verbose`] [`&log`] [`&show-all-intents`]
Versionshanterad	GET, POST	`/luis/v3.0/apps/{appId}/versions/{versionId}/predict?` `/luis/prediction/v3.0/apps/{appId}/versions/{versionId}/predict`	`query={query}` [`&verbose`] [`&log`] [`&show-all-intents`]

Frågeparametrarna konfigurerar hur och vad som returneras i frågesvaret:

Frågeparameter	Typ	Syfte
`query`	sträng	Användarens yttrande.
`verbose`	boolean	Ett booleskt värde som anger om alla metadata för de förutsagda modellerna ska returneras. Standardvärdet är falskt.
`log`	boolean	Loggar frågor som kan användas senare för aktiv inlärning. Standardvärdet är falskt.
`show-all-intents`	boolean	Ett booleskt värde som anger om du endast vill returnera alla avsikter eller avsikten med högsta poäng. Standardvärdet är falskt.

Fråga LUIS-appen

Ett exempel på ETT CURL-kommando för att fråga containern om en publicerad app är:

V3-förutsägelseslutpunkt
V2-förutsägelseslutpunkt

Om du vill köra frågor mot en modell i ett fack använder du följande API:

curl -G \
-d verbose=false \
-d log=true \
--data-urlencode "query=turn the lights on" \
"http://localhost:5000/luis/v3.0/apps/{APP_ID}/slots/production/predict"

Om du vill göra frågor till mellanlagringsmiljön ersätter du production i vägen med staging:

http://localhost:5000/luis/v3.0/apps/{APP_ID}/slots/staging/predict

Om du vill köra frågor mot en version av en modell använder du följande API:

curl -G \
-d verbose=false \
-d log=false \
--data-urlencode "query=turn the lights on" \
"http://localhost:5000/luis/v3.0/apps/{APP_ID}/versions/{APP_VERSION}/predict"

Om du vill köra frågor mot en modell i ett fack använder du följande API:

curl -X GET \
"http://localhost:5000/luis/v2.0/apps/{APP_ID}?q=turn%20on%20the%20lights&staging=false&timezoneOffset=0&verbose=false&log=true" \
-H "accept: application/json"

Om du vill göra frågor till mellanlagringsmiljön ändrar du parametervärdet för mellanlagringsfrågans sträng till true:

staging=true

Om du vill köra frågor mot en version av en modell använder du följande API:

curl -X GET \
"http://localhost:5000/luis/v2.0/apps/{APP_ID}/versions/{APP_VERSION}?q=turn%20on%20the%20lights&timezoneOffset=0&verbose=false&log=true" \
-H "accept: application/json"

Versionsnamnet har högst 10 tecken och innehåller endast tecken som tillåts i en URL.

Importera slutpunktsloggarna för aktiv inlärning

Om en utdatamontering har angetts för LUIS-containern sparas appfrågeloggfilerna i utdatakatalogen, där {INSTANCE_ID} är container-ID:t. Appfrågeloggen innehåller frågan, svaret och tidsstämplarna för varje förutsägelsefråga som skickas till LUIS-containern.

Följande plats visar den kapslade katalogstrukturen för containerns loggfiler.

/output/luis/{INSTANCE_ID}/

Från LUIS-portalen väljer du din app och sedan Importera slutpunktsloggar för att ladda upp loggarna.

Importera containerns loggfiler för aktiv inlärning

När loggen har laddats upp granskar du slutpunktsyttrandena i LUIS-portalen.

Verifiera att en container körs

Det finns flera sätt att verifiera att containern körs. Leta upp den externa IP-adressen och den exponerade porten för containern i fråga och öppna din favoritwebbläsare. Använd de olika url:er för begäranden som följer för att verifiera att containern körs. Exempelbegärande-URL:er som anges här är http://localhost:5000, men din specifika container kan variera. Se till att förlita dig på containerns externa IP-adress och exponerade port.

Begärans-URL	Syfte
`http://localhost:5000/`	Containern tillhandahåller en startsida.
`http://localhost:5000/ready`	Den här URL:en begärs med GET och tillhandahåller en verifiering av att containern är redo att acceptera en fråga mot modellen. Den här begäran kan användas för Kubernetes liveness- och beredskapsavsökningar.
`http://localhost:5000/status`	Den här URL:en begärs också med GET och kontrollerar om api-nyckeln som används för att starta containern är giltig utan att orsaka en slutpunktsfråga. Den här begäran kan användas för Kubernetes liveness- och beredskapsavsökningar.
`http://localhost:5000/swagger`	Containern tillhandahåller en fullständig uppsättning dokumentation för slutpunkterna samt en Prova-funktion. Med den här funktionen kan du ange inställningarna i ett webbaserat HTML-formulär och göra frågan utan att behöva skriva någon kod. När frågan har returnerats tillhandahålls ett exempel på CURL-kommandot för att demonstrera de HTTP-huvuden och brödtextformat som krävs.

Containerns startsida

Kör containern frånkopplad från Internet

Om du vill använda den här containern frånkopplad från Internet måste du först begära åtkomst genom att fylla i ett program och köpa en åtagandeplan. Mer information finns i Använda Docker-containrar i frånkopplade miljöer .

Om du har godkänts för att köra containern frånkopplad från Internet använder du följande exempel som visar formateringen för det docker run kommando som du ska använda, med platshållarvärden. Ersätt dessa platshållarvärden med dina egna värden.

Parametern DownloadLicense=True i kommandot docker run laddar ned en licensfil som gör att Docker-containern kan köras när den inte är ansluten till Internet. Den innehåller också ett förfallodatum, varefter licensfilen är ogiltig för att köra containern. Du kan bara använda en licensfil med lämplig container som du har godkänts för. Du kan till exempel inte använda en licensfil för en tal-till-text-container med en dokumentinformationscontainer.

Platshållare	Värde	Format eller exempel
`{IMAGE}`	Den containeravbildning som du vill använda.	`mcr.microsoft.com/azure-cognitive-services/form-recognizer/invoice`
`{LICENSE_MOUNT}`	Sökvägen där licensen laddas ned och monteras.	`/host/license:/path/to/license/directory`
`{ENDPOINT_URI}`	Slutpunkten för att autentisera din tjänstbegäran. Du hittar den på resursens nyckel- och slutpunktssida i Azure-portalen.	`https://<your-custom-subdomain>.cognitiveservices.azure.com`
`{API_KEY}`	Nyckeln för din Textanalys resurs. Du hittar den på resursens nyckel- och slutpunktssida i Azure-portalen.	`xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`
`{CONTAINER_LICENSE_DIRECTORY}`	Plats för licensmappen i containerns lokala filsystem.	`/path/to/license/directory`

docker run --rm -it -p 5000:5000 \ 
-v {LICENSE_MOUNT} \
{IMAGE} \
eula=accept \
billing={ENDPOINT_URI} \
apikey={API_KEY} \
DownloadLicense=True \
Mounts:License={CONTAINER_LICENSE_DIRECTORY}

När licensfilen har laddats ned kan du köra containern i en frånkopplad miljö. I följande exempel visas formateringen för det docker run kommando som du ska använda, med platshållarvärden. Ersätt dessa platshållarvärden med dina egna värden.

Oavsett var containern körs måste licensfilen monteras på containern och platsen för licensmappen i containerns lokala filsystem måste anges med Mounts:License=. En utdatamontering måste också anges så att faktureringsanvändningsposter kan skrivas.

Platshållare	Värde	Format eller exempel
`{IMAGE}`	Den containeravbildning som du vill använda.	`mcr.microsoft.com/azure-cognitive-services/form-recognizer/invoice`
`{MEMORY_SIZE}`	Lämplig storlek på minne som ska allokeras för containern.	`4g`
`{NUMBER_CPUS}`	Lämpligt antal processorer som ska allokeras för din container.	`4`
`{LICENSE_MOUNT}`	Sökvägen där licensen ska finnas och monteras.	`/host/license:/path/to/license/directory`
`{OUTPUT_PATH}`	Utdatasökvägen för loggning av användningsposter.	`/host/output:/path/to/output/directory`
`{CONTAINER_LICENSE_DIRECTORY}`	Plats för licensmappen i containerns lokala filsystem.	`/path/to/license/directory`
`{CONTAINER_OUTPUT_DIRECTORY}`	Plats för utdatamappen i containerns lokala filsystem.	`/path/to/output/directory`

docker run --rm -it -p 5000:5000 --memory {MEMORY_SIZE} --cpus {NUMBER_CPUS} \ 
-v {LICENSE_MOUNT} \ 
-v {OUTPUT_PATH} \
{IMAGE} \
eula=accept \
Mounts:License={CONTAINER_LICENSE_DIRECTORY}
Mounts:Output={CONTAINER_OUTPUT_DIRECTORY}

Stoppa containern

Om du vill stänga av containern trycker du på Ctrl+C i kommandoradsmiljön där containern körs.

Felsökning

Om du kör containern med en utdatamontering och loggning aktiverad genererar containern loggfiler som är användbara för att felsöka problem som inträffar när containern startas eller körs.

Dricks

Mer felsökningsinformation och vägledning finns i Vanliga frågor och svar om Azure AI-containrar.

Om du har problem med att köra en Azure AI-tjänstcontainer kan du prova att använda Microsofts diagnostikcontainer. Använd den här containern för att diagnostisera vanliga fel i distributionsmiljön som kan förhindra att Azure AI-containrar fungerar som förväntat.

Använd följande docker pull kommando för att hämta containern:

docker pull mcr.microsoft.com/azure-cognitive-services/diagnostic

Kör sedan containern. Ersätt {ENDPOINT_URI} med slutpunkten och ersätt {API_KEY} med nyckeln till resursen:

docker run --rm mcr.microsoft.com/azure-cognitive-services/diagnostic \
eula=accept \
Billing={ENDPOINT_URI} \
ApiKey={API_KEY}

Containern testar nätverksanslutningen till faktureringsslutpunkten.

Fakturering

LUIS-containern skickar faktureringsinformation till Azure med hjälp av en Azure AI-tjänstresurs på ditt Azure-konto.

Frågor till containern faktureras på prisnivån för den Azure-resurs som används för parametern ApiKey .

Azure AI-tjänstcontainrar är inte licensierade att köras utan att vara anslutna till slutpunkten för mätning eller fakturering. Du måste aktivera containrarna för att kunna kommunicera faktureringsinformation med faktureringsslutpunkten hela tiden. Azure AI-tjänstcontainrar skickar inte kunddata, till exempel den bild eller text som analyseras, till Microsoft.

Ansluta till Azure

Containern behöver faktureringsargumentvärdena för att köras. Med de här värdena kan containern ansluta till faktureringsslutpunkten. Containern rapporterar användning var 10:e till 15:e minut. Om containern inte ansluter till Azure inom den tillåtna tidsperioden fortsätter containern att köras men hanterar inte frågor förrän faktureringsslutpunkten har återställts. Anslutningen görs 10 gånger med samma tidsintervall på 10 till 15 minuter. Om den inte kan ansluta till faktureringsslutpunkten inom de 10 försöken slutar containern att hantera begäranden. Se vanliga frågor och svar om Azure AI-tjänstcontainern för ett exempel på den information som skickas till Microsoft för fakturering.

Faktureringsargument

Kommandot docker run startar containern när alla tre av följande alternativ har giltiga värden:

Alternativ	Description
`ApiKey`	API-nyckeln för azure AI-tjänstresursen som används för att spåra faktureringsinformation. Värdet för det här alternativet måste anges till en API-nyckel för den etablerade resursen som anges i `Billing`.
`Billing`	Slutpunkten för azure AI-tjänstresursen som används för att spåra faktureringsinformation. Värdet för det här alternativet måste anges till slutpunkts-URI:n för en etablerad Azure-resurs.
`Eula`	Anger att du har godkänt licensen för containern. Värdet för det här alternativet måste vara inställt på att acceptera.

Mer information om de här alternativen finns i Konfigurera containrar.

Sammanfattning

I den här artikeln har du lärt dig begrepp och arbetsflöden för att ladda ned, installera och köra LUIS-containrar (Language Understanding). Sammanfattningsvis:

Language Understanding (LUIS) tillhandahåller en Linux-container för Docker som tillhandahåller slutpunktsfrågeförutsägelser för yttranden.
Containeravbildningar laddas ned från Microsoft Container Registry (MCR).
Containeravbildningar körs i Docker.
Du kan använda REST API för att köra frågor mot containerslutpunkterna genom att ange containerns värd-URI.
Du måste ange faktureringsinformation när du instansierar en container.

Viktigt!

Azure AI-containrar är inte licensierade att köras utan att vara anslutna till Azure för mätning. Kunder måste göra det möjligt för containrarna att kommunicera faktureringsinformation med mätningstjänsten hela tiden. Azure AI-containrar skickar inte kunddata (till exempel den bild eller text som analyseras) till Microsoft.

Nästa steg

Granska Konfigurera containrar för konfigurationsinställningar.
Se BEGRÄNSNINGAR för LUIS-container för kända kapacitetsbegränsningar .
Se Felsökning för att lösa problem som rör LUIS-funktioner.
Använda fler Azure AI-containrar

Installera och köra Docker-containrar för LUIS

Förutsättningar

Samla in obligatoriska parametrar

Slutpunkts-URI

Nycklar

App-ID {APP_ID}

Redigeringsnyckel {AUTHORING_KEY}

Redigera API:er för paketfil

Värddatorn

Krav och rekommendationer för containrar

Hämta containeravbildningen med docker pull

Så här använder du containern

Exportera paketerad app från LUIS

Pakettyper

Krav för paketering

Exportera apppaket från LUIS-portalen

Exportera publicerade appars paket från LUIS-portalen

Exportera versionsappens paket från LUIS-portalen

Exportera publicerade appars paket från API

Exportera version av appens paket från API

Kör containern med docker run

Köra flera containrar på samma värd

Slutpunkts-API:er som stöds av containern

Köra frågor mot containerns förutsägelseslutpunkt

Fråga LUIS-appen

Importera slutpunktsloggarna för aktiv inlärning

Verifiera att en container körs

Kör containern frånkopplad från Internet

Stoppa containern

Felsökning

Fakturering

Ansluta till Azure

Faktureringsargument

Sammanfattning

Nästa steg

Ytterligare resurser

App-ID `{APP_ID}`

Redigeringsnyckel `{AUTHORING_KEY}`

Hämta containeravbildningen med `docker pull`

Kör containern med `docker run`