Here we are back in the Colab, which has been running overnight for me and probably for you too, I
hope.
And if anything, like me, you've been eagerly glued to it.
So this is showing the part in the colab where it's running away and you can see it's ticking through.
It's more than halfway at this point as it makes its way through the four epochs.
Four epochs are not required for this.
You only need to do one epoch, of course.
And just that I'm a sucker for this stuff and loving it.
So it's it's ticking away.
Let's go to the fabulous weights and biases to see how it looks here.
This is our run.
You remember in weights and biases.
The navigation at the top here lets you see the different projects that you may have.
And we're looking at my Pricer project, which is the one in question.
I've also got a Pricer GPT project for for where we fine tune GPT.
Um, and then here are the different runs I name the runs in the code after the date and time that they
were kicked off.
You don't need to do that.
You can call them runs anything you want.
I do this because it helps me be able to, uh, recollect when I did, what, run and so on.
So I found this quite a useful trick.
But you could also name it to describe the kind of run that you're doing.
Um, and you can also rename it by, by right clicking on it.
Uh, so the current run is this blue run right here.
This is what we've been running.
And if I zoom in on the training loss, which is the the diagram that really matters, you now know
this is cross-entropy loss we're seeing here.
Uh, and you'll see that it clearly has uh, this was the first epoch.
It comes down a bit here, uh, potentially because some overfitting starts to happen when it sees the
data a second time, and then it drops again for the beginning of the third epoch here.
The thing that I'm not doing that is a very much a best practice that I should be doing is having a
validation data set, and we'd be able to see validation loss.
And I imagine what you'd find is that it maybe only decreases a little bit here, and maybe quite soon
it will start to increase a bit because we are overfitting.
Uh, we'll find that out by, by running the model in inference mode, but it would be better to see
the validation results.
And hopefully that's something that you are doing.
And I would love to see those charts by the way.
So what we can also do is layer on top of this, the prior run that I had done when I ran it through
to completion.
Here we go.
Let's zoom in again on both of these runs together.
And what you'll see is that the two runs are very, very similar indeed.
Obviously I had the same, um, the same hyperparameters, and I'd set random seeds.
And so it's not not a great surprise, but it does show you that despite all of the complexity and everything
that's going on, you do get the, the same numbers, um, from these runs.
So that's somewhat comforting.
Uh, and I think that's probably all to all to show you.
We can see that in terms of the learning rate that now, well, before we were suspicious that the blue
line, if we just look at the blue line only, uh, just for a moment, flashed up with what it used
to see.
It used to be if you saw that, uh, if we bring this up, you'll see that the last time it was all
the way up here.
And maybe you were skeptical about whether we were really seeing a nice, smooth curve.
And now you clearly see that it's coming down in a very nice way.
So that cosine learning rate scheduler is a good trick to know, a good way to vary the learning rate
during the course of your batch.
Okay.
And then final thing to show you is to flip to hugging face.
I'll mention if you look at this model, you'll see that the name of this ends in 11 seconds at that
timestamp.
If we go over to Hugging Face in the hub, I've got all these different models.
And this one, this one ending in 11 seconds is, of course, the run in question that's running right
now.
And in fact, it even says updated two hours ago.
So we know it's the right one.
As I say, some people will just have the single repo they'll just write to for all of their different
runs, and that's a perfectly good way of doing it.
I prefer doing it this way, so I keep my my different runs completely separate.
And if I go into this repo we're now looking at if I click on files and versions, these are the files
associated with this.
Run again the safe tensors.
That's the business.
That's where it all happens.
It's 109MB worth of parameters that are the parameters of our Lora adapters.
Um, and over here you'll see history nine commits.
If I click on this, it's showing me that just as I had asked in my parameters in my setup, uh, hugging
face has been saving this to the hub, uploading it, making a different revision of these model weights
every 5000 steps.
Um, and so, uh, that's something we'll have access to if we want to go back and do some, uh, do
inference on any one of those different commits.
And hopefully you can see why I like to keep it as a separate repo.
So I don't muddle up the different saves during a particular run with the different versions of training.
Okay, I think that's enough of a tour of where we're at.
Uh, head back to the slides one more time before we actually get to inference.