Formato de arquivo .lu

APLICA-SE A: SDK v4

Um arquivo .lu descreve um modelo de reconhecimento de linguagem. Um arquivo .lu contém definições baseadas em texto simples e semelhantes ao Markdown para reconhecimento de linguagem. Você pode usar um ou mais arquivos .lu para treinar um modelo de linguagem para o serviço ou mecanismo de reconhecimento de linguagem natural (NLU) que seu bot usa, como reconhecimento de linguagem (LUIS) ou Orchestrator. O mecanismo NLU escolhido pode ser capaz de interpretar apenas o subconjunto dos elementos que um arquivo .lu pode descrever.

Um mecanismo NLU depende de um modelo de linguagem para entender o que um usuário diz. O mecanismo cria um modelo de linguagem a partir de conjuntos de exemplos de treinamento, assim como qualquer algoritmo de aprendizado de máquina. Uma vez treinado, o mecanismo usa o modelo para prever a intenção de um enunciado, geralmente na forma de uma ou mais intenções que representam uma tarefa ou ação que o usuário deseja executar e zero ou mais entidades que representam elementos relevantes para a intenção.

Você pode usar o LUIS ou o Orchestrator com qualquer bot desenvolvido usando o SDK do Bot Framework ou o Composer.

Este artigo é uma referência sobre como representar elementos de modelo de linguagem no formato de arquivo .lu. Para obter informações sobre como o reconhecimento de linguagem é usada em bots, confira Reconhecimento de linguagem ou Processamento de linguagem natural no Composer.

Como definir intenções usando enunciados de amostra

Uma intenção representa uma tarefa ou ação que o usuário deseja realizar, conforme expresso no enunciado. Você adiciona intenções ao bot para permitir que ele identifique grupos de perguntas ou comandos que representam a mesma intenção do usuário.

Alguns exemplos de intenções que você pode definir para um bot de viagem, com os exemplos de enunciado a partir dos quais elas são definidas:

Intencional	Exemplo de enunciados
BookFlight	"Reserve um voo para Maui na semana que vem" "Encontre um voo para Maui no dia 17" "Preciso de uma passagem de avião na próxima sexta-feira para Maui"
Saudação	"Oi" "Olá" “Boa tarde”
CheckWeather	"Como estará o tempo em Maui na próxima semana?"
Nenhum	"Gosto de biscoitos" "Há registro de rãs-touro saltando mais de 7 metros"

Além das intenções que você define, a opção Nenhuma é uma intenção de fallback que faz com que o evento unknownIntent seja acionado quando não é possível determinar nenhuma intenção a partir do enunciado dos usuários. Ao usar o LUIS, a opção Nenhuma é uma intenção obrigatória que precisa ser criada com enunciados que estão fora do seu domínio. Os enunciados associados à intenção Nenhuma devem compreender aproximadamente 10% do total dos enunciados em seu arquivo .lu.

As intenções, com seus exemplos de enunciados, são declaradas da seguinte maneira:

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

# <intent-name> descreve uma nova seção de definição de intenção. Cada linha após a definição da intenção são exemplos de enunciados que descrevem essa intenção usando o formato - <utterance>.

Aqui está um exemplo de arquivo .lu demonstrando essas intenções e um exemplo de enunciados que capturam maneiras pelas quais os usuários podem expressar a intenção:

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

Para obter mais informações sobre intenções e enunciados, confira Intenções em seu aplicativo LUIS e Entenda o que são bons enunciados para seu aplicativo LUIS na documentação do LUIS.

Entities

Uma entidade é parte de um enunciado que pode ser pensado como um parâmetro a ser usado na interpretação de uma intenção. Por exemplo, no enunciado Reserve uma passagem para Maui, Maui é uma entidade FlightDestination.

Exemplo de enunciado do usuário	Intenção prevista	Entidades extraídas	Explicação
Olá, tudo bem?	Saudação	-	Nenhuma entidade para extrair.
"Reserve um voo para Maui"	BookFlight	"Maui"	A entidade "FlightDestination" é extraída como "Maui".
"Como estará o tempo em Maui na próxima semana?"	CheckWeather	"Maui", "na próxima semana"	A entidade "WeatherLocation" é extraída como "Maui" e a entidade "DateRange" é extraída como "na próxima semana".
“Quero pedir uma pizza pequena”	orderPizza	"pequena"	A entidade "tamanho" é extraída como "pequena".
"Agendar uma reunião às 13h com Bob na distribuição"	ScheduleMeeting	“13h”, “Bob”	A entidade "MeetingTime" é extraída como "13h" e a entidade "Attendees" é extraída como "Bob".

