.lu-filformat

GÄLLER FÖR: SDK v4

En .lu-fil beskriver en språktolkningsmodell. En .lu-fil innehåller Markdown-liknande, enkla textbaserade definitioner för begrepp för språktolkning. Du kan använda en eller flera .lu-filer för att träna en språkmodell för tjänsten eller motorn för förståelse av naturligt språk (NLU) som roboten använder, till exempel Language Understanding (LUIS) eller Orchestrator. NLU-motorn du väljer kanske bara kan tolka delmängden av de element som en .lu-fil kan beskriva.

En NLU-motor förlitar sig på en språkmodell för att förstå vad en användare säger. Motorn skapar en språkmodell från uppsättningar med träningsexempel, precis som alla maskininlärningsalgoritmer. När motorn har tränats använder den modellen för att förutsäga avsikten med ett yttrande, vanligtvis i form av en eller flera avsikter som representerar en uppgift eller åtgärd som användaren vill utföra och noll eller flera entiteter som representerar element som är relevanta för avsikten.

Du kan använda LUIS eller Orchestrator med valfri robot som utvecklats med Hjälp av Bot Framework SDK eller Composer.

Kommentar

Language Understanding (LUIS) dras tillbaka den 1 oktober 2025. Från och med den 1 april 2023 kan du inte skapa nya LUIS-resurser. En nyare version av språktolkning är nu tillgänglig som en del av Azure AI Language.

Conversational Language Understanding (CLU), en funktion i Azure AI Language, är den uppdaterade versionen av LUIS. Mer information om stöd för språktolkning i Bot Framework SDK finns i Förstå naturligt språk.

Den här artikeln är en referens för hur du representerar språkmodellelement i .lu-filformatet. Information om hur språktolkning används i robotar finns i Language Understanding eller Bearbetning av naturligt språk i Composer.

Definiera avsikter med hjälp av exempelyttranden

En avsikt representerar en uppgift eller åtgärd som användaren vill utföra, vilket uttrycks i en användares yttrande. Du lägger till avsikter i roboten så att den kan identifiera grupper med frågor eller kommandon som representerar samma användar avsikt.

Några exempel på avsikter som du kan definiera för en reserobot, med exempelyttranden som de definieras från:

Avsikt	Exempel på yttranden
BookFlight (Boka flyg)	"Boka ett flyg till Maui nästa vecka" "Flyga mig till Maui den 17: e" "Jag behöver en flygbiljett nästa fredag till Maui"
Hälsning	"Hej" "Hej" "Bra eftermiddag"
CheckWeather	"Hur är vädret i Maui nästa vecka?"
None	"Jag gillar kakor" "Bullfrogs har registrerats hoppa över 7 fot"

Förutom de avsikter som du definierar är None en reserv-avsikt som gör unknownIntent att händelsen utlöses när inga avsikter kan fastställas från användarnas yttrande. När du använder LUIS är avsikten Ingen en obligatorisk avsikt som du behöver skapa med yttranden som ligger utanför domänen. Yttrandena som är associerade med avsikten Ingen bör bestå av ungefär 10 % av de totala yttrandena i .lu-filen.

Avsikter med deras exempelyttranden deklareras på följande sätt:

# <intent-name>
    - <utterance1>
    - <utterance2>

# <intent-name> beskriver ett nytt avsnitt för avsiktsdefinition. Varje rad efter avsiktsdefinitionen är exempelyttranden som beskriver avsikten - <utterance> med formatet .

Här är en .lu-exempelfil som visar dessa avsikter och exempelyttranden som samlar in sätt som användare kan uttrycka avsikten på:

> Use ">" to create a comment in your .lu files.
> Use multiple comment ">" characters to define outlining
> sections in the file to help you organize the content.

>> Primary intents
# BookFlight
- Book me a flight to Maui next week
- Fly me to Maui on the 17th
- I need a plane ticket next Friday to Maui

# Greeting
- Hi
- Hello
- Good afternoon

>> Secondary intents
# CheckWeather
- What's the weather like in Maui next week?

