Formato di file .lu

SI APPLICA A: SDK v4

Un file con estensione lu descrive un modello di comprensione del linguaggio. Un file con estensione lu contiene definizioni semplici basate su testo simili a Markdown per i concetti di comprensione del linguaggio. È possibile usare uno o più file con estensione lu per eseguire il training di un modello linguistico per il servizio o il motore NLU (Natural Language Understanding) usato dal bot, ad esempio Language Understanding (LUIS) o Orchestrator. Il motore NLU scelto può essere in grado di interpretare solo il subset degli elementi che un file con estensione lu può descrivere.

Un motore NLU si basa su un modello linguistico per comprendere cosa dice un utente. Il motore crea un modello linguistico da set di esempi di training, proprio come qualsiasi algoritmo di Machine Learning. Una volta eseguito il training, il motore usa il modello per stimare la finalità di un'espressione, in genere sotto forma di una o più finalità che rappresentano un'attività o un'azione che l'utente vuole eseguire e zero o più entità che rappresentano elementi rilevanti per la finalità.

È possibile usare LUIS o Orchestrator con qualsiasi bot sviluppato usando Bot Framework SDK o Composer.

Questo articolo è un riferimento per la rappresentazione degli elementi del modello linguistico nel formato di file con estensione lu. Per informazioni sull'uso della comprensione del linguaggio nei bot, vedere Language Understanding o Elaborazione del linguaggio naturale in Composer.

Definizione delle finalità tramite espressioni di esempio

Una finalità rappresenta un'attività o un'azione che l'utente vuole eseguire, come espresso nell'espressione di un utente. Si aggiungono finalità al bot per consentire di identificare gruppi di domande o comandi che rappresentano la stessa intenzione dell'utente.

Alcuni esempi di finalità che è possibile definire per un bot di viaggio, con le espressioni di esempio da cui sono definite:

Finalità	Espressioni di esempio
BookFlight (PrenotaVolo)	"Prenotami un volo a Maui la prossima settimana" "Volami a Maui il 17° "Ho bisogno di un biglietto aereo il venerdì prossimo a Maui"
Greeting	"Ciao" "Hello" "Buon pomeriggio"
ControlloMeteo	"Qual è il tempo di Maui la prossima settimana?"
None	"Mi piacciono i biscotti" "Bullfrogs sono stati registrati saltando oltre 7 piedi"

Oltre alle finalità definite dall'utente, Nessuna è una finalità di fallback che causa l'attivazione dell'evento unknownIntent quando non è possibile determinare finalità dall'espressione degli utenti. Quando si usa LUIS, la finalità None è una finalità obbligatoria che è necessario creare con espressioni esterne al dominio. Le espressioni associate alla finalità None devono includere circa il 10% delle espressioni totali nel file con estensione lu.

Le finalità con le espressioni di esempio vengono dichiarate nel modo seguente:

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

# <intent-name> descrive una sezione di definizione di una nuova finalità. Ogni riga dopo la definizione della finalità sono espressioni di esempio che descrivono tale finalità usando il - <utterance> formato .

Ecco un file con estensione lu di esempio che illustra queste finalità e espressioni di esempio che acquisiscono i modi in cui gli utenti possono esprimere la finalità:

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

Per altre informazioni sulle finalità e sulle espressioni, vedere Finalità nell'app LUIS e Informazioni sulle espressioni valide per l'app LUIS nella documentazione di LUIS.

Entità

Un'entità fa parte di un'espressione che può essere considerata come un parametro che può essere usato nell'interpretazione di una finalità. Ad esempio, nell'espressione Book a ticket to Maui, Maui è un'entità FlightDestination.

Espressione utente di esempio	Finalità stimata	Entità estratte	Spiegazione
Ciao come stai?	Greeting	-	Nessuna entità da estrarre.
"Prenota un volo a Maui"	BookFlight (PrenotaVolo)	"Maui"	L'entità "FlightDestination" viene estratta come "Maui".
"Qual è il tempo di Maui la prossima settimana?"	ControlloMeteo	"Maui", "prossima settimana"	L'entità "WeatherLocation" viene estratta come "Maui" e l'entità "DateRange" viene estratta come "settimana successiva".
"Voglio ordinare una piccola pizza"	orderPizza	"piccolo"	L'entità "Size" viene estratta come "small".
"Programma una riunione alle ore 13:00 con Bob presso la distribuzione"	ProgrammaRiunione	"1pm", "Bob"	L'entità "MeetingTime" viene estratta come "1pm" e l'entità "Partecipanti" viene estratta come "Bob".

