[00:00]
Today, you'll learn how to fine tune
[00:04]
I'll walk you through it
[00:05]
step by step, give you all the code
[00:09]
So let's go ahead and get started.
[00:11]
Now first
[00:14]
and when you should actually do it.
[00:15]
So fine tuning is taking a pre-trained
[00:19]
to be better at your specific task.
[00:21]
So think of this like hiring
[00:22]
an experienced chef and training them
[00:26]
Rather than teaching someone
[00:30]
So here's how it works.
[00:31]
Instead of training a model from zero,
[00:35]
or Claude that already understands
[00:38]
Then you feed these examples
[00:41]
So maybe customer service conversations,
[00:46]
The model then adjust its existing
[00:48]
knowledge to excel at your specific domain
[00:52]
Now this is completely different from
[00:55]
settings like temperature
[00:59]
Parameter tuning
[01:02]
Whereas fine tuning
[01:03]
is like teaching your car to drive
[01:06]
Now, when should you fine tune?
[01:08]
Well, there's three main scenarios.
[01:10]
First is when you need consistent
[01:13]
The prompting alone can't achieve.
[01:15]
So something like you want to output
[01:18]
or you want the model to write in
[01:21]
Second,
[01:24]
that the model just hasn't seen before.
[01:26]
So things like advanced medical records
[01:30]
or information that I just wouldn't
[01:34]
to what it is that you're doing.
[01:35]
And then third,
[01:37]
by using a smaller, specialized model
[01:42]
Now, the key advantage to fine tuning,
[01:46]
is that you need way
[01:49]
Instead of millions of examples
[01:52]
you might need thousands
[01:55]
and maybe minutes to train or hours
[01:59]
But here's the catch when you do fine
[02:03]
At general tasks,
[02:06]
So if you do fine tune
[02:07]
one of these models, keep in mind
[02:11]
at least typically, but be much better
[02:15]
Anyways, with that information
[02:16]
I want to show you how to do this
[02:19]
So let's go over to the computer
[02:21]
up in Python with some example data
[02:26]
And the first step
[02:28]
if we want to fine tune a model, is
[02:31]
that we're going to fine tune
[02:33]
If this is the most important step,
[02:36]
you're going to have a poorly
[02:38]
So make sure that you take your time here
[02:42]
Now for this video I've just used
[02:45]
which demonstrates HTML extraction.
[02:49]
So you can see that
[02:52]
a price tag, whatever, etc..
[02:54]
Okay, there's a bunch of information
[02:56]
and what I'm expecting the model
[03:01]
that tells me the name, price, category
[03:05]
Now, this is very specific
[03:08]
from these types of tags.
[03:10]
However, you could do anything as advanced
[03:13]
And you can see that
[03:17]
where I have some sample input
[03:20]
Now this can be literally anything
[03:22]
that you want, because
[03:25]
you're giving it example prompts
[03:28]
the result or the answer from
[03:32]
So you can use customer data again
[03:36]
In this case just simple HTML extraction.
[03:38]
So you can see kind of how it works.
[03:40]
And I can compare it easily in this video.
[03:42]
If you want this specific data set
[03:44]
I'll leave a link
[03:46]
Okay.
[03:47]
Now for this video
[03:48]
we're gonna use something called onslaught
[03:51]
This is open source.
[03:52]
It's free to use,
[03:55]
and very fast at fine
[03:58]
All right.
[03:59]
is I'm going to go over to this fine
[04:03]
for the purpose of this video.
[04:04]
I'm not going to write all of the code
[04:06]
I'm just going to leave a link
[04:08]
in the description that you can download,
[04:10]
or that you can connect to
[04:12]
and then you can use your own data
[04:16]
But before we get into that, here's
[04:20]
If you're already fine tuning LMS
[04:23]
Chances are you're solving real problems
[04:27]
Maybe it's a niche SAS,
[04:28]
an AI agent, or a quick side
[04:32]
Now imagine giving those users
[04:36]
booking system, portfolio, whatever
[04:40]
No templates, no drag and drop
[04:45]
Well, that's what ten web's AI Website
[04:49]
It's not a template engine
[04:52]
It's a real API that spins up fully
[04:56]
structure content design,
[05:00]
all in under 60s.
[05:02]
With one API call,
[05:06]
Your users never leave your dashboard.
[05:08]
You get full white label control,
[05:12]
your customer relationship,
[05:16]
management, and technical infrastructure
[05:20]
This is how ten web powers websites
[05:23]
And now you can do the same thing
[05:27]
Whether your user is launching
[05:30]
or online store, the site comes complete
[05:34]
mobile optimization, and full e-commerce
[05:39]
The platform that runs 62% of the web.
[05:42]
If you're ready to turn your next big idea
[05:44]
then visit my link in the description
[05:47]
Call with the ten web team to see
[05:51]
Okay, so how does the fine tuning work?
[05:54]
Well, you can fine
[05:57]
by running all of the code
[05:59]
that you can download
[06:02]
But unless you have a really powerful GPU,
[06:06]
even more powerful than that, then
[06:10]
So for most of you, I suggest that you use
[06:13]
This is a free online
[06:15]
code editor environment provided by Google
[06:18]
high end GPUs so you can do all of your
[06:22]
We can
[06:25]
and we can download it to our own computer
[06:29]
what I'm going to show you how to do.
[06:30]
So first step here is open up
[06:32]
I'll leave a link in the description.
[06:33]
If you're doing this on Google Colab
[06:37]
you should see a button here
[06:39]
We're going to press that
[06:40]
and we should connect to a
[06:45]
And if you're not sure,
[06:47]
and it's going to show you
[06:49]
system Ram, GPU, Ram, and disk,
[06:51]
and it will show you
[06:53]
If that didn't work, you can go here
[06:57]
And then you can make sure
[07:00]
and that you're running in Python three.
[07:03]
So now that we're connected
[07:05]
we can start running the various cells
[07:08]
Now, because we're going to train this
[07:10]
on our own custom data,
[07:12]
So what I've done is I have this Json file
[07:16]
But in order to open it in
[07:17]
Google Collaboratory
[07:20]
So I'm going to press on this file
[07:23]
And I'm going to go to this
[07:26]
And I'm going to select this file again.
[07:28]
You can download this
[07:31]
So once this file is uploaded
[07:35]
And what I'm doing is I'm
[07:38]
as a Json file by providing the name Json
[07:42]
Now you can use any type of data
[07:44]
Again,
[07:47]
where you have some input
[07:49]
Okay.
[07:49]
And the output
[07:51]
I'm going to convert this
[07:52]
to a string in one second,
[07:56]
All right.
[07:56]
So now that we have
[07:58]
And you can see that
[08:00]
And I'm successfully loading in this file
[08:03]
So I'll go ahead and close that window.
[08:04]
Next we need to install the various
[08:06]
In my case I'm in Google Colab.
[08:08]
So I'm going to run exclamation
[08:11]
I'll remove the uninstall command.
[08:12]
I just had that in case
[08:15]
Okay, this is going to take probably
[08:19]
Once it's done, I'll be right back.
[08:21]
So that install has finished here.
[08:23]
And now we're going to
[08:23]
move on to the next step here
[08:27]
However, as I says here, the following
[08:30]
In this runtime,
[08:30]
you must restart the runtime in order
[08:34]
So I'm just going to press
[08:37]
just to get this reloaded.
[08:38]
And once this restarting thing is done,
[08:42]
We can move on to the next cell.
[08:44]
And if you are running this locally,
[08:45]
the install might
[08:47]
and you are going to need to have Cuda
[08:50]
and be using an invariant GPU
[08:51]
in order for this to work,
[08:54]
That's why I like using Google Colab,
[08:56]
because everything is already
[08:57]
So I'm going to go ahead and press run
[08:59]
I'm just going to run this cell and check
[09:01]
if I have a GPU available
[09:04]
I should get two trues here
[09:08]
So Cuda is available
[09:12]
in this Google Colab instance or runtime,
[09:16]
Okay, so now we can move on
[09:17]
and we can start actually
[09:20]
Now here we need to pick the model
[09:24]
Now I'm going to pick
[09:25]
because I want to do this
[09:27]
and I want this to take days or weeks
[09:30]
And the model that I'm using here
[09:33]
Okay.
[09:33]
You can look up this model
[09:34]
if you want to see
[09:36]
but you can fine tune
[09:38]
That's open source.
[09:39]
So for the model name here,
[09:42]
You can go to the onslaught documentation
[09:44]
to find all the models that are available.
[09:46]
There are pretty much
[09:47]
you could do here like Lama 3.1
[09:52]
you can put them all here.
[09:53]
Then we're going to set the sequence
[09:54]
Now in this case
[09:57]
This is the maximum number of tokens
[09:59]
that the model can handle
[10:02]
Don't worry about that.
[10:04]
And this just means that we're going
[10:07]
Now what we need to do here is just load
[10:10]
So that's why I put the model name here.
[10:12]
And I'm getting the model
[10:13]
and the tokenizer from the fast
[10:16]
And then I'm
[10:16]
loading this pre-trained model
[10:20]
length load in four bit is equal to true
[10:25]
So I'm going to go ahead and press on run.
[10:27]
That's going to load the model for us.
[10:28]
It will need to download it
[10:31]
So that can take a second.
[10:32]
And you might see some stuff like this
[10:36]
Don't worry, that is totally normal.
[10:38]
I'll be right back
[10:41]
All right,
[10:43]
Again, I picked a pretty small one
[10:45]
If you pick a larger one, this can take
[10:48]
And next what we're going to do is we're
[10:51]
So the day that I have remember
[10:53]
where we have some input
[10:56]
Now what we need to do is
[10:59]
string that we can send to the model
[11:03]
So what we're going to do is we're just
[11:06]
that I wrote here,
[11:08]
That input is going to be equal to
[11:12]
So you'll likely
[11:14]
whatever type of data it is that you have.
[11:16]
Then I have a new line character,
[11:18]
And what I've done here for the output
[11:22]
Json object, I've converted it into text.
[11:25]
So that's what Json dump is doing.
[11:27]
I'm taking a Json object
[11:30]
So I'm doing that for my output okay.
[11:32]
And then I put this end of text tag here
[11:34]
so that the model knows
[11:37]
That's it.
[11:38]
There's many different ways
[11:40]
but this is what I want the prompt
[11:43]
And then this is the expected output okay.
[11:46]
I then have my format of data
[11:48]
through all of the items
[11:49]
that I have in my file and call this
[11:53]
And then I convert this into a data set.
[11:55]
Now if you try to run this,
[11:57]
That's
[12:00]
we may need to rerun where
[12:02]
because we reset the runtime.
[12:04]
So if we scroll down here now
[12:06]
that we can re-execute this cell.
[12:08]
And we should be good to go.
[12:09]
And we now generate this data set that
[12:12]
when we're running this trainer okay.
[12:14]
So now what we're going to do
[12:16]
something called the Lora adapters.
[12:18]
Now I'm not going to go into too much
[12:21]
But this line right here is essentially
[12:25]
that we need to our lemma in order
[12:29]
So again this can get very complicated.
[12:30]
You don't need to understand
[12:33]
And if you do want to mess with them
[12:35]
Or maybe use an L1 to explain them to you,
[12:37]
because there's a lot going on
[12:39]
Explain this in this video
[12:41]
So in fact,
[12:43]
or in Colab, I'll just highlight this.
[12:45]
Right click on it, press explain code.
[12:48]
This is going to use Gemini
[12:50]
And then we can actually just see
[12:52]
And that's going to be more accurate
[12:55]
So says the selected code applies
[12:58]
method to the language model.
[12:59]
Using this, here's
[13:02]
and then it tells
[13:04]
Okay, so use Gemini within here
[13:05]
if you want to know
[13:07]
Either way, we're going to go ahead and
[13:10]
Now by kind of adding
[13:12]
which then will actually allow us
[13:15]
which we'll do now.
[13:15]
So you can see 1.32 pounds layers
[13:19]
Don't worry too much about that
[13:21]
Okay, so now that we've learned in the
[13:24]
Now the trainer is actually the thing
[13:27]
tuning for us people much smarter than
[13:31]
So all we have to do is simply use it.
[13:33]
So again,
[13:34]
if you want, but what I'm using here
[13:38]
Importantly, I pass my model
[13:41]
This is actually going
[13:42]
to convert our string into the token
[13:46]
I pass my data set
[13:48]
The field for my data set is text.
[13:51]
That's important because if we go look
[13:55]
Here we created the data
[13:59]
And then it has all of the values okay.
[14:01]
And then we have a few other things
[14:03]
For example the maximum sequence length
[14:05]
that needs to match
[14:07]
And then all of these training arguments.
[14:10]
Again, I'm just going to leave
[14:11]
these kind of all default,
[14:14]
All right.
[14:15]
So now we're going to run this.
[14:16]
We're going to initialize the trainer.
[14:18]
And now that that is created
[14:20]
is actually train the model.
[14:22]
Now this step is going
[14:23]
to take a different amount of time
[14:26]
and the different settings
[14:28]
The more examples you have, the longer
[14:32]
you will get.
[14:33]
The larger
[14:35]
Then again, the longer this will take.
[14:37]
In my case, I'm using a very small model
[14:39]
with a very small amount of examples,
[14:43]
but this should train in
[14:47]
All right, so we are training now
[14:49]
and you can watch this window
[14:51]
So once this is finished
[14:53]
And then I'll show you how
[14:54]
we can actually test this model,
[14:57]
and then download it
[14:59]
All right.
[15:01]
Just as an FYI
[15:04]
So the next step is we're going to set up
[15:07]
just so we can test it and
[15:10]
So in order to do that, pretty much
[15:12]
here is modify these messages
[15:15]
So you can see I have some raw
[15:18]
And then I have content
[15:20]
You can place multiple messages here.
[15:22]
And you can see that this message is
[15:25]
I'm doing
[15:28]
You don't need to worry
[15:31]
We're just kind of putting the input
[15:33]
where we're able
[15:36]
at least in the inference mode,
[15:40]
That will just take a second.
[15:42]
And then you can see that
[15:44]
So we have user right
[15:47]
And then if we go over here
[15:50]
And then we get the output in the format
[15:53]
Okay.
[15:55]
And we can test this
[15:57]
to make sure it is working to our liking
[16:01]
Okay.
[16:01]
So now that we've assumed
[16:04]
It's working.
[16:04]
We've tested a few times in Google Colab.
[16:07]
What we want to do is download this model
[16:11]
and then start using it more permanently
[16:15]
And this step does take a while.
[16:17]
So bear with me here.
[16:18]
What we're going to do is run this where
[16:22]
Gov is the model format
[16:26]
So that's
[16:28]
So I'm going to go ahead and press run.
[16:29]
It is now going to essentially
[16:33]
Download it to Google Colab.
[16:35]
And then after that
[16:38]
so we can save it to our computer.
[16:40]
Now this can take a long time.
[16:42]
It can take ten minutes
[16:44]
So just bear with it.
[16:45]
Be patient.
[16:46]
And once it's done you can run this cell.
[16:49]
This cell will then download it
[16:52]
Then read and move on to the next step
[16:54]
where I show you how to actually load this
[16:58]
So once this is done executing
[17:01]
you should have a file
[17:04]
folder that's named something like this
[17:10]
If you're just looking for some file
[17:13]
this is going to be a pretty large file
[17:17]
In my case, both
[17:20]
so just keep that in mind.
[17:22]
This will take a while,
[17:24]
internet connection
[17:26]
Okay, now that we have the file,
[17:31]
So we need to create
[17:34]
So what I'm going to do
[17:36]
I'm just going to do this
[17:37]
to make our life a little bit easier.
[17:39]
And I'm going to open this up okay.
[17:41]
I'm going to zoom in a little bit
[17:43]
and make sure that a llama
[17:46]
So run the llama command,
[17:48]
make sure you've got that downloaded
[17:52]
Okay, from here
[17:55]
So CD into downloads
[17:58]
I have this Unsworth kind of
[18:04]
So what I'm going to do
[18:06]
So I'm going to say mkdir
[18:09]
Okay.
[18:10]
If we go to downloads now we can see this
[18:13]
I'm just going to drag this file
[18:15]
So now it's inside of Olamide test okay
[18:18]
I'm now
[18:20]
And I'm just doing this
[18:22]
But you don't need to follow
[18:24]
And what we're going to do now
[18:25]
is we're going to make something
[18:27]
Now a model file
[18:31]
that you want to run in a llama.
[18:33]
So we need to make one of those.
[18:34]
Now to do that we can make a new file
[18:37]
And then we're going to call this model
[18:39]
Just exactly like this with the capital
[18:44]
If we ls we can see it's here.
[18:46]
Now to edit this
[18:50]
And then I'm going to paste in
[18:54]
So it's going to say from dot slash.
[18:56]
And then this needs to be the name
[19:00]
So the local file
[19:02]
So I'm just going to copy the name
[19:03]
by going to rename copy
[19:06]
So we're going to say from dot slash
[19:10]
underscore mgg us again
[19:13]
So we're saying from this file right here
[19:17]
where this model file exists, then
[19:21]
So we can do the top
[19:24]
So user end of text.
[19:26]
Because that's the way
[19:28]
And then we have a template.
[19:29]
So the template is going to be user prompt
[19:33]
And then we just have a system message.
[19:35]
So if we want to tell the model
[19:37]
we can in this case
[19:41]
So this is a very simple model file.
[19:43]
This is how we're going to be able
[19:44]
to load in this particular model
[19:47]
So now we are going to save.
[19:49]
So I'm going to hit Ctrl x
[19:53]
Go ahead and press enter.
[19:54]
And now you can see
[19:56]
So nano model file.
[19:59]
It looks like this. Again
[20:01]
So now we have a model file
[20:05]
What we need to do is add this to a llama.
[20:07]
So in order to add this to a llama we're
[20:11]
And then we're going
[20:12]
So I'm going to say
[20:17]
And we're going to do dash f
[20:20]
What this is going to do
[20:21]
is add a new model configuration
[20:24]
So let's go ahead and press enter.
[20:27]
And now if we want to see if this is here
[20:30]
And we should see that we get the HTML
[20:34]
So now if we want to run the model
[20:38]
And then the name of this
[20:41]
It's going to take a second to load up.
[20:42]
And then we can paste
[20:44]
And we should see it working.
[20:46]
So let's go into our data set.
[20:47]
Let's just copy one of the ones
[20:50]
So let's copy this right here.
[20:53]
Go back and paste it okay
[20:55]
I just cleared the screen here
[20:58]
Then you can see after
[21:00]
This is the result that we got.
[21:02]
Now this isn't always going to work.
[21:04]
And you'll see now
[21:07]
That's because obviously
[21:10]
you know a pretty poor model.
[21:11]
Not one of the massive models,
[21:13]
but generally it is working
[21:16]
And more examples pass in.
[21:17]
This will give us a better output
[21:20]
This is a now custom fine tuned
[21:24]
locally on our own computer.
[21:25]
We could connect to it from Python or
[21:29]
And that is going to wrap up this video.
[21:31]
Now I know
[21:33]
You do need to experiment
[21:36]
But I wanted to show you how to do fine
[21:40]
and give you a step by step guide.
[21:42]
So hopefully this can get you up
[21:45]
All of the assets for this
[21:46]
video will be linked in the description
[21:49]
And with that said, I look forward