.lu-bestandsindeling

Artikel
10/24/2023

VAN TOEPASSING OP: SDK v4

Een .lu-bestand beschrijft een language understanding-model. Een LU-bestand bevat Markdown-achtige, eenvoudige op tekst gebaseerde definities voor taalbegripconcepten. U kunt een of meer .lu-bestanden gebruiken om een taalmodel te trainen voor de NLU-service (Natural Language Understanding) of engine die uw bot gebruikt, zoals Language Understanding (LUIS) of Orchestrator. De NLU-engine die u kiest, kan mogelijk alleen een subset interpreteren van de elementen die een .lu-bestand kan beschrijven.

Een NLU-engine is afhankelijk van een taalmodel om te begrijpen wat een gebruiker zegt. De engine maakt een taalmodel op basis van sets trainingsvoorbeelden, net zoals elk machine learning-algoritme. Zodra de engine is getraind, gebruikt de engine het model om de intentie van een uiting te voorspellen, meestal in de vorm van een of meer intenties die een taak of actie vertegenwoordigen die de gebruiker wil uitvoeren en nul of meer entiteiten die elementen vertegenwoordigen die relevant zijn voor de intentie.

U kunt LUIS of Orchestrator gebruiken met elke bot die is ontwikkeld met behulp van de Bot Framework SDK of Composer.

Notitie

Language Understanding (LUIS) wordt op 1 oktober 2025 buiten gebruik gesteld. Vanaf 1 april 2023 kunt u geen nieuwe LUIS-resources maken. Er is nu een nieuwere versie van taalkennis beschikbaar als onderdeel van Azure AI Language.

Conversational Language Understanding (CLU), een functie van Azure AI Language, is de bijgewerkte versie van LUIS. Zie Natuurlijke taalkennis voor meer informatie over ondersteuning voor taalkennis in de Bot Framework SDK.

Dit artikel is een verwijzing naar het weergeven van taalmodelelementen in de .lu-bestandsindeling. Zie Language Understanding of Natuurlijke taalverwerking in Composer voor informatie over hoe taalkennis wordt gebruikt in bots.

Intenties definiëren met behulp van voorbeelduitingen

Een intentie vertegenwoordigt een taak of actie die de gebruiker wil uitvoeren, zoals uitgedrukt in de uiting van een gebruiker. U voegt intenties toe aan uw bot om deze in staat te stellen groepen vragen of opdrachten te identificeren die dezelfde gebruikersintentie vertegenwoordigen.

Enkele voorbeelden van intenties die u kunt definiëren voor een reisbot, met de voorbeelduitingen waaruit ze zijn gedefinieerd:

Intentie	Voorbeelden van utterances
BookFlight	"Boek me volgende week een vlucht naar Maui" "Vlieg me naar Maui op de 17e" "Ik heb een vliegtuigticket nodig volgende vrijdag naar Maui"
Begroeting	"Hallo" "Hallo" "Goedemiddag"
Weersverwachting	"Hoe is het weer in Maui volgende week?"
Geen	"Ik hou van koekjes" "Bullfrogs zijn opgenomen die over 7 voet springen"

Naast de intenties die u definieert, is Geen een terugvalintentie die ervoor zorgt dat de unknownIntent gebeurtenis wordt geactiveerd wanneer er geen intenties kunnen worden bepaald door de uiting van gebruikers. Wanneer u LUIS gebruikt, is de intentie None een vereiste intentie die u moet maken met uitingen die zich buiten uw domein bevinden. De uitingen die zijn gekoppeld aan de intentie None moeten ongeveer 10% van de totale uitingen in uw .lu-bestand omvatten.

Intenties met hun voorbeelduitingen worden op de volgende manier gedeclareerd:

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

# <intent-name> beschrijft een sectie met een nieuwe intentiedefinitie. Elke regel na de intentiedefinitie zijn voorbeelduitingen die die intentie beschrijven met behulp van de - <utterance> indeling.

Hier volgt een voorbeeld van een LU-bestand waarin deze intenties en voorbeelduitingen worden gedemonstreerd die manieren vastleggen waarop gebruikers de intentie kunnen uitdrukken:

> 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?

Notitie