Definizioni di entità

Una definizione di entità definisce come riconoscere un intervallo in un'espressione come entità che è quindi possibile usare nel bot. Esistono molti tipi diversi di entità, tra cui: machine learning, precompilt, elenchi, espressioni regolari e modelli.

Le definizioni di entità nei file con estensione lu iniziano la voce con il segno@ () seguito dal tipo di entità e dal nome dell'entità:

@ <entity-type> <entity-name>

Facoltativamente, ogni entità può anche avere ruoli che identificano usi diversi della stessa entità. È anche possibile aggiungere funzionalità per migliorare il lavoro di riconoscimento delle entità. La sintassi generale è simile alla seguente:

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

Le entità che richiedono una definizione, ad esempio le entità elenco ed espressione regolare, vengono rappresentate usando la notazione seguente:

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

Altri esempi di dichiarazioni di entità verranno illustrati nelle sezioni seguenti insieme ai tipi di entità a cui si applicano.

Ad eccezione delle entità predefinite, i nomi delle entità possono contenere più parole con spazi. Tutti i nomi di entità con spazi devono essere racchiusi tra virgolette:

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

Tipi di entità

Esistono diversi tipi di entità in LUIS. Nelle sezioni seguenti verranno illustrati questi tipi di entità e concetti correlati, ad esempio ruoli e funzionalità, ed esempi di come creare modelli lu lu che li usano.

Entità basata su Machine Learning

Le entità basate su Machine Learning sono entità che consentono di fornire esempi in cui vengono etichettati nelle espressioni di esempio. In questo modo, il contesto necessario per imparare. L'entità basata su Machine Learning è ideale quando si identificano i dati che non sono sempre formattati correttamente ma hanno lo stesso significato.

L'esempio seguente illustra un'entità basata su Machine Learning denominata city (@ ml city) e una bookFlight finalità con espressioni di esempio con le entità etichettate:

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

Quando un utente dice qualcosa di simile a "Ho bisogno di un volo prenotato da Londra a Madrid", LUIS rileverà la finalità "bookFlight" ed estrae sia Londra che Madrid come entità della città.

I ruoli sono essenzialmente un livello aggiuntivo di informazioni contestuali che è possibile aggiungere alle entità apprese dal computer, che imparano anche dal contesto. L'espressione di esempio seguente mostra i ruoli di partenza e destinazione associati all'entità city:

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

Le entità basate su Machine Learning possono anche essere complesse in cui hanno una gerarchia di entità correlate l'una all'altra. Ad esempio, è possibile avere un'entità simile a un'entità pizzaOrder con le entità figlio seguenti: quantità, dimensioni, crosta, condimenti e così via.

Per definire un'entità figlio anteporre un trattino (-) al segno (@) e al rientro, come illustrato nell'esempio seguente:

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

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

Nell'esempio precedente l'entità number è un'entità predefinita. Le entità rimanenti sono tutte entità di elenco.

L'esempio seguente mostra una definizione di un'entità address basata su Machine Learning con fromAddress e toAddress come due ruoli, nonché elementi figlio.

@ 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

Entità predefinite

Le entità LUIS predefinite sono definite dal sistema. Ciò consente di risparmiare lavoro perché sono di alta qualità e forniscono valori normalizzati che sono più facili da usare nei programmi. Ad esempio, la frase "100 e due" diventerà il numero 1002. Sono supportati i tipi LUIS [entità predefinita][prebuilt-entity] seguenti:

• età
• datetimeV2
• dimension
• posta elettronica
• geographyV2
• keyPhrase
• money
• number
• ordinal
• ordinalV2
• percentage
• personName
• phonenumber
• temperatura
• URL.
• data/ora

Ecco alcuni esempi di come definire entità predefinite:

@ prebuilt number 
@ prebuilt datetimeV2
@ prebuilt age

Entità elenco

[Elencare le entità] [list-entity] rappresenta un set fisso e chiuso di parole correlate insieme ai relativi sinonimi. Il valore normalizzato viene restituito quando viene riconosciuto uno dei sinonimi corrispondenti. Fanno distinzione tra maiuscole e minuscole ed estratte in base a una corrispondenza di testo esatta.

L'esempio seguente illustra la sintassi per la definizione di un'entità elenco:

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

Estendendo l'esempio dalla sezione dell'entità pizzaOrder basata su Machine Learning, di seguito è riportato un esempio di elenchi per le entità figlio di dimensioni e crosta:

@ 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

