And welcome back in this section, we'll take a look at building an obstacle to using the ultra-Orthodox
YOLO Vision five framework to train a blood cell detector.
So we're going to detect different types of blood cells in these medical images.
These slides of these microscope slides.
So let's take a look.
So let's open Notebook 51 here, and let's get started.
So you can see this is how it's labeled.
So you can see these cells here with this bluish tint to it that I guess that's a white blood cell.
And these smaller ring looking ones are two red blood cells.
And these are platelets here.
So you can see those are the three main classes in this medical imaging dataset.
So again, this is a rebel floor notebook.
However, this one is actually provided by cultural ethics that mean removal to onto the text implementation
implemented it here.
So let's take a look at it now.
I will tell you ultimately did an amazing job with your vision.
Five.
So feel free to visit the GitHub repo.
Actually, we can take a look at it here.
In just visit this link right here and we can see the GitHub repo.
So you can see your image in five here, you have a cloud implementation, also, Cargill is a slack
forum where you can ask the developers questions as a Docker image as well if you needed one.
It's quite easy to install and setup.
It works on CPU systems or GPU systems.
However, don't trade it in the CPU system.
It's going to take forever and probably going to overheat your machine.
But you can see it's quite well integrated.
It has a number of integrations with things like weeds and biases and other metrics.
So it's quite good.
Encourage you to use this.
You can see it's quite popular on GitHub.
It has 21000 stores as well.
So I've already run around these blocks of code here.
This is just to clone the repo and still the requirements.
And then we get the data set.
Download it here.
And we just do some file configurations as well and print the configuration file.
The Yamoah, actually they don't call to see if she filed in this report or two of six.
And then we can just write some things to the file here, some changes we need to make and balances
from number of classes, actually, which comes from an earlier function.
And then we can just start training.
So let's begin.
So you can see your model has begun training here.
Let's take a look.
This is what you should see when you start training.
You can see all of these things here, and that's good architecture that is displayed.
And then you can see the training results after each epoch and you can see it's training quite fast
anyway.
Let's pause there for now, and I'll show you the inference for to see on the Vision five model using
the blood cell detection dataset.
So let me just pause this recording here.
So now you have the performance metrics you can analyze with this tense on board here.
You can also get the images for the results so you can take a look at the precision to recall the map
because those are quite important as well.
And you can take a look at inference on a few of the images here, so you can see this is the ground
to data, first of all.
And no, we're going to print the creating results.
Yes, and this is the actual results on some of our test data.
And you can see this is quite good.
Now you can run it in a few random images here and take a look at them individually here for these images.
And you can see this is also quite good.
It looks quite similar to the other one, but that's because it is similar.
So you can see this is performing quite well with your emission five and then you can export these weights
for future use if you want to save them.
So overall, I think this is quite good.
Hope you're happy with this lesson.
In the next lesson, we'll take a look at a plant doctor dataset.
What is that?
Well, it's looking at different plant lives for disease.
It's quite a few different classes in it.
And again, we're going to use the ultra takes, you know, information five pi to its implementation.
So stay tuned for that lesson.
Thank you.