Gebruik het -+teken of het * teken om lijsten aan te geven. Genummerde lijsten worden niet ondersteund.

Gebruik > dit om een opmerking te maken.

Er kunnen ook meerdere opmerkingstekens (">") worden gebruikt om overzichtssecties in het LU-bestand te definiëren om u te helpen de inhoud te ordenen. Met Composer kunt u profiteren van een overzicht bij het bewerken van LU-bestanden.

Zie Intenties in uw LUIS-app voor meer informatie over intenties en uitingen en begrijp wat goede uitingen zijn voor uw LUIS-app in de LUIS-documentatie.

Entiteiten

Een entiteit maakt deel uit van een uiting die kan worden beschouwd als een parameter die kan worden gebruikt bij de interpretatie van een intentie. In de utterance Book bijvoorbeeld een ticket naar Maui, is Tenant een entiteit FlightDestination.

Voorbeeld van uiting van gebruiker	Voorspelde intentie	Geëxtraheerde entiteiten	Uitleg
Hallo hoe gaat het?	Begroeting	-	Er zijn geen entiteiten die moeten worden geëxtraheerd.
"Boek een vlucht naar Maui"	BookFlight	"Maui"	De entiteit FlightDestination wordt geëxtraheerd als 'Maui'.
"Hoe is het weer in Maui volgende week?"	Weersverwachting	"Maui", "volgende week"	De entiteit WeatherLocation wordt geëxtraheerd als De entiteit 'Maui' en 'DateRange' wordt geëxtraheerd als 'volgende week'.
"Ik wil een kleine pizza bestellen"	orderPizza	"klein"	De entiteit Grootte wordt geëxtraheerd als 'klein'.
"Een vergadering om 13:00 uur met Bob van Distributie plannen"	ScheduleMeeting	"13:00 uur", "Bob"	De entiteit MeetingTime wordt geëxtraheerd als '1pm' en de entiteit 'Deelnemers' wordt geëxtraheerd als 'Bob'.

Fooi

Zie Entiteiten in LUIS in de LUIS-documentatie voor meer informatie over het gebruik van entiteiten in LUIS.

Entiteitsdefinities

Een entiteitsdefinitie definieert hoe u een span in een uiting herkent als een entiteit die u vervolgens in uw bot kunt gebruiken. Er zijn veel verschillende typen entiteiten, waaronder: machine learning, vooraf samengesteld, lijsten, reguliere expressies en patronen.

Met entiteitsdefinities in LU-bestanden wordt de vermelding gestart met het teken (@) gevolgd door het type entiteit en de naam van de entiteit:

@ <entity-type> <entity-name>

Optioneel kan elke entiteit ook rollen hebben die verschillende toepassingen van dezelfde entiteit identificeren. U kunt ook functies toevoegen om een betere taak te bieden bij het herkennen van entiteiten. De algemene syntaxis ziet er als volgt uit:

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

Entiteiten waarvoor een definitie is vereist, zoals lijst - en reguliere expressie-entiteiten , worden weergegeven met behulp van de volgende notatie:

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

Aanvullende voorbeelden van entiteitsdeclaraties worden weergegeven in de volgende secties, samen met de entiteitstypen waarop ze van toepassing zijn.

Met uitzondering van vooraf gedefinieerde entiteiten kunnen entiteitsnamen meerdere woorden met spaties bevatten. Alle entiteitsnamen met spaties moeten tussen aanhalingstekens worden geplaatst:

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

Entiteitstypen

Er zijn verschillende typen entiteiten in LUIS. In de volgende secties leert u meer over deze entiteitstypen en gerelateerde concepten, zoals rollen en functies, en voorbeelden van het maken van LU-sjablonen die deze gebruiken.

Entiteit op basis van machine learning

Door machine learning-entiteiten zijn entiteiten waarmee u voorbeelden kunt opgeven waarin u ze labelt in de voorbeelduitingen. Dit geeft ze de context die nodig is om van te leren. De machine learning-entiteit is ideaal bij het identificeren van gegevens die niet altijd goed zijn opgemaakt, maar dezelfde betekenis hebben.