Kommentar

-Använd tecknet , +eller * för att ange listor. Numrerade listor stöds inte.

Använd > för att skapa en kommentar.

Flera kommentarstecken (">") kan också användas för att definiera beskrivande avsnitt i .lu-filen som hjälper dig att organisera innehållet. Med Composer kan du dra nytta av att beskriva när du redigerar LU-filer.

Mer information om avsikter och yttranden finns i Avsikter i LUIS-appen och Förstå vilka bra yttranden som finns för LUIS-appen i LUIS-dokumentationen.

Entiteter

En entitet är en del av ett yttrande som kan betraktas som en parameter som kan användas i tolkningen av en avsikt. I yttrandet Boka till exempel en biljett till Maui är Maui en FlightDestination-entitet.

Exempel på användaryttrande	Avsikt förutsagd	Entiteter som extraherats	Förklaring
Hej hur mår du?	Hälsning	-	Inga entiteter att extrahera.
"Boka ett flyg till Maui"	BookFlight (Boka flyg)	"Maui"	Entiteten "FlightDestination" extraheras som "Maui".
"Hur är vädret i Maui nästa vecka?"	CheckWeather	"Maui", "nästa vecka"	Entiteten "WeatherLocation" extraheras som "Maui" och "DateRange"-entiteten extraheras som "nästa vecka".
"Jag vill beställa en liten pizza"	orderPizza	"liten"	Entiteten "Storlek" extraheras som "liten".
"Schedule a meeting at 1pm with Bob in Distribution" (”Boka ett möte kl. 13 med Bob”)	ScheduleMeeting (Boka möte)	"13:00", "Bob"	Entiteten "MeetingTime" extraheras som "13:00" och "Deltagare" extraheras som "Bob".

Dricks

Mer information om hur du använder entiteter i LUIS finns i Entiteter i LUIS-dokumentationen .

Entitetsdefinitioner

En entitetsdefinition definierar hur du identifierar ett spann i ett yttrande som en entitet som du sedan kan använda i roboten. Det finns många olika typer av entiteter, till exempel maskininlärning, fördefinierade, listor, reguljära uttryck och mönster.

Entitetsdefinitioner i .lu-filer startar posten med at sign (@) följt av typen av entitet och entitetsnamn:

@ <entity-type> <entity-name>

Alternativt kan varje entitet också ha roller som identifierar olika användningsområden för samma entitet. Du kan också lägga till funktioner för att göra ett bättre jobb med att identifiera entiteter . Den allmänna syntaxen ser ut så här:

@ <entity-type> <entity-name> [[hasRole[s]] <comma-separated-list-of-roles>] [hasFeature[s] <comma-separated-list-of-features>]

Entiteter som kräver en definition, till exempel entiteter för lista och reguljära uttryck , representeras med hjälp av följande notation:

@ <entity-type> <entity1-name> = <definition>

Ytterligare exempel på entitetsdeklarationer visas i följande avsnitt tillsammans med de entitetstyper som de gäller för.

Med undantag för fördefinierade entiteter kan entitetsnamn innehålla flera ord med blanksteg. Alla entitetsnamn med blanksteg måste omslutas med citattecken:

@ ml "this is a simple entity" role1, role2 = definition
@ ml 'another simple entity' hasRole role1 hasFeatures feature1, feature2

Entitetstyper

Det finns flera typer av entiteter i LUIS. I följande avsnitt får du lära dig mer om dessa entitetstyper och relaterade begrepp, till exempel roller och funktioner, och exempel på hur du skapar LU-mallar som använder dem.

Maskininlärd enhet

Maskininlärda entiteter är entiteter som gör att du kan ange exempel där du märker dem i exempelyttranden. Detta ger dem den kontext som behövs för att lära sig av. Den maskininlärda entiteten är idealisk när du identifierar data som inte alltid är väl formaterade men som har samma betydelse.

I följande exempel visas en maskininlärd entitet med namnet city (@ ml city) och en bookFlight avsikt med exempelyttranden med dina entiteter märkta:

> Define the city machine-learned entity
@ ml city

> Define the bookFlight intent with sample utterances that contain the machine-learned entities
# bookFlight
- Book a flight from {@city = Cairo} to {@city = Seattle}
- Get me 2 tickets for a flight to {@city = Bengaluru}
- Purchase ticket from {@city = Washington} to {@city = Tampa Bay}

När en användare säger något liknande "Jag behöver ett flyg bokat från London till Madrid", KOMMER LUIS att upptäcka avsikten "bookFlight" och extrahera både London och Madrid som stadsentiteter.

Roller är i stort sett ytterligare ett lager med sammanhangsinformation som du kan lägga till i dina maskininlärda entiteter, som också lär sig av kontexten. Följande exempelyttrande visar de avgångs- och målroller som är associerade med entiteten city:

- Book a flight from {@city:departure = Cairo} to {@city:destination = Seattle}

Maskininlärda entiteter kan också vara komplexa där de har en hierarki med entiteter som är relaterade till varandra. Du kan till exempel ha något som liknar en entitet pizzaOrder som har följande underordnade entiteter: kvantitet, storlek, skorpa, toppings och så vidare.

Du definierar en underordnad entitet genom att föregå ett bindestreck (-) med at-tecknet (@) och indrag, vilket visas i följande exempel:

@ prebuilt number
@ list sizeList
@ list crustList
@ list toppingList

@ ml pizzaOrder
    - @ number Quantity
    - @ sizeList Size
    - @ crustList Crust
    - @ toppingList Topping

I exemplet ovan är talentiteten en fördefinierad entitet. De återstående entiteterna är alla listentiteter.

I nästa exempel visas en definition av en maskininlärd entitet address , med fromAddress och toAddress som två roller samt underordnade.

@ list cityList
@ prebuilt number
@ prebuilt geographyV2
@ regex regexZipcode = /[0-9]{5}/
@ ml address hasRoles fromAddress, toAddress
@ address =
    - @ number 'door number'
    - @ ml streetName
    - @ ml location usesFeature geographyV2
        - @ cityList city
        - @ regexZipcode zipcode

Förbyggda entiteter

Fördefinierade LUIS-entiteter definieras av systemet. Detta sparar arbete eftersom de är av hög kvalitet och ger normaliserade värden som är enklare att använda i program. Till exempel skulle frasen "tusen och två" bli talet 1002. Följande LUIS-typer [fördefinierade entitet][prebuilt-entity] stöds:

• ålder
• datetimeV2
• dimension
• E-post
• geographyV2
• keyPhrase
• money
• Nummer
• Ordinal
• ordinalV2
• procentandel
• personName
• telefonnummer
• temperatur
• url
• datetime

Här är exempel på hur du definierar fördefinierade entiteter:

@ prebuilt number 
@ prebuilt datetimeV2
@ prebuilt age

Lista entitet

[Lista entiteter] [list-entity] representerar en fast, stängd uppsättning relaterade ord tillsammans med deras synonymer. Det normaliserade värdet returneras när någon av motsvarande synonymer identifieras. De är skiftlägeskänsliga och extraherade baserat på en exakt textmatchning.

I följande exempel visas syntaxen för att definiera en listentitet:

@ list <entityName>  =
    - <normalized-value> :
        - <synonym1>
        - <synonym2>
        - ...
    - <normalized-value> :
        - <synonym1>, <synonym2>, ...

Om du utökar pizzaOrder exemplet från avsnittet maskininlärd entitet är här ett exempel på listor över underordnade entiteter för storlek och skorpa:

@ list sizeList = 
    - Extra Large :
        - extra large
        - XL
        - xl
        - huge
        - massive
    - Large:
        - large
        - big
    - Medium :
        - medium
        - regular
    - Small :
        - small
        - smallest
        - individual

@ list crustList = 
    - Stuffed Crust :
        - stuffed crust
        - stufffed crust
    - Thin :
        - thin
        - thin crust
    - Thick :
        - thick
        - thick crust
        - Deep Dish
        - deep dish