Definições de entidade

Uma definição de entidade define como reconhecer uma extensão em um enunciado como uma entidade que você pode usar em seu bot. Existem muitos tipos diferentes de entidades, incluindo: aprendizado de máquina, pré-construído, listas, expressões regulares e padrões.

As definições de entidade em arquivos .lu iniciam a entrada com o sinal de arroba (@) seguido pelo tipo de entidade e nome da entidade:

@ <entity-type> <entity-name>

Opcionalmente, cada entidade também pode ter funções que identificam diferentes usos da mesma entidade. Você também pode adicionar recursos para ajudar a fazer um trabalho melhor de reconhecimento de entidades. A sintaxe geral é semelhante a:

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

As entidades que exigem uma definição, como uma lista e as entidades de expressões regulares, são representadas por meio da seguinte notação:

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

Exemplos adicionais de declarações de entidade serão demonstrados nas seções a seguir, juntamente com os tipos de entidade aos quais se aplicam.

Com exceção de entidades pré-criadas, os nomes das entidades podem conter várias palavras com espaços. Os nomes de entidades com espaço podem ser colocados entre aspas:

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

Tipos de entidade

Há vários tipos de entidades no LUIS. Nas seções a seguir, você aprenderá sobre esses tipos de entidade e conceitos relacionados, como funções e recursos, e exemplos de como criar modelos de LU que os usam.

Entidade com aprendizado de máquina

Entidades de aprendizado de máquina são entidades que permitem fornecer exemplos de onde as rotular nos exemplos de enunciado. Isso lhes dá o contexto necessário para aprender. A entidade de aprendizado de máquina é ideal para identificar dados que nem sempre estão bem formatados, mas têm o mesmo significado.

O exemplo a seguir demonstra uma entidade de aprendizado de máquina chamada cidade (@ ml city) e uma intenção bookFlight com exemplos de enunciado com suas entidades rotuladas:

> 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 um usuário disser algo semelhante a "Preciso de uma reserva de voo de Londres para Madri", o LUIS detectará a intenção 'bookFlight' e extrairá Londres e Madri como entidades cidades.

As funções são essencialmente uma camada adicional de informações contextuais que você pode adicionar às suas entidades aprendidas por máquina, que também aprendem com o contexto. O exemplo a seguir de enunciado mostra as funções de partida e destino associadas à entidade cidade:

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

As entidades de aprendizado de máquina também podem ser complexas quando têm uma hierarquia de entidades relacionadas entre si. Por exemplo, você pode ter algo como uma entidade pizzaOrder com as seguintes entidades filhas: quantidade, tamanho, crosta, coberturas e assim por diante.

Você define uma entidade filha acrescentando um traço (-) ao sinal de arroba (@) e um recuo, como demonstra o seguinte exemplo:

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

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

No exemplo acima, a entidade número é uma entidade pré-criada. As entidades restantes são todas entidades de lista.

O próximo exemplo mostra uma definição de uma entidade aprendida por máquina address, com fromAddress e toAddress como duas funções, bem como filhas.

@ 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

Entidades predefinidas

As entidades LUIS pré-criadas são definidas pelo sistema. Isso economiza seu trabalho, pois elas são de alta qualidade e fornecem valores normalizados que são mais fáceis de usar em programas. Por exemplo, a frase "mil e dois" passaria a ser o número 1002. Há suporte para os seguintes tipos de [entidade pré-construída] e [entidade pré-construída] LUIS:

• age
• datetimeV2
• dimensão
• Email
• geographyV2
• keyPhrase
• money
• number
• ordinal
• ordinalV2
• percentage
• personName
• phonenumber
• temperatura
• url
• datetime

Veja alguns exemplos de como obter entidades predefinidas:

@ prebuilt number 
@ prebuilt datetimeV2
@ prebuilt age

Entidade de lista

[Entidades de lista],[entidade-lista] representam um conjunto fixo e fechado de palavras relacionadas, juntamente com seus sinônimos. O valor normalizado é retornado quando qualquer um dos sinônimos correspondentes é reconhecido. Elas diferenciam maiúsculas de minúsculas e são extraídas com base em uma correspondência de texto exata.