In het volgende voorbeeld ziet u een machine learning-entiteit met de naam plaats (@ ml city) en een bookFlight intentie met voorbeelduitingen met het label uw entiteiten:

> 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}

Wanneer een gebruiker iets soortgelijks zegt als 'Ik heb een vlucht nodig die van Londen naar Madrid is geboekt', detecteert LUIS de intentie 'bookFlight' en extraheert zowel Londen als Madrid als stadsentiteiten.

Rollen zijn in wezen een extra laag contextuele informatie die u kunt toevoegen aan uw door machines geleerde entiteiten, die ook leren van context. In de volgende voorbeelduiting ziet u de vertrek- en doelrollen die zijn gekoppeld aan de entiteit Plaats:

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

Machine learning-entiteiten kunnen ook complex zijn wanneer ze een hiërarchie van entiteiten hebben die aan elkaar zijn gerelateerd. U kunt bijvoorbeeld iets hebben als een pizzaOrder entiteit met de volgende onderliggende entiteiten: hoeveelheid, grootte, korst, toppings, enzovoort.

U definieert een onderliggende entiteit door een streepje (-) toe te stellen aan het at-teken (@) en inspringen, zoals in het volgende voorbeeld wordt gedemonstreerd:

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

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

In het bovenstaande voorbeeld is de getalentiteit een vooraf gedefinieerde entiteit. De resterende entiteiten zijn alle lijstentiteiten.

In het volgende voorbeeld ziet u een definitie van een address machine learning-entiteit, met fromAddress en toAddress als twee rollen, evenals onderliggende functies.

@ 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

Vooraf samengestelde entiteiten

Vooraf gemaakte LUIS-entiteiten worden gedefinieerd door het systeem. Dit bespaart u werk omdat ze van hoge kwaliteit zijn en genormaliseerde waarden bieden die gemakkelijker te gebruiken zijn in programma's. De woordgroep 'duizend en twee' wordt bijvoorbeeld het getal 1002. De volgende typen LUIS [vooraf gedefinieerde entiteit][vooraf gedefinieerde entiteiten] worden ondersteund:

leeftijd
datetimeV2
dimensie
e-mailadres
geographyV2
Keyphrase
money
Nummer
Ordinale
rangtelwoordV2
percentage
personName
phonenumber
temperatuur
URL
datum/tijd

Hier volgen voorbeelden van het definiëren van vooraf gedefinieerde entiteiten:

@ prebuilt number 
@ prebuilt datetimeV2
@ prebuilt age

Lijstentiteit

[Lijstentiteiten] [list-entity] vertegenwoordigt een vaste, gesloten set gerelateerde woorden, samen met hun synoniemen. De genormaliseerde waarde wordt geretourneerd wanneer een van de bijbehorende synoniemen wordt herkend. Ze zijn hoofdlettergevoelig en geëxtraheerd op basis van een exacte tekstovereenkomst.

In het volgende voorbeeld ziet u de syntaxis voor het definiëren van een lijstentiteit:

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

pizzaOrder Hier volgt een voorbeeld van lijsten voor de grootte en de onderliggende entiteiten van de korst:

@ 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

Fooi

Omdat voor een lijstentiteit een exacte overeenkomst moet worden geëxtraheerd, kunnen uw resultaten worden verbeterd door veelvoorkomende spelfouten toe te voegen. Een veelvoorkomende oorzaak van spelfouten is een gevolg van het typen van fouten, zoals dubbele letters drievoudig, zoals in 'gevulde korst' in het bovenstaande voorbeeld.

Wanneer u lijstentiteiten gebruikt, moet u rechtstreeks in de utterance een waarde uit de lijst opnemen, maar u hoeft lijstentiteiten niet te labelen, hoewel u ze nog steeds kunt gebruiken als tijdelijke aanduidingen in een patroon. In het volgende voorbeeld ziet u een uiting met waarden uit de lijst:

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

Een entiteit in de vorm van een reguliere expressie

Met een [reguliere expressie-entiteit][regular-expression-entity] wordt een entiteit geëxtraheerd op basis van een patroon voor reguliere expressies dat u opgeeft. Reguliere expressies zijn het meest geschikt voor gestructureerde tekst of een vooraf gedefinieerde reeks alfanumerieke waarden die in een bepaalde indeling worden verwacht. Bijvoorbeeld:

Entity	Regular expression	voorbeeld
Vluchtnummer	flight [A-Z]{2} [0-9]{4}	vlucht AS 1234
Creditcardnummer	[0-9]{16}	5478789865437632

Hier volgt een voorbeeld van de entiteitsdefinities voor reguliere expressies:

> 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}/

Rollen

Een rol is een benoemde alias voor een entiteit op basis van context binnen een utterance. Een rol kan worden gebruikt met elk vooraf gedefinieerd of aangepast entiteitstype en worden gebruikt in zowel voorbeelduitingen als patronen.

In het onderstaande voorbeeld heeft de entiteit Locatie twee rollen endestinationorigin:

Entity	- Rol	Doel
Locatie	origin	Waar het vliegtuig vertrekt
Locatie	destination	Waar het vliegtuig landt

Rollen in .lu-bestandsindeling kunnen expliciet of impliciet worden gedefinieerd. Expliciete roldefinitie volgt de notatie:

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

Hieronder ziet u de verschillende manieren waarop u entiteiten en hun rollen expliciet kunt definiëren:

> # 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

U kunt rollen ook impliciet definiëren in patronen en gelabelde uitingen met behulp van de volgende indeling:

{@<entityName>:<roleName>}

U kunt in het onderstaande voorbeeld zien hoe de rollen userName:firstName en userName:lastName impliciet zijn gedefinieerd:

# 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

In patronen kunt u rollen gebruiken met behulp van de {<entityName>:<roleName>} notatie. Hier volgt een voorbeeld:

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

U kunt ook meerdere rollen definiëren voor een entiteit in patronen, zoals hieronder wordt weergegeven:

> 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

Patronen

[Patronen] [] hiermee kunt u een groot aantal voorbeelden behandelen die moeten worden vergeleken door een uiting te maken met tijdelijke houders voor waar entiteiten moeten worden gevonden. De patronen zijn een reguliere expressie op tokenniveau met tijdelijke aanduidingen voor entiteiten. Als een utterance tijdelijke aanduidingen voor entiteiten of patroonsyntaxis heeft, wordt deze geïnterpreteerd als een patroon. Anders wordt deze geïnterpreteerd als een utterance voor het trainen van machine learning.

De tijdelijke houders van de entiteit kunnen overeenkomen met entiteiten van elk type of ze kunnen worden gedefinieerd door het patroon zelf, zoals wanneer een sectie in het patroon een entiteit is die wordt geïdentificeerd door de omringende woorden te bekijken.

Patroonsyntaxis

De .lu-bestandsindeling ondersteunt de LUIS [patroonsyntaxis][]. Patroonsyntaxis is een sjabloon die is ingesloten in een utterance. De sjabloon moet zowel woorden als entiteiten bevatten die u wilt vergelijken, evenals woorden en interpunctie die u wilt negeren. De sjabloon is geen reguliere expressie.

Entiteiten in patronen worden omgeven door accolades, {}. Patronen kunnen entiteiten en entiteiten met rollen bevatten. [Pattern.any] [pattern-any] is een entiteit die alleen wordt gebruikt in patronen.

Function	Syntaxis	Nestniveau	voorbeeld
entity	{} -Accolades	2	`Where is form {entity-name}?`
optioneel	[] - vierkante haken Er is een limiet van 3 voor geneste niveaus van elke combinatie van optionele en groepering	2	`The question mark is optional [?]`
Groeperen	() - haakjes	2	`is (a \\| b)`
or	\| - verticale staaf (pijp) Er is een limiet van 2 op de verticale balken (Of) in één groep	-	`Where is form ({form-name-short} \\| {form-name-long} \\| {form-number})`
begin en/of einde van utterance	^-Caret	-	`^begin the utterance` `the utterance is done^` `^strict literal match of entire utterance with {number} entity^`

Zie het artikel [Pattern syntaxis][] in de LUIS-documentatie voor meer informatie.

In het volgende voorbeeld ziet u een definitie die wordt behandeld als een patroon met een alarmTime entiteit die is gedefinieerd door het patroon:

