>> You're not going to want to miss
this episode of the AI Show where we
look at a new features in language understanding,
being able to mark up stuff, complex hierarchies.
It's pretty cool. Make sure you tune in.
[MUSIC]
>> Hello and welcome to this special build edition of the AI Show.
We're going to talk about some of
the new features in language understanding.
I've got a special guest. Hello, my friend,
tell us who you are and what you do.
>> Hey, I'm Alicia Edelman Pelton,
and I'm a Principal Program Manager in
the Language Understanding Group and Cognitive Services.
>> Fantastic. So what is language understanding?
Let's just start off with that.
>> Sure. LUIS is an AI service that allows developers without
specific AI expertise to
build natural language understanding into their applications,
so you can extract intents and entities from
your text so that
your applications can understand what your user is trying to do,
and then you can process those requests.
>> That's fantastic. I've use LUIS before, it's pretty amazing.
What's new that maybe I don't know about?
>> Well, we've got lots of new stuff coming for
Build and I'm just super excited to share that with you.
We've got new tools and great new features that make it
easier than ever before to build these custom language models.
I'll run through the list here
quickly and then we'll dive into a demo,
and I'll show you some of this in action.
>> Let's do it.
>> We've listened to the feedback from our customers
and we've got an updated portal experience,
and this updated portal makes it easier than
ever before to label utterances,
update your entity schema,
and create features, and so I'll show you this all in the demo.
With this, we've introduced the ability to
add deeper hierarchy to your machine learned entities.
This gives you the capability to
recognize much more complex intents
and entities and to reuse them across your application.
We're so excited for people to use the power of
these new entities that we will even
upgrade them seamlessly for you.
If you have old composite entities in your application,
we'll pop up a notice that will
allow you to upgrade if you choose,
and it's totally risk-free.
So we create a new version of your app and you can test it
to ensure that it's performing well
before you ever deploy it in production.
>> This is really cool. I hate to interrupt,
but this is really cool because, generally,
whenever we upgrade these kinds of things,
it requires some manual process
for you to actually get the new goodness.
How are you able to do this?
>> Well, we actually put a lot of work into this process.
Even all the names that are
used for all of these entities remain the same,
so you don't need to change any of
your downstream code with this upgrade.
>> Well, that is fantastic because usually it's like,
''Oh no, something upgraded,
I need to go fix a thousand things.''
In this case, you don't even need to do that.
>> That's right. We've just made it super easy
for people to use these new capabilities.
>> Awesome.
>> We've got one more new thing
in the Core Language Understanding,
and it's a new app setting called normalized word forms.
By default, LUIS treats root words
differently than their plurals or the roots that have suffixes.
But in some cases,
you want the plurals and suffixes to be
handled the same in your application.
If that is applicable to your application,
you can just turn this new setting on
and they'll all be handled for you automatically.
>> That's cool.
>> In addition to the Core Language Understanding features,
we've got some additional stuff
that we are talking about at Build.
Customers have been asking for Docker container support,
and this is going GA in June.
It enables you to run anywhere and have the flexibility to scale
as much as you need without
any limitations on TPS when you're hosting the container.
Another request we've received is to
do batch testing through the API.
Previously, you could only do this in the portal,
and this will be live in June as well,
and we're making the service even more secure,
so you can encrypt all the data you
use in LUIS using your own key now.
You can either create your own keys and store them in a key vault
or you can use the Azure Key Vault APIs to generate keys.
This is a gated experienced now,
so you need to check the URL on the last slide to
get more details on how to sign up for this.
Finally, we've partnered with the great folks in
the CSE team and we're releasing a DevOps sample project.
This is a template repository that
provides a working project structure and
GitHub action pipelines so that you can
customize it for use in your own project.
>> Well, this is all super made.
Some of these things I've been wanting for a while,
like container support is absolutely amazing to me,
so I'm glad that's in there.
Can you show us how this works?
>> Absolutely. Let me set up the demo for you.
With the whole COVID-19 situation,
we're seeing companies have
an increased need for various types of customer support,
they're getting huge volumes.
So one way to deal with this increased need for
support resources is by using virtual agents and bots.
One key issue right now is the need to
take some leave to care for children or
other loved ones while at school and
other care resources are unavailable or switched up.
We'll take a look at the new language understanding features with
an app that processes requests to take
time off for various reasons.
What I'm showing you here is the bot emulator.
We'll see how this language understanding model
could be used in a bot.
Let's try a couple different requests.
Seth, I heard you wanted to take some vacation?
>> I sure do.
>> I'm going to play manager and say,
''Please approve Seth's vacation request for May 20th.''
Oh, thank goodness, it's been approved.
>> Yes. They might be mad at me
because that's literally the day of Build,
but I'm going to show up because I got approval from you.
>> Check out. That's right.
You're all clear now.
We can see that the leave request was approved,
so that means it is recognizing my intent to approve your request,
and there are a bunch of entities
that could have appeared in that and we're just
printing them out for
debugging sake here so we can show them to you.
But we properly extracted the leave type,
which is a vacation.
We got the action which was to approve and
we got Seth as the requester and your start date.
Let me try one more to show you another intent.
Right now, I need to take off two weeks for
childcare leaves starting May 20th to homeschool my kids.
So my lead request has been submitted.
So the bot properly recognized my intent to submit a leave,
and then it got the duration,
the leave type, the reason,
and the start date.
>> That's a pretty sophisticated sentence too,
you told it in one sentence and it got a lot out of that.
>> Yeah. So let me switch to the LUIS model.
So I can show you how we're doing that and
then new features in the portal.
So I'm looking at the intent page right now,
and you can see that I have
a few intents designed for this application,
and we actually looked at two;
we looked at this Manager Approval Action and the Leave Action.
You can see, there's something in common here,
the leave phrase entity,
and this is the leave phrase entity
had all those save entities that I could
recognize for when I
was making that request or I was making an approval.
So this leave phrase is reused as
a machine learning feature for both of those intents.
So this is a new capability,
you can add entities as features to other intents and entities,
and this can really improve the accuracy of your model.
So when I detect a leave phrase,
it's a really good signal to the model that I'm either in
this Manager Approval Action or the Leave Action.
So let me open up the Leave Action so I
can show you a few more new things in the portal.
So I'm going to click on this "@" sign and open
up this new Custom entities panel.
This is great because I can see all of these deep, hierarchical,
machine learn entities that I have defined for this application,
as well as the list entities that I've defined.
I can see them all while I'm adding utterances and labeling them,
and I can edit and take actions
right here without leaving my flow.
This is also switched from top down,
we used to do bottom-up construction of your schema,
and we find that top-down is
a much more natural way to think about your schema,
easier to edit too.
So maybe I'm looking at leave inquiries and I'm labeling them,
and I see that managers are being expressed in that phrase.
I can just add it right here as a new sub entity,
and then it's immediately available to label new utterances.
Maybe I'm debugging too,
and I see that leave
type isn't getting properly recognized for some reason.
I can look at the link to machine learning feature,
so where you see these little links here,
these all have features attached to those entities.
In this case, this is a phrase list,
that is the feature for this leave-type entity.
So I can open it up,
and maybe people are using the word sick time instead.
So I can add that right here on the fly, click "Save",
and update this feature while I'm in this labeling interaction.
Let me point out one other new thing here in this entity panel,
you see these little asterisks.
So this shows that
these two entities have what we call required features.
So this is new too,
so LUIS used to use something called constraints,
if you wanted some criteria to be met in
order for an entity to be predicted.
So now, you can require a certain feature,
and you can see that I have
this leave submissions modification list entity,
that needs to fire in order for us to ever predict this entity,
because I want to be really sure if somebody is canceling
or updating an existing leave submission.
>> This is all really cool. I'm sorry to interrupt.
One of the things that I'm enjoying about this the most,
is it allows you to think in more of a natural conversational way,
and then use the same patterns in
other recognition actions by yourself.
So I know there's intents and then there's
intents entities. Entities an intents.
>> Yeah.
>> Those are the two. So I love the way that
it's composing these altogether.
>> So let's talk a little bit more about that.
So this leave phrase is a pretty deep entity.
I've got all of these sub entities here.
It might seem strange,
I'm using this single Leave Action intent,
actually to recognize three distinct user actions,
and that's to create a new leave request,
to edit one or to delete one.
But the thing is that a lot of the things that people would say or
type in a request to cancel or update a leave,
are the same, so the same entities can be reused.
Then I can use this other save entities,
this leave submission modifier entity to
capture the actual action that the user wants to take,
and then I can reuse this deep entities,
deep hierarchical entity, for those three different actions.
This allows me to do much more complicated things like
recognizing multiple actions even in a single utterance.
We can now go up to five levels deep to
capture very complex entity structures.
So let me put in a couple of
new utterances so I can show you a few more new features.
>> I love the way it's underlining things too, that's really cool.
>> So let's talk about the difference
about the underlines and what you're going to see here.
So I just added a new utterance to my application,
and you see these dotted lines around it.
So it used to be in the old portal,
it was really difficult to visually distinguish between
a prediction that the model is making
based on where it's current state is,
and actual labels that you've submitted.
So these underlies are
actual labels that I have submitted and trained my model with.
But when I add a new utterance,
I can see how the current model is predicting.
In this one, this is great,
my current model it's not perfect,
it's in progress, but for this particular utterance,
it's getting all of these entities correct.
So if it gets everything correct,
I can confirm all of the entity predictions,
and turn those into labels in one click.
So that makes it really easy.
Now, we also have
some new view options that we've
added to allow you to customize this view.
You can turn those entity prediction's off.
I'm actually going to do that so I can
simulate what it's like when you don't have
the model getting those predictions really well for you.
So if you're just starting,
the model won't know where to predict entities yet,
and so you would not see those predictions.
So I'm going to show you two different ways to label,
and both of these have been improved for the build release.
So first of all,
you can use this custom entity palette.
I can click on the entity label,
it looks like a little highlighter,
and then I can click on the entity that I want to label,
and then just highlight this.
Now, I can start with a leave node,
I can start with a parent node, It doesn't matter.
You can see that I started with
duration and it's one of the child nodes,
and it automatically labels it with leave phrase,
because it knows it needs to be inside a leave phrase.
So if I go ahead and do the whole leave phrase,
you can see then that that label gets adjusted,
and then I can select leave
type and grab that thing as well, and then I'm all done.
Now, we do know that people like to label in the line as well,
so we have upgraded that experience as well.
So I turned off the little entity highlighter,
and again, doesn't matter,
even if you start with a leave node,
and use these cascading menus to label inline.
The same behavior applies,
you can see that the parent entities adjust as you label as well,
because we're smart enough to understand the structure.
Let me grab that right one here, leave submission.
So yeah, that's what we have
for all the new features in the portal.
>> This is really cool.
Even like down, and this I know it's a subtle,
but down to the actual text that you're editing,
looks like typewriter texts.
That subtle thing is actually really cool too,
and we're able to see it all, it's really awesome.
>> Yeah, it's really exciting because we're bringing
together a lot of the feedback that we've got from customers,
and we're super excited to
have people try it out and tell us how they like it.
>> Where can people go to find out more?
>> Well, here you go.
So you can check out
the what's new in Language Understanding in the documentation,
if you're new to LUIS and you don't quite know what this all is,
you can go to what is LUIS,
and get introduced completely to the service.
We have a whole set of upgraded best practices as well.
If you're really interested in those customer managed keys,
go to this URL and sign up for that experience.
We'd love to have you in our community as well.
>> That's awesome. Well, this all been pretty impressive.
Thank you so much for spending some time with us.
I'm sure you're very excited about what customers are going to do.
>> We're really excited to see what people will
do with all this new functionality.
It was great talking with you.
>> Thank you so much, we've been watching all about
the new features in Language Understanding.
Thank you so much for watching,
and we'll see you next time. Take care.
[MUSIC]