From the uDemy course on LLM engineering.
https://www.udemy.com/course/llm-engineering-master-ai-and-large-language-models
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
403 lines
9.8 KiB
403 lines
9.8 KiB
WEBVTT |
|
|
|
00:00.470 --> 00:01.040 |
|
All right. |
|
|
|
00:01.040 --> 00:02.750 |
|
Are you excited to see how this goes? |
|
|
|
00:02.780 --> 00:04.130 |
|
Let's give it a try. |
|
|
|
00:04.160 --> 00:12.890 |
|
So in this next section, I create a string called pi which has within it the code to do this series |
|
|
|
00:12.890 --> 00:15.890 |
|
one minus the third plus a fifth, minus the seventh plus a ninth. |
|
|
|
00:15.890 --> 00:17.420 |
|
You can see that for yourself. |
|
|
|
00:17.450 --> 00:18.770 |
|
Check how many mistakes. |
|
|
|
00:18.770 --> 00:23.690 |
|
And then it's going to do that 100 a million times. |
|
|
|
00:24.170 --> 00:28.640 |
|
And really it's like 200 million times because it's you can see each of this. |
|
|
|
00:28.670 --> 00:31.130 |
|
It's doing like two two elements in that series. |
|
|
|
00:31.130 --> 00:33.710 |
|
So it's 200 million of this series. |
|
|
|
00:33.710 --> 00:38.300 |
|
And we'll see how close to pi it gets and then it will print the result. |
|
|
|
00:38.570 --> 00:40.700 |
|
So let's do that. |
|
|
|
00:40.820 --> 00:46.700 |
|
I'm now going to do some some evil code, which of course we can do because we know exactly what we're |
|
|
|
00:46.700 --> 00:46.970 |
|
doing. |
|
|
|
00:46.970 --> 00:51.140 |
|
But you should always be slightly suspicious anytime someone says exac. |
|
|
|
00:51.170 --> 00:56.690 |
|
ExAC, of course, is the command that runs Python code as specified in a string. |
|
|
|
00:56.720 --> 01:02.820 |
|
And now you can see with some confidence this string is doing nothing to to evil. |
|
|
|
01:02.820 --> 01:04.350 |
|
It's just doing this series. |
|
|
|
01:04.350 --> 01:09.060 |
|
But you should always double check any time someone gives you code that involves an exec to make sure |
|
|
|
01:09.060 --> 01:13.200 |
|
there's no funny business with your file system, or making an internet connection or anything like |
|
|
|
01:13.200 --> 01:13.530 |
|
that. |
|
|
|
01:13.530 --> 01:17.820 |
|
But in this case, you can be assured this is pretty safe and let's give it a try. |
|
|
|
01:17.850 --> 01:18.600 |
|
Exact pi. |
|
|
|
01:18.630 --> 01:20.040 |
|
Let's see what happens. |
|
|
|
01:21.270 --> 01:23.400 |
|
So there's a pause. |
|
|
|
01:23.430 --> 01:27.570 |
|
While Python thinks 200 million of those terms. |
|
|
|
01:27.570 --> 01:28.500 |
|
And there we go. |
|
|
|
01:28.500 --> 01:31.080 |
|
So let's see how well the Pi comes out after that. |
|
|
|
01:31.080 --> 01:33.090 |
|
3.14159265. |
|
|
|
01:33.090 --> 01:34.650 |
|
And that digit is wrong. |
|
|
|
01:34.890 --> 01:39.960 |
|
So 200 million of these terms don't get you that much. |
|
|
|
01:39.960 --> 01:40.320 |
|
Pi. |
|
|
|
01:40.350 --> 01:45.570 |
|
As you probably you may know, there are much better series that converge very quickly, but they are |
|
|
|
01:45.570 --> 01:48.000 |
|
a lot more code and a lot more gumph. |
|
|
|
01:48.030 --> 01:51.840 |
|
This is the benefit of being super simple to write, but slowly converging. |
|
|
|
01:51.840 --> 01:57.870 |
|
So it took 8.5764 seconds for that to run. |
|
|
|
01:58.120 --> 02:01.870 |
|
There's a if you run this a few times, you'll see that that changes a fair amount because of other |
|
|
|
02:01.870 --> 02:03.100 |
|
things going on on the machine. |
|
|
|
02:03.100 --> 02:06.760 |
|
And your machine is different to mine, but you get the general idea. |
|
|
|
02:06.790 --> 02:07.390 |
|
Okay. |
|
|
|
02:07.420 --> 02:13.480 |
|
So I should be able to run optimize GPT pi, and it should stream out C plus plus code that will do |
|
|
|
02:13.480 --> 02:18.460 |
|
the same thing by sending that string as part of the user prompt to GPT four. |
|
|
|
02:18.490 --> 02:20.320 |
|
Oh, let's see what we get. |
|
|
|
02:20.740 --> 02:22.690 |
|
Uh, this is what I mentioned to you. |
|
|
|
02:22.690 --> 02:28.030 |
|
It puts this at the top of the file, which we then strip out before saving this to disk. |
|
|
|
02:28.060 --> 02:29.800 |
|
This is the method. |
|
|
|
02:29.920 --> 02:38.020 |
|
Uh, not uh, you may or may not be a C plus plus guru, but, uh, regardless, from knowledge of similar |
|
|
|
02:38.020 --> 02:42.370 |
|
things, you can probably get a good handle on the fact that this is doing the same thing. |
|
|
|
02:42.520 --> 02:48.460 |
|
Uh, and it's doing a similar number of calculations, similar number of terms, and it has written |
|
|
|
02:48.460 --> 02:50.740 |
|
a file here, optimized C plus plus. |
|
|
|
02:50.740 --> 02:52.390 |
|
And there it is. |
|
|
|
02:52.390 --> 02:54.040 |
|
You can see it all looks good. |
|
|
|
02:54.040 --> 03:00.470 |
|
And it has included this package that needs to be included, which is because it uses a set precision |
|
|
|
03:00.470 --> 03:01.370 |
|
function. |
|
|
|
03:01.370 --> 03:05.570 |
|
And if I discovered if I don't put that in the user prompt, then it doesn't include this package which |
|
|
|
03:05.570 --> 03:06.650 |
|
causes it to break. |
|
|
|
03:06.650 --> 03:07.910 |
|
So there we go. |
|
|
|
03:08.030 --> 03:10.790 |
|
For whatever it's worth, we've given it the hint and it's done it. |
|
|
|
03:11.330 --> 03:12.710 |
|
Um, okay. |
|
|
|
03:12.710 --> 03:14.090 |
|
So look at this next cell. |
|
|
|
03:14.090 --> 03:15.110 |
|
So this next cell. |
|
|
|
03:15.110 --> 03:23.330 |
|
You remember, if you do an exclamation mark in Jupyter, then it, uh, it will um, uh, it will run |
|
|
|
03:23.330 --> 03:25.010 |
|
that as a terminal command. |
|
|
|
03:25.010 --> 03:27.800 |
|
So what I'm doing here is a terminal command. |
|
|
|
03:27.800 --> 03:29.570 |
|
Uh clang++. |
|
|
|
03:29.570 --> 03:35.030 |
|
Uh, and this particular statement is running optimized. |
|
|
|
03:35.030 --> 03:39.740 |
|
It's doing a compile and then running that C plus plus code. |
|
|
|
03:39.980 --> 03:44.000 |
|
Um, and later we're going to use an even more optimized way of doing this. |
|
|
|
03:44.000 --> 03:47.750 |
|
But this this is a good for now for your computer. |
|
|
|
03:47.750 --> 03:51.350 |
|
You may want to Google what it will take to to compile. |
|
|
|
03:51.470 --> 03:57.690 |
|
Um, if you're using a mac, then you may need to um, Uh, at least open Xcode to make sure you've |
|
|
|
03:57.690 --> 04:02.070 |
|
got the latest Xcode tools installed so that you have the latest versions of compilers. |
|
|
|
04:02.190 --> 04:06.630 |
|
Um, but but regardless, a quick Google will tell you how you compile a C plus plus file. |
|
|
|
04:06.690 --> 04:12.360 |
|
Um, once you've changed this line to be an optimized C plus plus compile of the file optimized CPP, |
|
|
|
04:12.390 --> 04:14.370 |
|
that is of course how you will run it. |
|
|
|
04:14.370 --> 04:21.450 |
|
So remember what we are looking to beat is 8.57 seconds. |
|
|
|
04:21.450 --> 04:26.520 |
|
Let's see how GPT four zero how its code has done. |
|
|
|
04:26.520 --> 04:27.540 |
|
Here we go. |
|
|
|
04:29.280 --> 04:37.410 |
|
And it's got the same answer I should imagine 658 at least to within. |
|
|
|
04:37.440 --> 04:37.920 |
|
Yes. |
|
|
|
04:37.920 --> 04:38.550 |
|
Looks like it. |
|
|
|
04:38.550 --> 04:39.990 |
|
I mean you'd expect some. |
|
|
|
04:40.020 --> 04:42.300 |
|
Oh no it's there's not even any rounding differences. |
|
|
|
04:42.300 --> 04:44.310 |
|
It looks like it's exactly right. |
|
|
|
04:44.310 --> 04:47.520 |
|
And it's in a fraction of the time 0.21. |
|
|
|
04:47.610 --> 04:55.180 |
|
Uh, so it is clearly, uh, um, somewhere between 10 and 100 times faster. |
|
|
|
04:55.330 --> 04:58.810 |
|
You'll find later, when we optimize further, we can do even better than this. |
|
|
|
04:58.810 --> 04:59.020 |
|
But. |
|
|
|
04:59.020 --> 05:01.360 |
|
But with these flags, that is what we get. |
|
|
|
05:01.390 --> 05:02.980 |
|
It's pretty impressive. |
|
|
|
05:03.010 --> 05:10.990 |
|
We've just built something that can do a conversion of code from Python to C plus plus and run it many |
|
|
|
05:10.990 --> 05:12.550 |
|
times faster. |
|
|
|
05:12.580 --> 05:14.890 |
|
Let's see how Claude does. |
|
|
|
05:18.340 --> 05:21.220 |
|
Well, let's just quickly compare the code. |
|
|
|
05:22.960 --> 05:25.840 |
|
The code looks pretty similar to me. |
|
|
|
05:26.020 --> 05:29.260 |
|
Uh, you will find, if you look at it, that there are some subtle differences. |
|
|
|
05:29.260 --> 05:35.470 |
|
For example, there is this stuff here, um, which is to do with, uh. |
|
|
|
05:35.470 --> 05:41.740 |
|
Well, I am not a C plus plus expert, although I did code in C plus plus some time ago, 1 or 2 years |
|
|
|
05:41.740 --> 05:42.310 |
|
ago. |
|
|
|
05:42.460 --> 05:45.640 |
|
Uh, but, uh, sadly, that is all swapped out in my mind. |
|
|
|
05:45.670 --> 05:48.610 |
|
Uh, and I would certainly never have got to this level of expertise. |
|
|
|
05:48.610 --> 05:54.590 |
|
It's putting in, I believe, various hints to suggest that things can be parallelized, but I sort |
|
|
|
05:54.620 --> 06:00.080 |
|
of suspect with some of this stuff the compiler would apply that anyway in both cases, but we will |
|
|
|
06:00.080 --> 06:00.320 |
|
see. |
|
|
|
06:00.350 --> 06:07.820 |
|
We'll see if this actually makes any real difference by running the same command for. |
|
|
|
06:10.490 --> 06:11.780 |
|
Uh, sorry, did I run that? |
|
|
|
06:11.780 --> 06:12.620 |
|
Let's try that again. |
|
|
|
06:12.650 --> 06:13.520 |
|
Here we go. |
|
|
|
06:14.810 --> 06:17.630 |
|
And this is the answer that we got. |
|
|
|
06:17.810 --> 06:27.770 |
|
Um, and it looks like, um, I think we may have to go back and do. |
|
|
|
06:27.770 --> 06:28.100 |
|
Oh, no. |
|
|
|
06:28.100 --> 06:28.430 |
|
Here we go. |
|
|
|
06:28.460 --> 06:29.030 |
|
Here we go. |
|
|
|
06:29.030 --> 06:29.930 |
|
Sorry. |
|
|
|
06:29.930 --> 06:35.360 |
|
This was Gpg's version, so GPT was 0.2121. |
|
|
|
06:35.540 --> 06:38.510 |
|
And here I've jumped ahead. |
|
|
|
06:38.510 --> 06:39.470 |
|
That's why I'm getting confused. |
|
|
|
06:39.470 --> 06:40.040 |
|
Sorry. |
|
|
|
06:40.040 --> 06:41.720 |
|
Let's go back up again. |
|
|
|
06:42.260 --> 06:55.410 |
|
Uh, I'm going to have to write this down 0.2131 is GPT version and Claude's Version is in 0.2121. |
|
|
|
06:55.410 --> 06:58.500 |
|
So Claude was a hair faster than GPT. |
|
|
|
06:58.530 --> 07:02.340 |
|
But I gotta tell you, this is within in error bars. |
|
|
|
07:02.340 --> 07:05.640 |
|
If you run this a few times, it will vary by at least that amount. |
|
|
|
07:05.640 --> 07:12.570 |
|
So basically they've both produced code which when running on the machine, uh, has run at the same |
|
|
|
07:12.570 --> 07:12.990 |
|
speed. |
|
|
|
07:12.990 --> 07:19.140 |
|
I would expect that the actual compiled machine code is the same in both cases. |
|
|
|
07:19.290 --> 07:23.040 |
|
Um, which is what you would expect for a fairly simple problem. |
|
|
|
07:23.190 --> 07:32.040 |
|
Uh, so both GPT four and Claude have crushed it with a well optimized solution to this, uh, Python |
|
|
|
07:32.040 --> 07:33.540 |
|
code to generate pi. |
|
|
|
07:33.870 --> 07:39.810 |
|
Uh, but, um, uh, although, as I'll say, GPT four did need a few more hints than Claude, but they |
|
|
|
07:39.810 --> 07:42.120 |
|
both got there after the break. |
|
|
|
07:42.120 --> 07:48.300 |
|
We're going to move to a harder problem, much harder code to see how they can optimize. |
|
|
|
07:48.300 --> 07:50.220 |
|
I will see you in the next video.
|
|
|