# DeleteAlarm
- delete the {alarmTime} alarm

De uiting 'verwijder het 7:00-alarm' komt overeen met het patroon en herkent een alarmTime entiteit van '7:00 uur'.

Het volgende voorbeeld is daarentegen een gelabelde utterance waarbij alarmTime een machine learning-entiteit is, omdat deze een gelabelde waarde 7AM heeft:

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

U kunt entiteitslabels en tijdelijke houders van entiteiten niet combineren in dezelfde uiting, maar u kunt tijdelijke houders gebruiken die overeenkomen met door machine geleerde entiteiten.

Fooi

U moet begrijpen hoe uw bot reageert op gebruikersinvoer voordat u patronen toevoegt, omdat patronen zwaarder worden gewogen dan voorbeelduitingen en het vertrouwen scheeftrekken. Er is geen kwaad om ze toe te voegen aan het begin van uw modelontwerp, maar het is gemakkelijker om te zien hoe elk patroon het model wijzigt nadat het model is getest met uitingen.

Woordgroepenlijst

Een [woordgroepenlijst][frasenlijst] is een lijst met woorden of woordgroepen waarmee u het concept kunt vinden dat u wilt identificeren. De lijst is niet hoofdlettergevoelig. Woordgroepenlijsten hebben twee verschillende doeleinden:

De woordenlijst uitbreiden: dit is de standaardinstelling wanneer u een frasenlijst definieert en wordt aangeduid als niet-uitwisselbaar. Woordgroepen met meerdere woorden worden een functie voor machine learning, waarvoor minder voorbeelden nodig zijn om te leren. In dit gebruik is er geen relatie tussen de leden van de faselijst.
Synoniemen definiëren: uitwisselbare woordgroepenlijsten worden gebruikt om synoniemen te definiëren die hetzelfde betekenen. Dit gebruik helpt bij het generaliseren met minder voorbeelden. Elke woordgroep in de lijst resulteert in dezelfde functie als de machine learning. Als u dit wilt gebruiken, moet u opgeven interchangeable in de definitie van de frasenlijst (@ phraselist <Name>(interchangeable))

Notitie

een functie kan een woordgroepenlijst of entiteit zijn die u koppelt aan een intentie of entiteit om het belang van die functie te benadrukken bij het nauwkeurig detecteren van de intentie van de gebruiker. Zie Een woordgroepenlijst toevoegen als functie voor meer informatie.

Zie [Create a phrase list for a concept][phrase-list] (Een woordgroepenlijst voor een concept maken) voor meer informatie over wanneer en hoe u woordgroepenlijsten gebruikt, inclusief typische scenario's waarvoor ze worden gebruikt.

U definieert woordgroepenlijsten met behulp van de volgende notatie:

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

Hier volgt een voorbeeld van een woordgroepenlijst die wordt gebruikt om de woordenlijst uit te breiden:

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

Woordgroepenlijsten kunnen ook worden gebruikt om synoniemen te definiëren door ze als uitwisselbaar te markeren.

@ 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

Woordgroepenlijsten zijn standaard beschikbaar voor alle geleerde intenties en entiteiten. Er zijn drie beschikbaarheidsstatussen:

Beschikbaarheidsstatus	Omschrijving
enabledForAllModels	(standaard) Wanneer een frasenlijst is gemarkeerd als `enabledForAllModels`, is deze beschikbaar voor alle modellen, ongeacht of u deze specifiek als functie vermeldt.
disabledForAllModels	Wanneer een frasenlijst is gemarkeerd als `disabledForAllModels`, wordt deze alleen gebruikt in een model als deze specifiek wordt vermeld als een functie.
disabled	Wanneer een frasenlijst is gemarkeerd als `disabled`, wordt deze nergens gebruikt, inclusief modellen waarin deze specifiek als een functie wordt vermeld. Dit biedt een eenvoudige mogelijkheid om een frasenlijst uit te schakelen om te zien hoe goed dingen werken zonder deze.

Woordgroepenlijsten zijn standaard wereldwijd beschikbaar en kunnen ook specifiek worden ingesteld met behulp van het enabledForAllModels trefwoord:

@ phraselist abc enabledForAllModels