Dricks

Eftersom en listentitet kräver att en exakt matchning extraheras kan dina resultat förbättras genom att lägga till vanliga felstavningar. En vanlig orsak till felstavningar är ett resultat av skrivfel som dubbla bokstäver som tredubblas som i "fylld skorpa" i exemplet ovan.

När du använder listentiteter bör du inkludera ett värde från listan direkt i yttrandet, men du behöver inte märka listentiteter, även om du fortfarande kan använda dem som platshållare i ett mönster. I följande exempel visas ett yttrande med värden från listan:

- I'd like to order a large pepperoni stuffed crust pizza.

Entitet för reguljära uttryck

En [reguljär uttrycksentitet][regular-expression-entity] extraherar en entitet baserat på ett reguljärt uttrycksteckenmönster som du anger. Reguljära uttryck passar bäst för strukturerad text eller en fördefinierad sekvens med alfanumeriska värden som förväntas i ett visst format. Till exempel:

Enhet	Regular expression	Exempel
Flightnummer	flight [A-Z]{2} [0-9]{4}	flight AS 1234
Kreditkortsnummer	[0-9]{16}	5478789865437632

Här är ett exempel på entitetsdefinitioner för reguljära uttryck:

> Flight Number regular expression entity definition
@ regex flightNumber = /flight [A-Z]{2} [0-9]{4}/

> Credit Card Number regular expression entity definition
@ regex creditCardNumber = /[0-9]{16}/

Roller

En roll är ett namngivet alias för en entitet baserat på kontexten i ett yttrande. En roll kan användas med valfri fördefinierad eller anpassad entitetstyp och används i både exempelyttranden och mönster.

I exemplet nedan har entiteten Plats två roller och origin destination:

Enhet	Roll	Syfte
Plats	ursprung	Där planet avgår från
Plats	destination	Där planet landar

Roller i .lu-filformat kan definieras explicit eller implicit. Explicit rolldefinition följer notationen:

@ <entityType> <entityName> [hasRole[s]] role1, role2, ...

Nedan visas de olika sätt som du uttryckligen kan definiera entiteter och deras roller på:

> # ml entity definition with roles
> the following are 4 different approaches to define roles:

@ ml name role1, role2

@ ml name hasRoles role1, role2

@ ml name
@ name hasRoles role1, role2

@ ml name
@ name hasRole role1
@ name hasRole role2

Du kan också implicit definiera roller direkt i mönster och etiketterade yttranden med följande format:

{@<entityName>:<roleName>}

Du kan se i exemplet nedan hur rollerna userName:firstName och userName:lastName är implicit definierade:

# getUserName
- My first name is {@userName:firstName=vishwac}
- My full name is {@userName:firstName=vishwac} {@userName:lastName=kannan}
- Hello, I'm {@userName:firstName=vishwac}
- {@userName=vishwac} is my name

@ ml userName

I mönster kan du använda roller med hjälp av notationen {<entityName>:<roleName>} . Här är ett exempel:

# getUserName
- call me {name:userName}
- I'm {name:userName}
- my name is {name:userName}

Du kan också definiera flera roller för en entitet i mönster, se nedan:

> Roles can be specified for list entity types as well - in this case fromCity and toCity are added as roles to the 'city' list entity defined further below

# BookFlight
- book flight from {city:fromCity} to {city:toCity}
- [can you] get me a flight from {city:fromCity} to {city:toCity}
- get me a flight to {city:toCity}
- I need to fly from {city:fromCity}

$city:Seattle=
- Seattle
- Tacoma
- SeaTac
- SEA

$city:Portland=
- Portland
- PDX

Mönster

[Mönster] [] gör att du kan ta upp ett stort antal exempel som ska matchas genom att skapa ett yttrande med platshållare för var entiteter ska hittas. Mönstren är ett reguljärt uttryck på tokennivå med platshållare för entiteter. Om ett yttrande har någon entitetsplatshållare eller mönstersyntax tolkas det som ett mönster. Annars tolkas det som ett yttrande för att träna maskininlärning.