O exemplo a seguir mostra a sintaxe para definir uma entidade de lista:

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

Estendendo o exemplo pizzaOrder da seção de entidade de aprendizado de máquina, veja um exemplo de listas para as entidades filhas de tamanho 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

Ao usar entidades de lista, você deve incluir um valor da lista diretamente no enunciado, não é necessário rotular entidades de lista, embora ainda possa usá-las como espaços reservados em um padrão. O exemplo a seguir mostra um enunciado com valores da lista:

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

Entidade de expressão regular

Uma [entidade de expressão-regular], [entidade de expressão regular] extrai uma entidade com base em um padrão de caractere de expressão regular fornecido por você. As entidades de expressão regular são melhores para um texto estruturado ou uma sequência predefinida de valores alfanuméricos esperados em determinado formato. Por exemplo:

Entidade	Expressão regular	Exemplo
Número do Voo	voo [A-Z]{2} [0-9]{4}	voo AS 1234
Número do Cartão de Crédito	[0-9]{16}	5478789865437632

Este é um exemplo de definições de entidades de expressão expressão regular:

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

Funções

Uma função é um alias nomeado para uma entidade com base no contexto dentro de um enunciado. Uma função pode ser usada com qualquer tipo de entidade predefinida ou personalizada e em exemplos de padrões e enunciados.

No exemplo abaixo, a entidade Localização tem duas funções, origin e destination:

Entidade	Função	Finalidade
Location	origin	De onde parte o avião
Location	destino	Onde o avião pousa

As funções no formato de arquivo .lu podem ser definidas explícita ou implicitamente. A definição de função explícita segue a notação:

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

Abaixo, são mostradas as diversas maneiras pelas quais você pode definir explicitamente as entidades e as respectivas funções:

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

Você também pode definir funções de maneira implícita diretamente em padrões e enunciados rotulados com o seguinte formato:

{@<entityName>:<roleName>}

Veja no exemplo abaixo como as funções userName:firstName e userName:lastName são definidas implicitamente:

# 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

Em padrões, você pode usar funções com a notação {<entityName>:<roleName>}. Aqui está um exemplo:

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

Você também pode definir várias funções para uma entidade em padrões. Veja abaixo:

> 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

Padrões

[Padrões] [] permitem que você cubra um número grande de exemplos que devem ser correspondidos criando um enunciado com espaços reservados para onde as entidades devem ser encontradas. Os padrões são uma expressão regular de nível de token com espaços reservados para entidades. Se um enunciado tiver qualquer entidade, espaços reservados ou sintaxe de padrão, ele será interpretado como um padrão. Caso contrário, será interpretada como um enunciado para treinar o aprendizado de máquina.

Os espaços reservados para entidades podem corresponder a entidades de qualquer tipo ou podem ser definidos pelo próprio padrão, como quando uma seção no padrão é uma entidade identificada observando as palavras ao redor.

Sintaxe de padrões

O formato de arquivo .lu oferece suporte à [sintaxe de padrão][] do LUIS. A sintaxe de padrão é um modelo inserido em um enunciado. O modelo deverá conter palavras e entidades com as quais deseja fazer a correspondência, bem como palavras e sinais de pontuação que deseja ignorar. O modelo não é uma expressão regular.

As entidades nos padrões são colocadas entre chaves, {}. Os padrões podem incluir entidades e entidades com funções. [Pattern.any][pattern-any] é uma entidade usada apenas em padrões.

Função	Sintaxe	Nível de aninhamento	Exemplo
entidade	{} - chaves	2	Where is form {entity-name}?
opcionais	[] - colchetes Há um limite de 3 nos níveis de aninhamento de qualquer combinação de opcional e agrupamento	2	The question mark is optional [?]
agrupamento	(): parênteses	2	is (a \| b)
or	| - barra vertical (pipe) Há um limite 2 nas barras verticais (ou) em um grupo	-	Where is form ({form-name-short} \| {form-name-long} \| {form-number})
início e/ou fim de enunciado	^: circunflexo	-	^begin the utterance the utterance is done^ ^strict literal match of entire utterance with {number} entity^

Confira o artigo [Sintaxe de padrão][] na documentação do LUIS para obter mais informações.