Twee voorbeelden van het instellen van een frasenlijst op disabledForAllModels:

@ phraselist abc disabledForAllModels

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

@ question disabledForAllModels

Wanneer u een frasenlijst disabledinstelt op, wordt deze niet gebruikt, zelfs niet wanneer deze specifiek wordt vermeld als een functie:

> 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

Woordgroepenlijsten kunnen worden gebruikt als functies voor specifieke intenties en entiteiten, zoals beschreven in de volgende sectie.

Functies toevoegen aan intenties en entiteiten

Machine learning werkt door functies te nemen en te leren hoe deze zich verhouden tot de gewenste intentie of entiteit uit voorbeelduitingen. Standaard zijn functies gewoon de woorden waaruit utterances bestaan. Woordgroepenlijsten bieden een middel om meerdere woorden samen te voegen in een nieuwe functie; Hierdoor wordt machine learning beter gegeneraliseerd vanuit minder voorbeelden. Woordgroepenlijsten zijn standaard globaal en zijn van toepassing op alle machine learning-modellen, maar u kunt ze ook koppelen aan specifieke intenties of entiteiten. U kunt intenties of entiteiten ook gebruiken als functies om andere intenties als entiteiten te detecteren. Dit biedt modulariteit, zodat u complexere concepten kunt opbouwen op basis van eenvoudigere bouwstenen.

Notitie

In machine learning is een functie tekst die een onderscheidend kenmerk of kenmerk beschrijft van gegevens waaruit uw systeem merkt en leert. Woordgroepenlijsten, intenties en entiteiten kunnen worden gebruikt als functies, zoals wordt uitgelegd in deze en de volgende secties.

Functies kunnen worden toegevoegd aan elke geleerde intentie of entiteit met behulp van het usesFeature trefwoord.

Een woordgroepenlijst toevoegen als een functie

Woordgroepenlijsten kunnen worden toegevoegd als een functie voor intenties of entiteiten. Dit helpt deze specifieke intenties of entiteiten zonder dat dit van invloed is op andere intenties en entiteiten. Hier volgt een voorbeeld van het definiëren van een frasenlijst als een functie voor een ander model:

> 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

Een entiteit of intentie toevoegen als een functie

Hieronder ziet u voorbeelden van het toevoegen van intenties en entiteiten als een functie met 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

Metagegevens

U kunt metagegevens opnemen die betrekking hebben op uw LUIS-toepassing of QnA Maker-knowledge base in het LU-bestand. Dit helpt de parser om de LU-inhoud correct te verwerken. Metagegevens worden meestal toegevoegd aan het begin van het .lu-bestand.

U kunt als volgt configuratiegegevens definiëren met behulp van > !#:

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

Houd er rekening mee dat alle informatie die expliciet via CLI-argumenten wordt doorgegeven, informatie in het LU-bestand overschrijft.

> 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

Zie de onderstaande tabel voor een beschrijving van de metagegevenswaarden van de toepassing die in het bovenstaande voorbeeld worden gebruikt. Zie [App- en versie-instellingen][luis-metadata] in de LUIS-documentatie voor meer informatie over app.settings in LUIS.

Metagegevens	Beschrijving
Naam	De naam van uw toepassing
VersionId	De naam van die specifieke versie
Cultuur	De taal die wordt gebruikt door uw toepassing
Schemaversie	Het LUIS-schema wordt bijgewerkt wanneer er een nieuwe functie of instelling wordt toegevoegd in LUIS. Gebruik het schemaversienummer dat u hebt gebruikt bij het maken of bijwerken van uw LUIS-model.

Externe verwijzingen

In de onderstaande secties wordt beschreven hoe u lokale bestands- en URI-verwijzingen maakt.

Verwijzingen naar lokale bestanden

Notitie

Azure AI QnA Maker wordt op 31 maart 2025 buiten gebruik gesteld. Vanaf 1 oktober 2022 kunt u geen nieuwe resources of kennisbanken voor QnA Maker maken. Een nieuwere versie van de vraag- en antwoordmogelijkheid is nu beschikbaar als onderdeel van Azure AI Language.