Innehavarna av entitetsplats kan motsvara entiteter av vilken typ som helst eller definieras av själva mönstret, till exempel när ett avsnitt i mönstret är en entitet som identifieras genom att titta på de omgivande orden.

Mönstersyntax

Filformatet .lu stöder LUIS [Mönstersyntax][]. Mönstersyntax är en mall som är inbäddad i ett yttrande. Mallen ska innehålla både ord och entiteter som du vill matcha, samt ord och skiljetecken som du vill ignorera. Mallen är inte ett reguljärt uttryck.

Entiteter i mönster omges av klammerparenteser, {}. Mönster kan omfatta entiteter och entiteter med roller. [Pattern.any] [pattern-any] är en entitet som endast används i mönster.

Function	Syntax	Kapslingsnivå	Exempel
entity	{} -Hängslen	2	Where is form {entity-name}?
valfri	[] - hakparenteser Det finns en gräns på 3 för kapslingsnivåer för valfri kombination och gruppering	2	The question mark is optional [?]
Gruppering	() - parenteser	2	is (a \| b)
eller	| - Lodrät stapel (rör) Det finns en gräns på 2 på de lodräta staplarna (eller) i en grupp	-	Where is form ({form-name-short} \| {form-name-long} \| {form-number})
början och/eller slutet av yttrandet	^-Cirkumflex	-	^begin the utterance the utterance is done^ ^strict literal match of entire utterance with {number} entity^

Mer information finns i artikeln [Mönstersyntax][] i LUIS-dokumentationen.

I följande exempel visas en definition som skulle behandlas som ett mönster med en entitet alarmTime som definieras av mönstret:

# DeleteAlarm
- delete the {alarmTime} alarm

Yttrandet "ta bort larmet 07:00" skulle matcha mönstret och skulle känna igen en entitet alarmTime av "07:00".

Däremot är följande exempel ett märkt yttrande där alarmTime är en maskininlärd entitet eftersom den har ett märkt värde 07:00:

# DeleteAlarm
- delete the {alarmTime=7AM} alarm

Du kan inte blanda entitetsetiketter och entitetsplatsinnehavare i samma yttrande, men du kan använda platshållare som motsvarar maskininlärda entiteter.

Dricks

Du bör förstå hur din robot svarar på användarindata innan du lägger till mönster, eftersom mönster är viktade mer än exempelyttranden och kommer att förvränga konfidensen. Det skadar inte att lägga till dem i början av modelldesignen, men det är lättare att se hur varje mönster ändrar modellen efter att modellen har testats med yttranden.

Fraslista

En [fraslista][fraslista] är en lista med ord eller fraser som hjälper dig att hitta det begrepp som du försöker identifiera. Listan är inte skiftlägeskänslig. Fraslistor har två olika syften:

• Utöka ordlistan: Detta är standard när du definierar en fraslista och kallas inte utbytbar. Fraser med flera ord blir en funktion i maskininlärningen som kräver färre exempel för att lära sig. I den här användningen finns det ingen relation mellan medlemmarna i faslistan.
• Definiera synonymer: Utbytbara fraslistor används för att definiera synonymer som betyder samma sak. Den här användningen hjälper till att generalisera med färre exempel. Alla fraser i listan resulterar i samma funktion som maskininlärningen. För att kunna använda detta måste du interchangeable ange i fraslistans definition (@ phraselist <Name>(interchangeable))

Kommentar

en funktion kan vara en fraslista eller en entitet som du associerar med en avsikt eller en entitet för att betona funktionens betydelse för att korrekt identifiera användar avsikt. Mer information finns i Lägga till en fraslista som en funktion .

Mer information om när och hur du använder fraslistor, inklusive vanliga scenarier som de används för, finns i [Skapa en fraslista för ett begrepp][fraslista].

Du definierar fraslistor med följande notation:

@ phraselist <Name>
    - <phrase1>
    - <phrase2>

Här är ett exempel på en fraslista som används för att utöka ordlistan:

@ phraseList newTerms=
- surf the sky
- jump on the beam
- blue sky pajamas

Fraslistor kan också användas för att definiera synonymer genom att markera dem som utbytbara.

@ phraseList Want(interchangeable) =
    - require, need, desire, know

> You can also break up the phrase list values into a bulleted list
@ phraseList Want(interchangeable) =
    - require
    - need
    - desire
    - know

Som standard är fraslistor tillgängliga för alla inlärda avsikter och entiteter. Det finns tre tillgänglighetstillstånd:

Tillgänglighetstillstånd	Description
enabledForAllModels	(standard) När en fraslista har markerats som enabledForAllModelsär den tillgänglig för alla modeller oavsett om du specifikt anger den som en funktion eller inte.
disabledForAllModels	När en fraslista är markerad som disabledForAllModelsanvänds den bara i en modell om den är specifikt listad som en funktion.
inaktiverat	När en fraslista är markerad som disabledanvänds den inte någonstans, inklusive modeller där den är specifikt listad som en funktion. Detta ger ett enkelt sätt att inaktivera en fraslista för att se hur bra saker fungerar utan den.

Fraslistor är globalt tillgängliga som standard och kan också anges specifikt med hjälp av nyckelordet enabledForAllModels :

@ phraselist abc enabledForAllModels

Två exempel på hur du ställer in en fraslista på disabledForAllModels:

@ phraselist abc disabledForAllModels

> You can also use this approach
@ phraselist question(interchangeable) =
    - are you
    - you are

@ question disabledForAllModels

När du anger en fraslista till disabledanvänds den inte, inte ens när den anges som en funktion:

> phrase list definition, temporarily set to disabled to measure its impact

@ phraselist yourPhraseList disabled

> phrase list as feature to intent, won't be used

@ intent yourIntent usesFeature yourPhraseList

Fraslistor kan användas som funktioner för specifika avsikter och entiteter enligt beskrivningen i nästa avsnitt.

Lägga till funktioner i avsikter och entiteter

Maskininlärning fungerar genom att ta funktioner och lära sig hur de relaterar till den önskade avsikten eller entiteten från exempelyttranden. Som standard är funktioner bara de ord som utgör yttranden. Fraslistor är ett sätt att gruppera flera ord i en ny funktion. Detta gör att maskininlärning generalisera bättre från färre exempel. Som standard är fraslistor globala och gäller för alla maskininlärda modeller, men du kan också koppla dem till specifika avsikter eller entiteter. Du kan också använda avsikter eller entiteter som funktioner för att identifiera andra avsikter som entiteter. Detta ger modularitet så att du kan bygga upp mer komplexa begrepp från enklare byggstenar.

Kommentar

I maskininlärning är en funktion text som beskriver ett särskiljande drag eller attribut för data som systemet observerar och lär sig av. Fraslistor, avsikter och entiteter kan användas som funktioner enligt beskrivningen i detta och följande avsnitt.

Funktioner kan läggas till i alla inlärda avsikter eller entiteter med hjälp av nyckelordet usesFeature .

Lägga till en fraslista som en funktion

Fraslistor kan läggas till som en funktion i avsikter eller entiteter. Detta hjälper dessa specifika avsikter eller entiteter utan att påverka andra avsikter och entiteter. Här är ett exempel på hur du definierar en fraslista som en funktion för en annan modell:

> phrase list definition

@ phraseList PLCity(interchangeable) =
    - seattle
    - space needle
    - SEATAC
    - SEA

> phrase list as feature to intent 

@ intent getUserProfileIntent usesFeature PLCity

> phrase list as a feature to an ml entity

@ ml myCity usesFeature PLCity

@ regex regexZipcode = /[0-9]{5}/

> a phrase list is used as a feature in a hierarchal entity

@ ml address fromAddress, toAddress
@ address =
    - @ number 'door number'
    - @ ml streetName
    - @ ml location
        - @ ml city usesFeature PLCity
        - @ regexZipcode zipcode

Lägga till en entitet eller avsikt som en funktion

