Hi and welcome back to this birth cause, so let's start calling for our obsession with but of course,
the first thing that we have to do is to connect to the server.
And as I showed you for the first application, how to use a GPU as accelerator.
We will have another look and see that I use this time, Tipu, because, as I explained to you, are
way more efficient for birth training.
So I advise you to go to Tipu for this application and anyway, for any application where you want to
fine tune that.
So that was for the first.
But then we will start by having to install some libraries.
But this time those will not be the same as for the previous applications, because this time we will
really train, but we will find units.
And actually Google developed some well developed, created some custom optimizer.
They don't use the standard Adam Optimizer.
They just tweeted a little bit and it's actually available.
The code is on GitHub.
And so we want to use the very light birds package that's introduced at the beginning.
We will use this time the official development of birds intends to float to by Google.
So this is something that is still in development.
But they really recently made a package available for installation.
So we will do that by calling PIP install G.F. modules.
Official, so that's the first new thing that we install and in order to make sure that everything works
perfectly, we will not actually use the latest official version of the flow.
We will not use dancefloor 2.0.
We will actually use the last devlopment version of dancefloor.
So this is the version of 10 that contains the future changes that will be officially released.
And the reason why we do that is that T.F. models are official being also something that is in development.
We want to make sure that we have all the tools to make it work and those tools might be actually in
the latest version of dancefloor and not in the official release version of dancefloor.
So in order to do that, we also need to install T.F. Nightly.
So this is how we call this def version of Densify.
So let's run that.
This might take more than a few seconds.
So we'll cut right here.
And because I want to show you something right after it's.
OK, so after inserting those packages, you should have a lot of lines and some of them are red, and
most importantly, you have this message at the end that tells you that some versions of the packages
that were installed in the server we are using are not compatible with the new version of the photo
that we want to use.
And that's perfectly normal.
So we just have to do what they tell us to do, which is to restore the runtime.
Oh, yes.
And so you can see that we are restarting everything and now we will be able to use our new version
of Tensor Flow.
So let's continue importing our packages and we start, of course, with denser flow.
So imports then flow as T.F..
And we don't have to worry about this one and we'll just check that we have the right version of to
follow by calling t f that and disco and disco version and disco underscore.
And yet we see that we don't have to point out, not even to point one.
We have some later version that is the dead version of dancefloor.
So now let's import everything that is related to to flow into bits.
And actually we will import a lot of things, a lot of functions, because we won't do the whole day
that people sitting by ourselves, mostly because this is really specific to squat.
This involves some chasten preprocessing and some small optimization that Google has made.
Everything is really specific to this quad format of the data.
So we will actually use for the auditory processing and for writing the results and the evaluation phase.
A lot of functions that Google needs and that Google wrote that are available in TFW modules official.
So let let's import everything first, of course, because we will use, but we will create it, but
later we will need to import denser flow.
Hebb as before and we import it as her.
Now let's import what will be related to the data processing.
So from official that an LP, that CIA official is the way we call the package which we import in here.
TFW modules official.
This is called oficial.
So from official that and LP Dot, but that's tokenization.
We import full tokenized.
So that's actually exactly the same filter is a function that we used before.
This is just how we call it with this new package that we are using.
And now we'll copy this because I will use it a lot for the next ten lines.
So the other thing that we want to import is from official and they'll be input pipeline and we import
create squad data sets.
And then the last thing we want to import for the data processing will be from birds and squad leaders.
So they even have a full file about functions that are really related to this QUAT task and the pre
processing and dealing with all the data.
And from that we want to import generates T.F. records from Jaeson File because the IDs that we will
use the original JSON file of the squad's data sets.
And with this function we will create an intermediate file, which is a record file that then will be
used by the function creates quite data sets in order to have a fully performing data set for a module.
And this dataset will look exactly the same as the one we built ourselves for our previous applications.
Now, as I said before, we want to use the standard Adam optimized that we will use a slightly modified
Adam, which is available by calling from official official DOT and LP imports up to my station.
So in this optimization, there is an optimizer that we will use and that is slightly better than Adam
to fine tune.
But and finally, all the files that we will use for the evaluation part, because we will need to use
our outputs to write in a file that will be used with the evaluation script that comes with squad.
So the first thing is from official NLB, the birds that squad labe we import with squad examples.
Now, let me actually.
But all this thing.
Because we will also need.
The feature writer, so those are just some really small tools that I used to process the the output
of birds of our model in order to make it a valid input for the evaluation scripts from squad.
So we still need to import.
So there is.
Whitespace here, we also need convert's examples to features and finally rights predictions.
So that's the function that will allow us to write our prediction in a decent file that fits the formats
that will be used for the evaluation scripts right after.
So let's import all that.
And finally, we will import some more standard libraries for Python and for everything else.
So we import NIAMBI as and B, we import math.
We import random import time.
Also in sports, Jason, we will also use the package collections and imports.
Oh, yes.
And finally, as we will need to have access to files that are in our personal Google Drive, we need
to import drive from Google collab.
So import.
So that's it for all the importing that we ought to do.
So that was more than usual.
But that will allow us to go back into building the model because it will really simplify the data processing
and writing the result into a valid file.
So let's go right now into the type of processing that will be faster than usual this time.
So let's go through that quickly and see you soon.