Kjede med LUIS hensikter

stemmer
4

Så de har denne fint eksempel inne i EchoBot prøve å demonstrere kjeder

 public static readonly IDialog<string> dialog = Chain.PostToChain()
        .Select(msg => msg.Text)
        .Switch(
            new Case<string, IDialog<string>>(text =>
                {
                    var regex = new Regex(^reset);
                    return regex.Match(text).Success;
                }, (context, txt) =>
                {
                    return Chain.From(() => new PromptDialog.PromptConfirm(Are you sure you want to reset the count?,
                    Didn't get that!, 3)).ContinueWith<bool, string>(async (ctx, res) =>
                    {
                        string reply;
                        if (await res)
                        {
                            ctx.UserData.SetValue(count, 0);
                            reply = Reset count.;
                        }
                        else
                        {
                            reply = Did not reset count.;
                        }
                        return Chain.Return(reply);
                    });
                }),
            new RegexCase<IDialog<string>>(new Regex(^help, RegexOptions.IgnoreCase), (context, txt) =>
                {
                    return Chain.Return(I am a simple echo dialog with a counter! Reset my counter by typing \reset\!);
                }),
            new DefaultCase<string, IDialog<string>>((context, txt) =>
                {
                    int count;
                    context.UserData.TryGetValue(count, out count);
                    context.UserData.SetValue(count, ++count);
                    string reply = string.Format({0}: You said {1}, count, txt);
                    return Chain.Return(reply);
                }))
        .Unwrap()
        .PostToUser();
}

Men i stedet for å bruke en REGEX å bestemme min samtale banen jeg vil mye heller bruke en LUIS Intent. Jeg bruker denne fine kodebit å trekke ut LUIS Intent.

public static async Task<LUISQuery> ParseUserInput(string strInput)
    {
        string strRet = string.Empty;
        string strEscaped = Uri.EscapeDataString(strInput);

        using (var client = new HttpClient())
        {
            string uri = Constants.Keys.LUISQueryUrl + strEscaped;
            HttpResponseMessage msg = await client.GetAsync(uri);

            if (msg.IsSuccessStatusCode)
            {
                var jsonResponse = await msg.Content.ReadAsStringAsync();
                var _Data = JsonConvert.DeserializeObject<LUISQuery>(jsonResponse);
                return _Data;
            }
        }
        return null;
    }

Nå dessverre fordi dette er async det ikke spiller godt med LINQ spørringen til å kjøre saken uttalelse. Kan noen gi meg noen kode som vil tillate meg å ha en sak uttalelse inni min kjede basert på LUIS hensikter?

Publisert på 22/06/2016 klokken 16:22
kilden bruker
På andre språk...                            


1 svar

stemmer
0

Omg er rett i hans kommentar.

Husk at IDialogs har en type, mening, IDialog kan returnere et objekt av en type spesifisert av deg selv:

public class TodoItemDialog : IDialog<TodoItem>
{
   // Somewhere, you'll call this to end the dialog
   public async Task FinishAsync(IDialogContext context, IMessageActivity activity)
   {
      var todoItem = _itemRepository.GetItemByTitle(activity.Text);
      context.Done(todoItem);
   }
}

kallet til context.Done () returnerer objekt som din Dialog var ment å gå tilbake. Whever du leser en klasse erklæring for alle typer IDialog

public class TodoItemDialog : LuisDialog<TodoItem>

Det hjelper å lese det som:

"TodoItemDialog er et Dialog klasse som returnerer en TodoItem når den er ferdig"

I stedet for kjeding, kan du bruke context.Forward () som i utgangspunktet videresender samme messageActivity til en annen dialog klasse ..

Forskjellen mellom context.Forward () og context.Call () er essencially at context.Forward () gjør det mulig å videresende en messageActivity som umiddelbart håndtert av dialogen kalles, mens context.Call () bare starter en ny dialog, uten overlevere noe.

Fra "Root" dialog, hvis du trenger å bruke LUIS å bestemme en hensikt og returnere et spesifikt objekt, kan du bare videresende den messageActivity til den ved hjelp av Forward og deretter håndtering resultatet i den angitte tilbakeringing:

await context.Forward(new TodoItemDialog(), AfterTodoItemDialogAsync, messageActivity, CancellationToken.None);

private async Task AfterTodoItemDialogAsync(IDialogContext context, IAwaitable<TodoItem> result)
{
    var receivedTodoItem = await result;

    // Continue conversation
}

Og til slutt, kan din LuisDialog klassen ser omtrent slik ut:

[Serializable, LuisModel("[ModelID]", "[SubscriptionKey]")]
public class TodoItemDialog : LuisDialog<TodoItem>
{
    [LuisIntent("GetTodoItem")]
    public async Task GetTodoItem(IDialogContext context, LuisResult result)
    {
        await context.PostAsync("Working on it, give me a moment...");
        result.TryFindEntity("TodoItemText", out EntityRecommendation entity);
        if(entity.Score > 0.9)
        {
            var todoItem = _todoItemRepository.GetByText(entity.Entity);
            context.Done(todoItem);
        }
    }
}

(For enkelhets skyld har jeg ikke noe annet uttalelser i eksempelet, som er noe du selvsagt må legge til)

Svarte 30/04/2017 kl. 08:24
kilden bruker

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more