Quando si usano entità di elenco, è consigliabile includere un valore dall'elenco direttamente nell'espressione, non è necessario etichettare le entità elenco anche se è comunque possibile usarle come segnaposto in un criterio. L'esempio seguente mostra un'espressione con valori dell'elenco:

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

Entità di espressione regolare

Un[entità espressione regolare][regular-expression-entity] estrae un'entità in base a un modello di caratteri di espressione regolare specificato. Le espressioni regolari sono ideali per il testo strutturato o una sequenza predefinita di valori alfanumerici previsti in un determinato formato. Ad esempio:

Entità	Espressione regolare	Esempio
Flight Number	volo [A-Z]{2} [0-9]{4}	volo AS 1234
Numero carta di credito	[0-9]{16}	5478789865437632

Ecco un esempio delle definizioni di entità delle espressioni regolari:

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

Ruoli

Un ruolo è un alias denominato per un'entità basata sul contesto all'interno di un'espressione. Un ruolo può essere usato con qualsiasi tipo di entità predefinito o personalizzato e viene usato sia in espressioni di esempio che in modelli.

Nell'esempio seguente l'entità Location ha due ruoli, ovvero origin e destination:

Entità	Ruolo	Scopo
Titolo	origin	Da dove parte l'aereo
Titolo	destination	Dove atterra l'aereo

I ruoli nel formato di file .lu possono essere definiti in modo esplicito o implicito. La definizione di ruolo esplicita è conforme alla notazione seguente:

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

Di seguito sono illustrati i diversi modi in cui è possibile definire in modo esplicito le entità e i relativi ruoli:

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

È anche possibile definire in modo implicito i ruoli direttamente nei modelli e nelle espressioni etichettate usando il formato seguente:

{@<entityName>:<roleName>}

Nell'esempio seguente viene illustrato il modo in cui i ruoli userName:firstName e userName:lastName sono definiti in modo implicito:

# 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

Nei modelli è possibile usare i ruoli usando la {<entityName>:<roleName>} notazione . Ecco un esempio:

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

È anche possibile definire più ruoli per un'entità nei modelli, come illustrato di seguito:

> 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

Criteri

[Modelli] [] consente di coprire un numero elevato di esempi che devono essere confrontati creando un'espressione con segnaposto per dove trovare le entità. I modelli sono un'espressione regolare a livello di token con segnaposto per le entità. Se un'espressione ha segnaposto o sintassi di criteri di entità, viene interpretata come un modello. In caso contrario, viene interpretato come un'espressione per il training di Machine Learning.

I segnaposto dell'entità possono corrispondere a entità di qualsiasi tipo oppure possono essere definiti dal modello stesso, ad esempio quando una sezione nel modello è un'entità identificata esaminando le parole circostanti.

Sintassi dei criteri

Il formato di file con estensione lu supporta luis [sintassi pattern][]. La sintassi del modello è un modello incorporato in un'espressione. Il modello deve contenere sia parole che entità che si desidera associare, nonché parole e punteggiatura da ignorare. Il modello non è un'espressione regolare.

Le entità nei modelli sono racchiuse tra parentesi graffe, {}. I criteri possono includere entità ed entità con ruoli. [Pattern.any] [pattern-any] è un'entità usata solo nei modelli.

Funzione	Sintassi	Livello di nidificazione	Esempio
entità	{} -apparecchio per i denti	2	Where is form {entity-name}?
facoltative	[] - Parentesi quadre È previsto un limite di 3 sui livelli di annidamento di qualsiasi combinazione di raggruppamento e facoltativo	2	The question mark is optional [?]
grouping	() - parentesi	2	is (a \| b)
oppure	| - Barra verticale (pipe) C'è un limite di 2 sulle barre verticali (Or) in un gruppo	-	Where is form ({form-name-short} \| {form-name-long} \| {form-number})
inizio e/o fine dell'espressione	^-Cursore	-	^begin the utterance the utterance is done^ ^strict literal match of entire utterance with {number} entity^

Per altre informazioni, vedere l'articolo [Sintassi dei criteri][] nella documentazione di LUIS.

L'esempio seguente illustra una definizione che verrebbe considerata come un modello con un'entità alarmTime definita dal modello:

# DeleteAlarm
- delete the {alarmTime} alarm

L'espressione "eliminare l'allarme delle 7:00" corrisponde al modello e riconosce alarmTime un'entità di "7am".

L'esempio seguente, invece, è un'espressione etichettata in cui alarmTime è un'entità basata su Machine Learning poiché ha un valore etichettato 7AM:

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