Aangepaste vraagantwoorden, een functie van Azure AI Language, is de bijgewerkte versie van de QnA Maker-service. Zie Natuurlijke taalbegrip voor meer informatie over vraag- en antwoordondersteuning in de Bot Framework SDK.

Verwijst naar het .lu-bestand. Volg de syntaxis van de Markdown-koppeling. Ondersteunde verwijzingen zijn onder andere:

Verwijzing naar een ander .lu-bestand via [link name](<.lu file name>). Verwijzing kan een absoluut pad of een relatief pad zijn van het bestand met .lu.
Verwijzing naar een map met andere .lu-bestanden wordt ondersteund via:
- [link name](<.lu file path>*): zoekt naar .lu-bestanden onder het opgegeven absolute of relatieve pad
- [link name](<.lu file path>**): recursief zoekt naar .lu-bestanden onder het opgegeven absolute of relatieve pad, inclusief submappen.
U kunt ook verwijzingen toevoegen naar uitingen die zijn gedefinieerd in een specifiek bestand onder een intentiesectie of als QnA-paren.
- [link name](<.lu file path>#<INTENT-NAME>): vindt alle utterances onder <INTENT-NAME> in het .lu-bestand en voegt deze toe aan de lijst met utterances waar de verwijzing is opgegeven.
- [link name](<.lu file path>#<INTENT-NAME>*utterances*): vindt alle utterances (geen patronen) onder <INTENT-NAME> in het .lu-bestand en voegt deze toe aan de lijst met utterances waar de verwijzing is opgegeven.
- [link name](<.lu file path>#<INTENT-NAME>*patterns*): vindt alle patronen (geen uitingen) onder <INTENT-NAME> in het .lu-bestand en voegt deze toe aan de lijst met patronen waarin de verwijzing is opgegeven.
- [link name](<.lu file path>#*utterances*): vindt alle utterances in het .lu-bestand en voegt deze toe aan de lijst met utterances waar de verwijzing is opgegeven.
- [link name](<.lu file path>#*patterns*): vindt alle patronen in het .lu-bestand en voegt deze toe aan de lijst met utterances waar de verwijzing is opgegeven.
- [link name](<.lu file path>#*utterancesAndPatterns*): vindt alle utterances en patronen in het .lu-bestand en voegt deze toe aan de lijst met utterances waar de verwijzing is opgegeven.
- [link name](<.qna file path>#$name?): vindt alle wijzigingen van de specifieke wijzigingsdefinitie in de .qna-inhoud en voegt deze toe aan de lijst met utterances waar de verwijzing is opgegeven.
- [link name](<.qna file path>#*alterations*?): vindt alle wijzigingen van de .qna-inhoud en voegt deze toe aan de lijst met utterances waar de verwijzing is opgegeven.
- [link name](<.qna file path>#?question-to-find?): vindt alle variatievragen van de specifieke vraag en voegt deze toe aan de lijst met utterances waar de verwijzing is opgegeven. Houd er rekening mee dat eventuele spaties in uw vraag moeten worden vervangen door het - teken.
- [link name](<.qna file path>#*answers*?): vindt alle antwoorden en voegt deze toe aan de lijst met utterances waar de verwijzing is opgegeven.

Hier volgt een voorbeeld van de bovengenoemde verwijzingen:

> 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-verwijzingen

Hieronder ziet u voorbeelden van het maken van URI-verwijzingen:

> 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*)

Aanvullende informatie

Lees .qna-bestandsindeling voor meer informatie over .qna-bestanden.

Delen via

.lu-bestandsindeling

Intenties definiëren met behulp van voorbeelduitingen

Entiteiten

Entiteitsdefinities

Entiteitstypen

Entiteit op basis van machine learning

Vooraf samengestelde entiteiten

Lijstentiteit

Een entiteit in de vorm van een reguliere expressie

Rollen

Patronen

Patroonsyntaxis

Woordgroepenlijst

Functies toevoegen aan intenties en entiteiten

Een woordgroepenlijst toevoegen als een functie

Een entiteit of intentie toevoegen als een functie

Metagegevens

Externe verwijzingen

Verwijzingen naar lokale bestanden

URI-verwijzingen

Aanvullende informatie

Aanvullende resources