Hi and welcome back to this, because so now that we have trained our squad model, we are ready to
go to the evaluation box.
So this involves creating a decent file with our prediction for the deficit.
And this process is a bit complicated.
And actually, it's not that it's complicated.
It's more that it's really specific to squad.
And we have many things to do in order to have something that fits the input for the evaluation scripts
that we will have a look at later.
So I decided not to write dozens or even hundreds of lines of code just so that's because that's actually
the number of lines that Google wrote in order to have something that is optimized to get the correct
file for the evaluation scripts.
And so we will basically use the functions that Google wrote and we will go into the details.
For me, it's not really interesting and we would lose a lot of time doing.
That's the most important thing of this application of this model have been seen in details.
But hey, we actually just use the process that Google developed for birds.
And so we want to write everything together because also there was some concept intensive flow that
we have not seen and are not really useful.
So I would just quickly explain what its function does.
But the whole preparation of the evaluation won't be our main focus.
We will write the loop that makes the prediction, of course, but everything that is not really related
to our A.I. and that is to specify the squad and that involves too much lines of code without learning
anything.
We want to go into the details.
So basically, what does the first cell, it just gets the death that you should have in your personal
Google Drive folder into the session.
Then in order to understand the few next sales, we just need to understand that what we will call feature,
which is actually a T.F. to train that feature and also example and to record those are actually protocols.
So they are tools that I'll use in order to convey information or to store information.
So that's a really specific tool intensive flow.
That's Google using this code.
All we have to know is that those are conventions.
So this is exactly what we do here.
We define the function that will write our traffic code file related to the deficits, and then we just
creates a tokenized, as we did several times before.
This is for future information needs.
We will need information about tokenized isolator.
Then there is a small function that we need to declare that will help us create the list of the evil
features.
So once again, as I told you evaluators, it's not really the features of our data sets.
It's conventions of information.
And now the important parts convert exemplars to features.
This will create the features that we will need later to create our Jaeson file with the outputs and
also it creates the T.F. that we could file.
So the total file is the file that will contains the future data set that we will use as inputs for
our evaluation.
And this is exactly what we do here.
It's the same thing as what we did for the data processing, for the input creation.
Once we have our track record, we can call create squad data sets.
That is the function that creates the data sets for the task from ATF records file that has been created
before.
Of course, the only difference is that here we need to specify that this training is false.
So this is not a data set that corresponds to a training set that we are using.
So that's basically the process that we need to use if we use the Google codes in order to create our
data sets for the evaluation bots.
So that was not the funniest part of our journey.
But now that we have this, we can write every bit of code by ourself to really make the predictions
and we will write this into a JSON and finally we will be able to evaluate our model.
So I'll see you in the next letter to finally make the predictions see soon.