Non è possibile combinare etichette di entità e segnaposto delle entità nella stessa espressione, ma è possibile usare segnaposto che corrispondono alle entità basate su Machine Learning.

Elenco di frasi

[elenco frasi][phrase-list] è un elenco di parole o frasi che consentono di trovare il concetto che si sta tentando di identificare. L'elenco non fa distinzione tra maiuscole e minuscole. Gli elenchi di frasi hanno due scopi diversi:

• Estendere il dizionario: si tratta dell'impostazione predefinita quando si definisce un elenco di frasi ed è noto come non intercambiabile. Le frasi con più parole diventano una funzionalità dell'apprendimento automatico che richiede meno esempi da apprendere. In questo utilizzo non esiste alcuna relazione tra i membri dell'elenco di fasi.
• Definire i sinonimi: gli elenchi di frasi intercambiabili vengono usati per definire sinonimi che significano la stessa cosa. Questo utilizzo consente di generalizzare con un minor numero di esempi. Qualsiasi frase nell'elenco restituisce la stessa funzionalità per l'apprendimento automatico. Per usare questa operazione, è necessario specificare interchangeable nella definizione dell'elenco di frasi (@ phraselist <Name>(interchangeable))

Per altre informazioni su quando e su come usare elenchi di frasi, inclusi gli scenari tipici per cui vengono usati, vedere [Creare un elenco di frasi per un concetto][phrase-list].

Gli elenchi di frasi vengono definiti usando la notazione seguente:

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

Di seguito è riportato un esempio di elenco di frasi usato per estendere il dizionario:

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

Gli elenchi di frasi possono essere usati anche per definire sinonimi contrassegnandoli come intercambiabili.

@ 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

Per impostazione predefinita, gli elenchi di frasi sono disponibili per tutte le finalità e le entità apprese. Esistono tre stati di disponibilità:

Stato di disponibilità	Descrizione
enabledForAllModels	(impostazione predefinita) Quando un elenco di frasi è contrassegnato come enabledForAllModels, è disponibile per tutti i modelli indipendentemente dal fatto che venga elencato in modo specifico come funzionalità.
disabledForAllModels	Quando un elenco di frasi è contrassegnato come disabledForAllModels, viene usato solo in un modello se è elencato in modo specifico come funzionalità.
disabilitato	Quando un elenco di frasi è contrassegnato come disabled, non viene usato da nessuna parte, inclusi i modelli in cui è elencato in modo specifico come funzionalità. In questo modo è possibile disattivare un elenco di frasi per vedere come funzionano bene le cose senza di esso.

Gli elenchi di frasi sono disponibili a livello globale per impostazione predefinita e possono anche essere impostati specificamente usando la enabledForAllModels parola chiave :

@ phraselist abc enabledForAllModels

Due esempi di impostazione di un elenco di frasi su disabledForAllModels:

@ phraselist abc disabledForAllModels

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

@ question disabledForAllModels

Quando si imposta un elenco di frasi su disabled, non verrà usato, anche se specificato come funzionalità:

> 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

Gli elenchi di frasi possono essere usati come funzionalità per finalità ed entità specifiche, come descritto nella sezione successiva.

Aggiunta di funzionalità a finalità ed entità

L'apprendimento automatico funziona prendendo funzionalità e apprendendo come sono correlate alla finalità o all'entità desiderata da espressioni di esempio. Per impostazione predefinita, le funzionalità sono semplicemente le parole che costituiscono espressioni. Gli elenchi di frasi forniscono un mezzo per raggruppare più parole in una nuova funzionalità; in questo modo l'apprendimento automatico viene generalizzato meglio da un minor numero di esempi. Per impostazione predefinita, gli elenchi di frasi sono globali e si applicano a tutti i modelli di Machine Learning, ma è anche possibile collegarli a finalità o entità specifiche. È anche possibile usare finalità o entità come funzionalità per rilevare altre finalità come entità. Ciò garantisce la modularità in modo da poter creare concetti più complessi da blocchi predefiniti più semplici.

Le funzionalità possono essere aggiunte a qualsiasi finalità o entità appresa usando la usesFeature parola chiave .

Aggiungere un elenco di frasi come funzionalità

Gli elenchi di frasi possono essere aggiunti come funzionalità alle finalità o alle entità. Ciò consente di usare finalità o entità specifiche senza influire su altre finalità ed entità. Ecco un esempio relativo alla definizione di un elenco di frasi come funzionalità per un altro modello:

> 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

Aggiungere un'entità o una finalità come funzionalità