O exemplo a seguir mostra uma definição que seria tratada como um padrão com uma entidade alarmTime definida pelo padrão:

# DeleteAlarm
- delete the {alarmTime} alarm

O enunciado "apague o alarme das 7h" corresponderia ao padrão e reconheceria uma entidade alarmTime das "7h".

Por outro lado, o exemplo a seguir é um enunciado rotulado, em quealarmTime é uma entidade aprendida por máquina, pois tem um valor rotulado de 7h:

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

Não é possível misturar rótulos de entidade e espaços reservados de entidade no mesmo enunciado, mas você pode usar espaços reservados que correspondam a entidades aprendidas por máquina.

Lista de frases

Uma [lista de frases][lista-frases] é uma lista de palavras ou frases que ajudam a encontrar o conceito que você está tentando identificar. A lista não diferencia maiúsculas de minúsculas. As listas de frases têm duas finalidades diferentes:

• Estender o dicionário: esse é o padrão quando você define uma lista de frases e é conhecido como não intercambiável. Frases com várias palavras se tornam um recurso para o aprendizado de máquina, que requer menos exemplos para aprender. Nesse uso, não há relação entre os elementos da lista de fases.
• Definir sinônimos: listas de frases intercambiáveis são usadas para definir sinônimos que significam a mesma coisa. Esse uso ajuda a generalizar com menos exemplos. Qualquer frase na lista resulta no mesmo recurso para o aprendizado de máquina. Para usá-la, é necessário especificar interchangeable na definição da lista de frases (@ phraselist <Name>(interchangeable))

Para obter informações adicionais sobre quando e como usar listas de frases, incluindo cenários típicos para os quais são usadas, confira [Criar uma lista de frases para um conceito][lista de frases].

Você define as listas de frases usando a seguinte notação:

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

Veja um exemplo de lista de frases usada para estender o dicionário:

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

As listas de frases também podem ser usadas para definir Sinônimos marcando-os como intercambiáveis.

@ 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

Por padrão, as listas de frases estão disponíveis para todas as intenções e entidades aprendidas. Há três estados de disponibilidade:

Estado de disponibilidade	Descrição
enabledForAllModels	(padrão) Quando uma lista de frases é marcada como enabledForAllModels, ela está disponível para todos os modelos, independentemente de você listá-la especificamente como um recurso ou não.
disabledForAllModels	Quando uma lista de frases é marcada como disabledForAllModels, ela só é usada em um modelo se estiver especificamente listada como um recurso.
desabilitado	Quando uma lista de frases é marcada como disabled, ela não é usada em nenhum lugar, incluindo nenhum modelo em que esteja especificamente listada como um recurso. Isso fornece um meio fácil de desativar uma lista de frases para ver como as coisas funcionam bem sem ela.

As listas de frases estão disponíveis globalmente por padrão e também podem ser definidas especificamente usando a palavra-chave enabledForAllModels:

@ phraselist abc enabledForAllModels

Dois exemplos de definição de uma lista de frases como disabledForAllModels:

@ phraselist abc disabledForAllModels

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

@ question disabledForAllModels

Ao definir uma lista de frases como disabled, ela não será usada, mesmo quando especificamente listada como um recurso:

> 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

As listas de frases podem ser usadas como recursos para intenções e entidades específicas, como descrito na próxima seção.

Adicionando recursos a intenções e entidades

O aprendizado de máquina funciona considerando recursos e aprendendo como eles se relacionam com a intenção ou entidade desejada a partir de exemplos de enunciado. Por padrão, recursos são simplesmente as palavras que compõem os enunciados. As listas de frases fornecem um meio de agrupar várias palavras em um novo recurso. Isso faz com que o aprendizado de máquina generalize melhor a partir de menos exemplos. Por padrão, as listas de frases são globais e se aplicam a todos os modelos aprendidos por máquina, mas você também pode vinculá-las a intenções ou entidades específicas. Você também pode usar intenções ou entidades como recursos para detectar outras intenções como entidades. Isso fornece modularidade para que você possa criar conceitos mais complexos a partir de blocos de construção mais simples.

Os recursos podem ser adicionados a qualquer intenção ou entidade aprendida usando a palavra-chave usesFeature.

Adicionar uma lista de frases como recurso

As listas de frases podem ser adicionadas como um recurso a intenções ou entidades. Isso ajuda essas intenções ou entidades específicas sem afetar outras intenções e entidades. Este é um exemplo de como definir uma lista de frases como um recurso para outro modelo:

> 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

Adicionar uma entidade ou uma intenção como um recurso

Veja abaixo exemplos de como adicionar intenções e entidades como um recurso com 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

Metadados

Você pode incluir metadados relacionados ao aplicativo LUIS ou à base de informações do QnA Maker no arquivo .lu. Isso ajudará a orientar o analisador a processar o conteúdo do LU corretamente. Normalmente, os metadados são adicionados ao início do arquivo .lu.

Veja como definir as informações de configuração usando > !#:

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

Observe que todas as informações passadas explicitamente por meio de argumentos da CLI substituirão as informações do arquivo .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

Confira a tabela abaixo para obter uma descrição dos valores de metadados do aplicativo, usados no exemplo acima. Para obter informações sobreas configurações de aplicativo no LUIS, confira [Configurações de aplicativo e versão][luis-metadata] na documentação do LUIS.

Metadados	Descrição
Nome	O nome do aplicativo
VersionId	O nome dessa versão específica
Cultura	A linguagem usada pelo seu aplicativo
Versão do esquema	O esquema LUIS é atualizado sempre que um novo recurso ou configuração é adicionada ao LUIS. Use o número de versão do esquema que utilizou ao criar ou atualizar seu modelo LUIS.

Referências externas

As seções abaixo detalham como fazer referências a um arquivo local e à URI.

Referências a arquivo local

Referencia o arquivo .lu. Siga a sintaxe de link Markdown. As referências com suporte incluem:

• Referência a outro arquivo .lu por meio de [link name](<.lu file name>). A referência pode ser um caminho absoluto ou um caminho relativo do arquivo .lu contido.
• Há suporte para a referência a uma pasta com outros arquivos .lu por meio do seguinte:
  • [link name](<.lu file path>*) procura os arquivos .lu no caminho relativo ou absoluto especificado
  • [link name](<.lu file path>**) procura recursivamente os arquivos .lu no caminho relativo ou absoluto especificado, incluindo as subpastas.
• Adicione também referências aos enunciados definidos em um arquivo específico em uma seção de intenção ou como pares de QnA.
  • [link name](<.lu file path>#<INTENT-NAME>): localiza todos os enunciados em <NOME-DA-INTENÇÃO> no arquivo .lu e os adiciona à lista de enunciados em que a referência é especificada.
  • [link name](<.lu file path>#<INTENT-NAME>*utterances*): localiza todos os enunciados (não padrões) em <NOME-DA-INTENÇÃO> no arquivo .lu e os adiciona à lista de enunciados em que a referência é especificada.
  • [link name](<.lu file path>#<INTENT-NAME>*patterns*): localiza todos os padrões (não enunciados) em <NOME-DA-INTENÇÃO> no arquivo .lu e os adiciona à lista de padrões em que a referência é especificada.
  • [link name](<.lu file path>#*utterances*): localiza todos os enunciados no arquivo .lu e os adiciona à lista de enunciados em que a referência é especificada.
  • [link name](<.lu file path>#*patterns*): localiza todos os padrões no arquivo .lu e os adiciona à lista de enunciados em que a referência é especificada.
  • [link name](<.lu file path>#*utterancesAndPatterns*): localiza todos os enunciados e padrões no arquivo .lu e os adiciona à lista de enunciados em que a referência é especificada.
  • [link name](<.qna file path>#$name?): localiza todas as alterações da definição de alteração específica no conteúdo do .qna e as adiciona à lista de enunciados em que a referência é especificada.
  • [link name](<.qna file path>#*alterations*?): localiza todas as alterações do conteúdo do .qna e as adiciona à lista de enunciados em que a referência é especificada.
  • [link name](<.qna file path>#?question-to-find?): localiza todas as perguntas da variação de pergunta específica e as adiciona à lista de enunciados em que a referência é especificada. Observe que qualquer espaço na pergunta precisará ser substituído pelo caractere -.
  • [link name](<.qna file path>#*answers*?): localiza todas as respostas e as adiciona à lista de enunciados em que a referência é especificada.

Este é um exemplo das referências mencionadas anteriormente:

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

Referências à URI

Veja abaixo exemplos de como fazer referências à 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*)

Informações adicionais

• Leia Formato de arquivo .qna para saber mais sobre os arquivos .qna.