Nedan visas exempel på hur du lägger till avsikter och entiteter som en funktion med usesFeature:

> entity definition - @ <entityType> <entityName> [<roles>]

@ prebuilt personName
@ prebuilt age

> entity definition with roles

@ ml userName hasRoles fistName, lastName

> add an entity as a feature to another entity

@ userName usesFeature personName

> add an entity as feature to an intent

@ intent getUserNameIntent usesFeature personName

> Intent definition

# getUserNameIntent
- utterances

> multiple entities as a feature to a model

@ intent getUserNameIntent usesFeature age, personName

> intent as a feature to another intent

@ intent getUserProfileIntent usesFeature getUserNameIntent

# getUserProfileIntent
- utterances

Metadata

Du kan inkludera metadata relaterade till ditt LUIS-program eller QnA Maker-kunskapsbas i .lu-filen. Detta hjälper till att dirigera parsern att hantera LU-innehållet korrekt. Metadata läggs vanligtvis till i början av .lu-filen.

Så här definierar du konfigurationsinformation med hjälp av > !#:

> !# @<property> = <value>
> !# @<scope>.<property> = <value>
> !# @<scope>.<property> = <semicolon-delimited-key-value-pairs>

Observera att all information som uttryckligen skickas via CLI-argument åsidosätter information i .lu-filen.

> LUIS application information
> !# @app.name = my luis application
> !# @app.desc = description of my luis application
> !# @app.versionId = 1.0
> !# @app.culture = en-us
> !# @app.luis_schema_version = 7.0.0
> !# @app.settings.NormalizePunctuation = true
> !# @app.settings.NormalizeWordForm = true
> !# @app.settings.UseAllTrainingData = true
> !# @app.tokenizerVersion = 1.0.0

Se tabellen nedan för en beskrivning av de värden för programmetadata som används i exemplet ovan. Information om app.settings i LUIS finns i [App- och versionsinställningar][luis-metadata] i LUIS-dokumentationen.

Metadata	Beskrivning
Namn	Ditt programnamn
VersionId	Namnet på den specifika versionen
Kultur	Det språk som används av ditt program
Schemaversion	LUIS-schemat uppdateras när en ny funktion eller inställning läggs till i LUIS. Använd det schemaversionsnummer som du använde när du skapade eller uppdaterade LUIS-modellen.

Externa referenser

Avsnitten nedan beskriver hur du gör lokala fil- och URI-referenser .

Lokala filreferenser

Kommentar

Azure AI QnA Maker dras tillbaka den 31 mars 2025. Från och med den 1 oktober 2022 kan du inte skapa nya QnA Maker resurser eller kunskapsbaser för 2022. En nyare version av fråge- och svarsfunktionen är nu tillgänglig som en del av Azure AI Language.

Svar på anpassade frågor, en funktion i Azure AI Language, är den uppdaterade versionen av QnA Maker-tjänsten. Mer information om stöd för frågor och svar i Bot Framework SDK finns i Förstå naturligt språk.

Refererar till .lu-filen. Följ Markdown-länksyntaxen. Referenser som stöds är:

• Referens till en annan .lu-fil via [link name](<.lu file name>). Referens kan vara en absolut sökväg eller en relativ sökväg från den innehållande .lu-filen.
• Referens till en mapp med andra .lu-filer stöds via:
  • [link name](<.lu file path>*): söker efter .lu-filer under den angivna absoluta eller relativa sökvägen
  • [link name](<.lu file path>**): söker rekursivt efter .lu-filer under den angivna absoluta eller relativa sökvägen, inklusive undermappar.