Ecco alcuni esempi che illustrano come aggiungere finalità ed entità come funzionalità con 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

Metadati UFX

È possibile includere i metadati correlati all'applicazione LUIS o alla knowledge base di QnA Maker nel file con estensione lu. In questo modo il parser potrà gestire correttamente il contenuto Language Understanding. I metadati vengono in genere aggiunti all'inizio del file con estensione lu.

Ecco come definire le informazioni di configurazione usando > !#:

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

Si noti che tutte le informazioni passate in modo esplicito tramite gli argomenti dell'interfaccia della riga di comando sostituiranno le informazioni presenti nel file .lu.

> 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

Vedere la tabella seguente per una descrizione dei valori dei metadati dell'applicazione usati nell'esempio precedente. Per informazioni su app.settings in LUIS, vedere [Impostazioni app e versione][luis-metadata] nella documentazione di LUIS.

Metadati UFX	Descrizione
Name	Nome dell'applicazione
Versionid	Nome di tale versione specifica
Cultura	Lingua usata dall'applicazione
Versione schema	Lo schema LUIS viene aggiornato ogni volta che viene aggiunta una nuova funzionalità o un'impostazione in LUIS. Usare il numero di versione dello schema usato durante la creazione o l'aggiornamento del modello LUIS.

Riferimenti esterni

Le sezioni seguenti illustrano in dettaglio come creare riferimenti a file e URI locali.

Riferimenti ai file locali

I riferimenti al file .lu Seguire la sintassi del collegamento Markdown. I riferimenti supportati includono:

• Riferimento a un altro file .lu tramite [link name](<.lu file name>). I riferimenti possono essere un percorso assoluto o un percorso relativo rispetto al file .lu che li contiene.
• Il riferimento a una cartella con altri file con estensione lu è supportato tramite:
  • [link name](<.lu file path>*): cerca i file con estensione lu nel percorso assoluto o relativo specificato
  • [link name](<.lu file path>**): cerca in modo ricorsivo i file con estensione lu nel percorso assoluto o relativo specificato, incluse le sottocartelle.
• È anche possibile aggiungere riferimenti a espressioni definite in un file specifico in una sezione intent o come coppie domanda/risposta.
  • [link name](<.lu file path>#<INTENT-NAME>): trova tutte le espressioni in <INTENT-NAME> nel file con estensione lu e le aggiunge all'elenco di espressioni in cui è specificato il riferimento.
  • [link name](<.lu file path>#<INTENT-NAME>*utterances*): trova tutte le espressioni (non pattern) in <INTENT-NAME> nel file con estensione lu e le aggiunge all'elenco di espressioni in cui è specificato il riferimento.
  • [link name](<.lu file path>#<INTENT-NAME>*patterns*): trova tutti i modelli (non le espressioni) in <INTENT-NAME> nel file con estensione lu e li aggiunge all'elenco di modelli in cui è specificato il riferimento.
  • [link name](<.lu file path>#*utterances*): trova tutte le espressioni nel file con estensione lu e le aggiunge all'elenco di espressioni in cui è specificato il riferimento.
  • [link name](<.lu file path>#*patterns*): trova tutti i modelli nel file con estensione lu e li aggiunge all'elenco di espressioni in cui è specificato il riferimento.
  • [link name](<.lu file path>#*utterancesAndPatterns*): trova tutte le espressioni e i modelli nel file con estensione lu e li aggiunge all'elenco di espressioni in cui è specificato il riferimento.
  • [link name](<.qna file path>#$name?): trova tutte le modifiche della definizione di modifica specifica nel contenuto con estensione qna e le aggiunge all'elenco di espressioni in cui è specificato il riferimento.
  • [link name](<.qna file path>#*alterations*?): trova tutte le modifiche dal contenuto con estensione qna e le aggiunge all'elenco di espressioni in cui è specificato il riferimento.
  • [link name](<.qna file path>#?question-to-find?): trova tutte le domande di variazione dalla domanda specifica e le aggiunge all'elenco di espressioni in cui è specificato il riferimento. Si noti che tutti gli spazi presenti nella domanda dovranno essere sostituiti con il carattere -.
  • [link name](<.qna file path>#*answers*?): trova tutte le risposte e le aggiunge all'elenco di espressioni in cui è specificato il riferimento.

Ecco un esempio dei riferimenti menzionati in precedenza:

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

Riferimenti URI

Di seguito sono riportati alcuni esempi di come creare riferimenti URI:

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

Informazioni aggiuntive

• Per ulteriori informazioni sui file .qna, vedere Formato di file .qna.