[OPENING MUSIC]
NISARG KADAM: My name is Nisarg, and I am
a member of UiPath Community.
I have built an automation to help predict diabetes,
using AI Center and Apps.
I have created this workflow because, as you see--
as you look at this number, the total
the number of people with diabetes
will rise from 11 million in 2000, to almost 20 million
by 2025.
So, if the number is definitely going to rise a lot,
we definitely need a strong mechanism and strong set
of algorithms to predict, based on the medical reports.
Because this is going to be the need of the future.
Everything is being digitalized, so why not this?
So let us look at how is it exactly going to work?
So I have already created a bot, or an application,
a UiPath app, which helps me to predict the diabetes.
Now, if I simply say, run, from here.
Look at this, how it works, you wouldn't believe this.
Very, very, very easy to use, and a very nice one
to have a background in.
So you have to enter the glucose value, here.
So there are six things, 1, 2, 3, 4, 5, 6, 7 input fields
that are required.
The first is a glucose value, second
is a blood pressure amount, skin thickness, insulin value, BMI,
diabetic pedigree function, and age.
So based on all of these seven parameters,
it is going to predict diabetes, and, also,
it is going to give us the accuracy of the machine
learning extraction, which is a confidence of the machine
learning extraction.
So you can also decide whether you want to make it accurate
or not, you want to believe it or not.
OK, so there are seven fields here.
The first one is glucose.
I have a couple of data--
I'm definitely not going to open anybody's [INAUDIBLE] report.
So I have some sample data here.
And the outcome of this sample data is already decided,
correct?
So now we are going to check whether our bot is correct
or not.
So bot's answer-- bot's prediction,
we are going to write it here.
So it's a bot prediction.
OK.
Let's check whether our bot is correct.
So I have first person whose glucose value is 148.
Blood pressure is 72.
I don't know what is the parameter that
is measured with.
But that is the standard parameter, I believe.
Insulin is zero, let's say.
BMI, 33.6.
Diabetes pedigree function is 0.627 and age is 50.
So according to the report, this person
has diabetes, based on this data set.
OK.
Now let's try to check whether our bot predicts it
accurately or not.
So I'm going to click on this Predict button, and that's it.
Now look at this you Ui robot, here.
It is going to run a robot, and this Ui robot
is going to run the bot behind the scene and try to predict,
based on the dataset which we have entered,
whether the person has diabetes or not.
So you'll get the answer here.
So let's say-- what is the answer before I show you
the answer.
So the person has diabetes.
OK?
And we need to know the bot's prediction.
As you can see, here, bot has predicted it is diabetic,
that means this person has diabetes.
And the prediction accuracy is 0.8065,
that is 80.65%, which is great.
So we just predicted whether a person
has diabetes based on the [INAUDIBLE]
report of a person, which was made for diabetes patients.
Now this is how you can leverage the integration
level of machine learning, [? at ?] low coding App
feature, and of workflow creation.
Now this is how great it is for accuracy.
As far as we see, this is correct.
So let's navigate to the next one.
So let's see this data, which has 85% of--
so 80 glucose.
Blood pressure value is 66, skin thickness is 29,
insulin is zero.
It'd be like that.
So 26.6 is the BMI value.
Diabetes pedigree function is 0.351, and age of this person
is 31.
So based on all these parameters,
we are going to predict whether this person has diabetes
or not.
And guess what?
This person doesn't have diabetes in actuality,
so this is a real outcome.
And we are going to check whether bot predicts correctly,
or not.
I'm going to click on Predict, and let's wait for the bot.
Now you can see that the bot has already started execution.
Our bot is running, right now, in background.
And you can see the result in some time,
so it is taking some time to process.
It is using the TPOTAutoMLClassification model,
and we will wait for the response.
So this is still the older response,
which is diabetic and 0.806578.
We will wait for the correct response right now.
It is taking its own sweet time.
Do I hit Refresh, or something?
OK.
Let's find Refresh here.
Let's try to run the same bot again.
OK, so let's try to enter the second values again.
It missed the data here.
OK, so the values were 85 for glucose, for blood pressure
it was 66, for skin thickness it was 29,
for insulin it was zero BMI value was 26.6,
diabetes pedigree function is 0.351, and age is 31,
and let's predict.
So now, if our bot predicts correctly--
I mean if our bot gives you that this patient doesn't
have diabetes and the accuracy is more than--
let's say at least 70%--
then we can believe on this report, correct?
So that means our bot is predicting correctly.
Non-diabetic, and that is also with 0.91,
that is 91% of accuracy.
So this bot predicted with almost 80% of accuracy.
Bot predicted this one with 90% accuracy.
I'm going to write it, 90%, here.
Let's say, write it, roughly, 80% here.
And this is also correct, bot predicted it very correctly.
Correct?
Now let's look at this data.
So I'm going to refresh this one again, and let's see how--
so how are we going to predict?
If our report is 100% accurate, then this
is going to be a very, very wonderful use
case in the market, right now.
So let's look at--
how can we do that?
So skin thickness is zero, insulin is zero,
BMI is this value, diabetes-- oh, sorry, what was that?
23.3.
Age is 32.
So this person has diabetes.
This person has diabetes.
And let's see what bot predicts.
If bot predicts that this person has diabetes with the accuracy,
then we're--
our application is clearly working correctly.
OK, so let's wait for that.
And the bot is still running in background
and bot is trying to predict.
Perfect.
So this person has diabetes and it is an accuracy of 74.75,
so almost 75%.
And the prediction is correct, it is exactly accurate.
Now let's look at the fourth data for this particular person
who doesn't have any diabetes.
So this is a non-diabetic person.
So let's see.
Let's copy this data in here, one by one.
And once we check all the accuracies
of all these particular people's data,
then we are going to go ahead and look
at how this bot is exactly integrated,
and how can you leverage this bot-- sorry,
I did not copy this correctly.
So insulin value is 94, BMI is 28.1,
diabetic pedigree function is 0.167,
and the age of this person is 21.
Let's predict.
Now this person doesn't have diabetes
and the bot prediction should be no diabetes.
Non-diabetic person, and prediction
should be more than, at least, 75% or 70%,
so we can believe what the data say.
And exactly, this person is non-diabetic,
as the bot has predicted, as you can see on screen.
And the accuracy is 97.80, which is almost 98%.
So 98% accuracy.
That is really correct, I mean really correct.
And now, all the accuracy of this bot
depends on the last data, so let's go ahead,
and let's try to predict what happens
at the end of this particular dataset.
So we have the last patient, here,
and the last patient's data are glucose,
137, blood pressure is 40, skin thickness is 35,
insulin is 168, BMI is 43.1, diabetes pedigree function
is 2.288, age is 33.
And let's predict.
Let's wait for the outcome, and we
will try to verify whether our data is correct.
So let's look at the accuracy.
This person has diabetes, though.
So let's see if bot predicts it very accurately.
And bot has completed execution, and the bot
has predicted it diabetic.
And with more than 75% accuracy, 76.23, which is 76%.
So this is also correct.
And with this, we can say our bot has predicted totally
100% accuracy for all these patients
which we had records of.
And bot has predicted correct for each and every one of them
with more than 75% of accuracy.
Now, I know you're really interested,
how did I create this particular application?
So I know you're very, very interested.
And let's look at how I created this application.
It is very easy.
So the first thing you should have
is the dataset, obviously, for machine learning training.
For that, I used Kaggle's Pima Indian Diabetes Dataset.
So I used this dataset, you can download it from here,
in CSV format.
And then I converted that data into training and test
set of data.
So always remember, training dataset is 80%,
test dataset is 20%.
I used UiPath's TPOT model, which is--
I'm currently in UiPath AI Fabric, OK?
Now, as you can see here, this is the project
for diabetes prediction.
And if you go to ML Packages, Out of the box package,
here, in the tabular data.
I'm using TPOTAutoMLClassification model,
because I just need to predict whether a person has diabetes,
yes or no.
So it is going in the classification model.
And in the classification model, I just
train the data with the dataset, so I uploaded the dataset here,
[INAUDIBLE] data.
So data I just look from here, Pima Diabetes dataset,
you can get the data from here.
And you can create the pipeline for train and evaluation.
You can see I got the accuracy of 77.92% when
I trained this model.
So this model is trained with 70--
almost 78% accuracy, and it is predicting very correctly.
All the data and the skill is also deployed right here.
OK, so if you have made more than--
how many predictions?
We have made almost eight predictions.
Correct?
And you can also see the logs here.
Now, once you've deployed this AI Fabric bot, or AI Fabric
project, which is diabetes prediction,
then you need to go here in the UiPath Studio,
and I have created a very simple UiPath workflow here,
which gets all the data using arguments.
So I'm taking all the data using arguments, right here.
OK.
And once you get all the data, we
are going to convert it into a dictionary variable,
then into JSON, which is required for the diabetes
prediction.
So then you put response inquiries just
like this, which reads Feature1, Feature2, until FeatureN,
and target column is also accepted.
And then it is going to give you predictions
based on predictions zero of confidence.
Once you predict the data-- once you get the data--
you can write it in the JSON format,
and you can put it into deserialzation.
And based on the condition of the dataset,
you get the output, whether it is diabetic--
whether the person is diabetic or non-diabetic.
And then you send that values outside,
using out_Prediction and out_Confidence.
And once it's entered value outside, what do you do?
You navigate to UiPath Apps, and you create a very beautiful
UiPath App.
So let me show you how the app is structured, in edit format.
So what I have done is, I have simply created all these input
dialogues or you can say, input controls,
which is nothing but text area.
Predict is a button, Diabetes Prediction and Prediction
Accuracy is nothing but the label,
which I want to showcase here.
And if I navigate here-- so I have attached the process.
The process is-- let me show you the processes--
the DiabetesPrediction process which I
published on the Orchestrator.
Let me show you the Orchestrator.
So-- let me refresh-- so DiabetesPrediction
is the process which we publish from Studio.
We will navigate to the app again,
back, so this published process is
connected with this particular application.
And, apparently, I'm taking all the values here
from the workflow, which are in arguments.
And as soon as you click on the Predict button,
it is going to predict the diabetes,
and it is going to predict the accuracy.
And it is going to display the accuracy of the prediction.
So this is how simple the bot creation is.
Thank you so much for watching this video,
and happy automation.
[OUTRO]