• Du kan också lägga till referenser till yttranden som definierats i en specifik fil under ett avsiktsavsnitt eller som QnA-par.
  • [link name](<.lu file path>#<INTENT-NAME>): hittar alla yttranden under <INTENT-NAME> i .lu-filen och lägger till dem i listan över yttranden där referensen anges.
  • [link name](<.lu file path>#<INTENT-NAME>*utterances*): hittar alla yttranden (inte mönster) under <INTENT-NAME> i .lu-filen och lägger till dem i listan över yttranden där referensen anges.
  • [link name](<.lu file path>#<INTENT-NAME>*patterns*): hittar alla mönster (inte yttranden) under <INTENT-NAME> i .lu-filen och lägger till dem i listan med mönster där referensen anges.
  • [link name](<.lu file path>#*utterances*): hittar alla yttranden i .lu-filen och lägger till dem i listan över yttranden där referensen har angetts.
  • [link name](<.lu file path>#*patterns*): hittar alla mönster i .lu-filen och lägger till dem i listan över yttranden där referensen har angetts.
  • [link name](<.lu file path>#*utterancesAndPatterns*): hittar alla yttranden och mönster i .lu-filen och lägger till dem i listan över yttranden där referensen anges.
  • [link name](<.qna file path>#$name?): hittar alla ändringar från den specifika ändringsdefinitionen i .qna-innehållet och lägger till dem i listan över yttranden där referensen anges.
  • [link name](<.qna file path>#*alterations*?): hittar alla ändringar från .qna-innehållet och lägger till dem i listan över yttranden där referensen anges.
  • [link name](<.qna file path>#?question-to-find?): hittar alla variantfrågor från den specifika frågan och lägger till dem i listan över yttranden där referensen anges. Observera att alla blanksteg i din fråga måste ersättas med - tecknet.
  • [link name](<.qna file path>#*answers*?): hittar alla svar och lägger till dem i listan över yttranden där referensen har angetts.

Här är ett exempel på ovan nämnda referenser:

> You can include references to other .lu files

[All LU files](./all.lu)

> References to other files can have wildcards in them

[en-us](./en-us/*)

> References to other lu files can include subfolders as well.
> /** indicates to the parser to recursively look for .lu files in all subfolders as well.

[all LU files](../**)

> You can include deep references to intents defined in a .lu file in utterances

# None
- [None uttearnces](./all.lu#Help)

> With the above statement, the parser will parse all.lu and extract out all utterances associated with the 'Help' intent and add them under 'None' intent as defined in this file.

> NOTE: This **only** works for utterances as entities that are referenced by the uttearnces in the 'Help' intent won't be brought forward to this .lu file.

# All utterances
> you can use the *utterances* wild card to include all utterances from a lu file. This includes utterances across all intents defined in that .lu file.
- [all.lu](./all.lu#*utterances*)
> you can use the *patterns* wild card to include all patterns from a lu file.
> - [all.lu](./all.lu#*patterns*)
> you can use the *utterancesAndPatterns* wild card to include all utterances and patterns from a lu file.
> - [all.lu](./all.lu#*utterancesAndPatterns*)

> You can include wild cards with deep references to QnA maker questions defined in a .qna file in utterances

# None
- [QnA questions](./*#?)

> With the above statement, the parser will parse **all** .lu files under ./, extract out all questions from QnA pairs in those files and add them under 'None' intent as defined in this file.

> You can include deep references to QnA maker questions defined in a .qna file in utterances

# None
- [QnA questions](./qna1.qna#?)

> With the above statement, the parser will parse qna1.lu and extract out all questions from QnA pairs in that file and add them under 'None' intent as defined in this file.

URI-referenser

Nedan visas exempel på hur du gör URI-referenser:

> URI to LU resource
[import](http://.../foo.lu)

# intent1
> Ability to pull in specific utterances from an intent
- [import](http://.../foo.lu#None)

# intent2
> Ability to pull in utterances or patterns or both from a specific intent 'None'
- [import](http://..../foo.lu#None*utterances*)
- [import](http://..../bar.lu#None*patterns*)
- [import](http://..../taz.lu#None*utterancesandpatterns*)

# intent3
> Ability to pull in all utterances or patterns or both across all intents
- [import](http://..../foo.lu#*utterances*)
- [import](http://..../bar.lu#*patterns*)
- [import](http://..../taz.lu#*utterancesandpatterns*)

Ytterligare Information

• Läs filformatet .qna för mer information om .qna-filer.