So in this section, what we do, we analyze our results.
So a good way to analyze results is basically to create some training plots.
These are very good ways to understand how your model is performing in relation to how many epochs we
performed, how it's doing a test dataset.
I assume that the training, the dataset, we're going to look at accuracy and loss for each.
So let's take a look here.
So remember, just to recap, we created a epoch law lost log in accuracy log.
Well, the reason we created those is so that we can actually produce these auto shots at the end.
So I'm not going to go into too much detail with the code for these charts.
I'll just go through it relatively quick.
If you wanted to understand math problem, there's a lot of online logs and material to discuss how
to use my Portland.
But for now, what we do?
We're creating some subplots.
So we use plotted out subplots here.
We create the figure and the ax here.
So what we do know, we just create the title for using the party function, and we said we want to
put the title that way to five degrees so that you don't have to do that, to be honest.
We use X one or twin x.
That allows us to have two different Y accesses on the graph.
And that's because the loss isn't a very different skill to accuracy.
Accuracy is a percent skill, and it's usually going to be close and close to 80 and above in most models.
And loss is going to be quite low.
It's going to be under one of the two.
In most cases, and these are a number of epochs we train for.
Remember, we just train for 10 epochs.
So this graph is exactly what you want to see when you're training.
You want to see a loss starting at a relatively medium high point and then coming down as e-books go.
And then you want to see accuracy going up as well.
So this is this is a good sign.
Now this is the accuracy and loss for the test dataset.
If you wanted to actually do this for the training loss, you can just create some more functions here
and store those results in the loop as well.
We didn't actually store them in our case.
However, it's a good exercise for you to do to go back, manipulate the training code, which I want
to go all the way up.
But it's quite it's quite long.
So a simple exercise to do just create some new variables.
Run the function.
Run the data.
True.
Still, get the training, the model story accuracy still loss at that point and log it and then photographs
of it afterward.
So you can see what the epochal looks like, it's just a list of this range.
Similarly, you can use this to generate that list as well.
I don't know.
I actually put this here just maybe to help you guys understand what epoch was doing.
So that's it for this lesson.
I won't go into that.
This is an extra good and not so observations here is that if you were to try this same network treating
it with a CPU, it's going to take much, much longer.
So if you wanted to give it a try and experiment with that to see how it goes.
Good luck with that.
And basically.
So that concludes this lesson on Python, which you've seen how we actually put everything together,
how we got our data, how we looked at our libraries, how we created the network poetry to optimize
data loaders, lost function, then how we passed everything to our training loop, how we saved the
model, how we displayed our results, how we loaded our model and then got get some pretty got some
predictions out of it.
So I hope that was a very useful lesson for you guys.
What we'll do next, we'll do the same thing, the same procedure, but we just did.
However, we're going to use Keros with TensorFlow to do this, so it's going to be quite different
and also quite easier and much simpler than using by too much.
And there's a reason we started with pay to watch this.
It's because it is a harder one.
It's a bit more intricate, a lot more detail, and you have to understand the training process a bit
more than by George.
So I thought it would be good for you, beginners, because they're coming fresh from the slides to
understand how to construct the neural nets to CNN's inside touch.
And then afterward, when you saw moving to Keros, which is a much higher level API, it's going to
seem a lot easier.
And Caris is quite nice.
A lot of people may prefer to use cameras for most cases, most projects researchers may prefer to use
pay to watch, and we'll have some slides where we discuss the differences when you should reduce PyTorch
or when you should use cameras later on.
But for now, that's it.
And for now, we'll move on to creating seamless CNN inquiries.
So I look forward to showing it up in the next section.
Thank you.