CMU Advanced NLP 2024 (17) Code Generation/transcript.vtt

WEBVTT

00:00:00.480 --> 00:00:06.279
so uh I guess we can get started uh

00:00:04.080 --> 00:00:09.880
today I'm going to be talking about code

00:00:06.279 --> 00:00:11.719
generation and uh so this is a a

00:00:09.880 --> 00:00:13.599
research topic that I've uh worked on

00:00:11.719 --> 00:00:15.280
for a long time now I I like a lot it's

00:00:13.599 --> 00:00:17.520
become very useful nowadays which is

00:00:15.280 --> 00:00:20.960
very exciting um so I'd like to talk

00:00:17.520 --> 00:00:23.119
about kind of some of the basics and

00:00:20.960 --> 00:00:28.000
Frontiers uh that we're working on right

00:00:23.119 --> 00:00:28.000
now in this General uh area

00:00:31.719 --> 00:00:36.760
um

00:00:33.360 --> 00:00:38.160
so before I get into code generation

00:00:36.760 --> 00:00:40.719
specifically one thing I'd like to point

00:00:38.160 --> 00:00:43.399
out is for the next four or so classes

00:00:40.719 --> 00:00:45.680
I'm going to be talking about tasks and

00:00:43.399 --> 00:00:48.680
up until now I've been focusing on a lot

00:00:45.680 --> 00:00:52.840
of like General things that weren't as

00:00:48.680 --> 00:00:55.199
much about any specific tasks um

00:00:52.840 --> 00:00:57.000
and I know that not everybody's going to

00:00:55.199 --> 00:00:59.399
be interested in the four tasks that I'm

00:00:57.000 --> 00:01:00.960
talking about in the next you know four

00:00:59.399 --> 00:01:02.480
lectures

00:01:00.960 --> 00:01:04.920
um

00:01:02.480 --> 00:01:06.640
but I'm going to be covering various

00:01:04.920 --> 00:01:08.680
things about different tasks and

00:01:06.640 --> 00:01:10.640
hopefully you can map the same questions

00:01:08.680 --> 00:01:12.040
onto whatever task you are interested in

00:01:10.640 --> 00:01:14.360
if you're not interested in any of the

00:01:12.040 --> 00:01:15.880
ones I talk about here so basically what

00:01:14.360 --> 00:01:18.119
I want to talk about is the task

00:01:15.880 --> 00:01:21.040
objective like why do we do that task

00:01:18.119 --> 00:01:23.479
why is it important um what data sets

00:01:21.040 --> 00:01:26.560
can we use to train or test our models

00:01:23.479 --> 00:01:28.799
on these tasks evaluation metrics and

00:01:26.560 --> 00:01:31.200
how do we evaluate uh both manually and

00:01:28.799 --> 00:01:32.079
automatically with respect to how good

00:01:31.200 --> 00:01:34.960
we're

00:01:32.079 --> 00:01:37.880
doing and finally models and methods so

00:01:34.960 --> 00:01:40.720
you know how do we solve the

00:01:37.880 --> 00:01:42.479
problem and so for code generation first

00:01:40.720 --> 00:01:44.439
I'd like to talk about the overview and

00:01:42.479 --> 00:01:47.040
objectives of code generation so

00:01:44.439 --> 00:01:48.840
basically code generation is the task of

00:01:47.040 --> 00:01:52.439
generating executable code is an

00:01:48.840 --> 00:01:54.479
interface to uh a program or to

00:01:52.439 --> 00:01:58.320
computers and there's a lot of different

00:01:54.479 --> 00:02:01.000
ways we can do this um why do we want to

00:01:58.320 --> 00:02:03.159
do this so

00:02:01.000 --> 00:02:05.000
the first thing is that software

00:02:03.159 --> 00:02:06.759
engineering is really important and

00:02:05.000 --> 00:02:09.640
being able to generate code accelerate

00:02:06.759 --> 00:02:11.560
software engineering uh now code

00:02:09.640 --> 00:02:13.640
generation is practical and I hope that

00:02:11.560 --> 00:02:15.599
everybody in the class is using some

00:02:13.640 --> 00:02:17.840
sort of you know code generation to

00:02:15.599 --> 00:02:20.200
accelerate your own workflow if you're

00:02:17.840 --> 00:02:22.599
not I highly encourage you to to try it

00:02:20.200 --> 00:02:26.200
because it's very

00:02:22.599 --> 00:02:31.040
useful second it also does things like

00:02:26.200 --> 00:02:34.239
enabling models to access tools um

00:02:31.040 --> 00:02:37.440
and even if you're not specifically

00:02:34.239 --> 00:02:39.440
working on a software related task this

00:02:37.440 --> 00:02:41.000
can be helpful but I want to talk about

00:02:39.440 --> 00:02:42.480
this in a later class when we talk about

00:02:41.000 --> 00:02:46.640
llm agents so I'm not going to be

00:02:42.480 --> 00:02:48.319
talking about um that as much this time

00:02:46.640 --> 00:02:50.159
uh one other thing that I I forgot to

00:02:48.319 --> 00:02:52.920
mention here which I'm also going to

00:02:50.159 --> 00:02:55.000
talk about in the later class is even if

00:02:52.920 --> 00:02:58.120
you're not using code at all training on

00:02:55.000 --> 00:03:00.319
code has been shown to cause some

00:02:58.120 --> 00:03:01.920
benefits to learning models uh

00:03:00.319 --> 00:03:03.799
specifically with respect to learning

00:03:01.920 --> 00:03:06.480
like difficult multitask reasoning uh

00:03:03.799 --> 00:03:07.599
sorry multi-step reasoning tasks and so

00:03:06.480 --> 00:03:09.480
that's another reason why you might want

00:03:07.599 --> 00:03:10.840
to worry about codes so I'm going to

00:03:09.480 --> 00:03:12.840
mainly talk about the first one this

00:03:10.840 --> 00:03:14.560
time and leave the other two uh for

00:03:12.840 --> 00:03:17.720
future

00:03:14.560 --> 00:03:21.760
lectures so specifically for this task

00:03:17.720 --> 00:03:25.200
our input um is some sort of

00:03:21.760 --> 00:03:27.360
specification of what we want to do um

00:03:25.200 --> 00:03:30.319
and our output is going to be

00:03:27.360 --> 00:03:33.000
code so

00:03:30.319 --> 00:03:35.920
when you write a

00:03:33.000 --> 00:03:37.239
program how do you describe the thing

00:03:35.920 --> 00:03:40.239
that you want to implement in the

00:03:37.239 --> 00:03:42.000
program before you implement it like uh

00:03:40.239 --> 00:03:44.720
yeah what are some of the specifications

00:03:42.000 --> 00:03:44.720
that people can give

00:03:45.280 --> 00:03:50.720
you what the input and output of the

00:03:47.680 --> 00:03:52.360
functions are uh yes uh sorry what what

00:03:50.720 --> 00:03:54.400
types the inputs and outputs of the

00:03:52.360 --> 00:03:56.239
function are so those would be like type

00:03:54.400 --> 00:03:57.760
in in Python for example yeah that

00:03:56.239 --> 00:03:59.439
that's a good one it's actually not on

00:03:57.760 --> 00:04:02.079
my list of things here but it's it's a

00:03:59.439 --> 00:04:06.040
good Point yeah any any other things

00:04:02.079 --> 00:04:08.680
yeah complexity requirements complexity

00:04:06.040 --> 00:04:11.040
requirements constraints that is also

00:04:08.680 --> 00:04:14.840
not on my list of things here uh that's

00:04:11.040 --> 00:04:17.040
uh that's a good one too um and any uh

00:04:14.840 --> 00:04:20.280
slightly more straight forward

00:04:17.040 --> 00:04:24.040
things pseudo code yeah um in pseudo

00:04:20.280 --> 00:04:26.720
code uh what what is pseudo code written

00:04:24.040 --> 00:04:28.440
in natural natural language yeah so

00:04:26.720 --> 00:04:31.199
natural language inputs are are one

00:04:28.440 --> 00:04:34.520
thing so I will tell you I want I want a

00:04:31.199 --> 00:04:39.160
program that uh I want you to write a

00:04:34.520 --> 00:04:41.479
web interface that allows me to um order

00:04:39.160 --> 00:04:43.560
pizza or something like that that that

00:04:41.479 --> 00:04:46.560
would be one way to do it any other

00:04:43.560 --> 00:04:46.560
ideas

00:04:51.199 --> 00:04:55.840
yeah this is what I have and this is

00:04:53.360 --> 00:04:57.240
what I want yeah so um that's especially

00:04:55.840 --> 00:04:59.880
the case if you're like modifying a

00:04:57.240 --> 00:05:01.400
program um or something like that so

00:04:59.880 --> 00:05:06.280
actually the next one on my list there

00:05:01.400 --> 00:05:06.280
so good good point um any other

00:05:09.759 --> 00:05:15.720
ideas yeah or or a multimodal person you

00:05:12.880 --> 00:05:20.120
know I might say I want a pizza ordering

00:05:15.720 --> 00:05:22.039
I want a pizza ordering app and up here

00:05:20.120 --> 00:05:24.000
it should have your like username so you

00:05:22.039 --> 00:05:25.840
can click through the settings and like

00:05:24.000 --> 00:05:27.080
over here you should have the menu and

00:05:25.840 --> 00:05:28.680
over here you should have your check out

00:05:27.080 --> 00:05:30.400
card or something like that you know

00:05:28.680 --> 00:05:32.440
it's something you do for a programmer

00:05:30.400 --> 00:05:34.680
as well until recently we couldn't

00:05:32.440 --> 00:05:37.680
really use that with like actual models

00:05:34.680 --> 00:05:40.560
but um yeah yeah well that was my fourth

00:05:37.680 --> 00:05:42.639
one but um and then the other one uh

00:05:40.560 --> 00:05:44.960
inputs and outputs this could come in

00:05:42.639 --> 00:05:46.560
the form of like unit tests or something

00:05:44.960 --> 00:05:49.199
like that where it's like yeah this is

00:05:46.560 --> 00:05:51.160
the input this is the expected output so

00:05:49.199 --> 00:05:53.240
these are all things we use both as

00:05:51.160 --> 00:05:55.639
human programmers and in code generation

00:05:53.240 --> 00:05:58.120
models I really like the two other

00:05:55.639 --> 00:06:00.440
points though um

00:05:58.120 --> 00:06:03.759
because typin

00:06:00.440 --> 00:06:05.479
are actually something that you like

00:06:03.759 --> 00:06:06.599
writing writing with typ pints is

00:06:05.479 --> 00:06:09.240
actually something that you can do with

00:06:06.599 --> 00:06:14.120
code generation models and um

00:06:09.240 --> 00:06:16.680
constraints such as like it should it

00:06:14.120 --> 00:06:20.199
should meet certain speed requirements

00:06:16.680 --> 00:06:21.520
or it should um you know use certain

00:06:20.199 --> 00:06:22.960
libraries or something like that are

00:06:21.520 --> 00:06:24.840
also constraints that you could add I

00:06:22.960 --> 00:06:26.120
didn't put that on this slide here that

00:06:24.840 --> 00:06:28.319
might come in the natural language

00:06:26.120 --> 00:06:30.639
description but it could be something

00:06:28.319 --> 00:06:32.759
separate and then you know the output is

00:06:30.639 --> 00:06:36.759
whatever code you want

00:06:32.759 --> 00:06:38.240
to so um how many people are using like

00:06:36.759 --> 00:06:41.000
GitHub

00:06:38.240 --> 00:06:46.160
co-pilot like what

00:06:41.000 --> 00:06:47.759
percentage maybe about half okay um how

00:06:46.160 --> 00:06:49.840
many people are using another like

00:06:47.759 --> 00:06:56.080
assisted coding tool other than GitHub

00:06:49.840 --> 00:06:57.400
coet yeah g gp4 gp4 is an could be an

00:06:56.080 --> 00:06:58.680
assisted coding tool I'm talking more

00:06:57.400 --> 00:07:02.400
like something that's actually in your

00:06:58.680 --> 00:07:04.759
IDE something yeah anybody

00:07:02.400 --> 00:07:07.680
else does anyone use

00:07:04.759 --> 00:07:13.639
cursor no

00:07:07.680 --> 00:07:18.039
um yeah cursor yeah okay so

00:07:13.639 --> 00:07:20.919
yeah Co collab uh Ai and collab yeah so

00:07:18.039 --> 00:07:24.080
um so I think there are a lot of these

00:07:20.919 --> 00:07:26.879
uh going around I I use co-pilot myself

00:07:24.080 --> 00:07:28.639
I have not used cursor I do use GPD 4 um

00:07:26.879 --> 00:07:30.599
and I'll I'll show you an example of how

00:07:28.639 --> 00:07:32.919
I use them different

00:07:30.599 --> 00:07:34.360
um if you haven't used copilot hopefully

00:07:32.919 --> 00:07:39.599
this will

00:07:34.360 --> 00:07:42.599
work um I just made a a simple

00:07:39.599 --> 00:07:42.599
video

00:07:43.280 --> 00:07:49.520
oops okay that's not working but anyway

00:07:46.159 --> 00:07:51.000
you um you type your uh you know you

00:07:49.520 --> 00:07:54.319
type and it basically completes your

00:07:51.000 --> 00:07:56.639
code so this is this is an example here

00:07:54.319 --> 00:07:58.599
and I didn't write any of this code

00:07:56.639 --> 00:08:02.360
actually I just wrote the comments and

00:07:58.599 --> 00:08:04.000
then it filled in the the actual C and

00:08:02.360 --> 00:08:05.639
also I didn't exactly check if it's

00:08:04.000 --> 00:08:08.080
correct or not

00:08:05.639 --> 00:08:11.120
so if there's any mistake it's co

00:08:08.080 --> 00:08:15.159
Pilot's fault not my fault but um I it

00:08:11.120 --> 00:08:15.159
looked correct to me so

00:08:15.759 --> 00:08:21.120
um and oh by the way you get to use it

00:08:18.120 --> 00:08:22.800
for free with your CMU account so if you

00:08:21.120 --> 00:08:24.120
uh if you don't want to use it but don't

00:08:22.800 --> 00:08:25.919
want to pay for it you're and left

00:08:24.120 --> 00:08:31.639
because you can use

00:08:25.919 --> 00:08:36.320
it um another example uh is gd4 or uh

00:08:31.639 --> 00:08:38.519
more recently Cloud 3 um and basically

00:08:36.320 --> 00:08:40.680
this can do a different variety of

00:08:38.519 --> 00:08:43.719
things so we talked about screenshots

00:08:40.680 --> 00:08:45.720
and basically I asked Claude to create a

00:08:43.719 --> 00:08:48.399
react app that replicates the claw

00:08:45.720 --> 00:08:50.240
interface by giving it a screenshot and

00:08:48.399 --> 00:08:52.560
asking it create a react app that looks

00:08:50.240 --> 00:08:55.200
like the screenshot and then it gave me

00:08:52.560 --> 00:09:00.800
a whole bunch of text and in the end it

00:08:55.200 --> 00:09:03.320
started um making this uh container here

00:09:00.800 --> 00:09:08.040
um

00:09:03.320 --> 00:09:11.040
and this uh it basically is skipping

00:09:08.040 --> 00:09:12.800
some of the styling stuff uh because

00:09:11.040 --> 00:09:14.480
large language models I I think they're

00:09:12.800 --> 00:09:16.560
basically trained so that they don't

00:09:14.480 --> 00:09:19.959
give really really long responses

00:09:16.560 --> 00:09:21.320
because like if you uh asked for

00:09:19.959 --> 00:09:23.640
something that would take a really

00:09:21.320 --> 00:09:25.519
really long time and then the model just

00:09:23.640 --> 00:09:26.880
complied and gave that to you for a

00:09:25.519 --> 00:09:29.000
really really long time it would cost

00:09:26.880 --> 00:09:30.680
them a lot of money so I feel like they

00:09:29.000 --> 00:09:32.440
they B try to train the models to only

00:09:30.680 --> 00:09:37.160
out at like a thousand tokens at a time

00:09:32.440 --> 00:09:38.959
or something like that so um it it won't

00:09:37.160 --> 00:09:40.839
actually go out and program the whole

00:09:38.959 --> 00:09:43.120
project for you but with a little

00:09:40.839 --> 00:09:44.680
cajoling if you say okay now implement

00:09:43.120 --> 00:09:48.519
this part now implement this part now

00:09:44.680 --> 00:09:49.959
implement this part um you uh you can

00:09:48.519 --> 00:09:53.040
end up with some pretty interesting

00:09:49.959 --> 00:09:55.680
stuff and let me

00:09:53.040 --> 00:09:57.120
uh let me see if I can I can show you an

00:09:55.680 --> 00:10:01.320
example

00:09:57.120 --> 00:10:01.320
so I I know a little bit of

00:10:01.440 --> 00:10:07.040
react um the front end framework but I

00:10:04.240 --> 00:10:09.839
don't know a whole lot but recently

00:10:07.040 --> 00:10:14.279
we've been um working on an open-source

00:10:09.839 --> 00:10:18.959
assisted coding app and I most of this

00:10:14.279 --> 00:10:21.519
was just written by quad um it's uh I I

00:10:18.959 --> 00:10:23.079
said I want an app that on the left side

00:10:21.519 --> 00:10:26.160
it has a chat window and then on the

00:10:23.079 --> 00:10:28.240
right side it has three uh three panes

00:10:26.160 --> 00:10:30.120
one is a terminal one is a planner and

00:10:28.240 --> 00:10:32.200
one is a code editor

00:10:30.120 --> 00:10:33.880
and um so it gave me something it was

00:10:32.200 --> 00:10:37.399
kind of ugly so I said okay make the

00:10:33.880 --> 00:10:40.639
background black um change the CSS file

00:10:37.399 --> 00:10:43.639
so that um you have like a user icon and

00:10:40.639 --> 00:10:46.040
a robot icon and stuff like that and

00:10:43.639 --> 00:10:49.240
after this I I wrote very little of this

00:10:46.040 --> 00:10:51.079
code I wrote like 1% of this code or

00:10:49.240 --> 00:10:54.480
something like that and it's able to to

00:10:51.079 --> 00:10:57.880
do these sorts of things for you um so

00:10:54.480 --> 00:11:01.000
if you don't like writing front ends

00:10:57.880 --> 00:11:03.880
good luck uh or good good news that you

00:11:01.000 --> 00:11:05.560
uh can come up with a passable front end

00:11:03.880 --> 00:11:07.519
without uh without actually having to

00:11:05.560 --> 00:11:08.720
write it nonetheless you know good front

00:11:07.519 --> 00:11:10.200
end Engineers will come up with

00:11:08.720 --> 00:11:13.639
something much more beautiful than that

00:11:10.200 --> 00:11:15.880
so um so basically why do I why did I

00:11:13.639 --> 00:11:19.959
want to say this I think um GitHub

00:11:15.880 --> 00:11:20.839
co-pilot and Pla or gp4 serve very

00:11:19.959 --> 00:11:25.200
different

00:11:20.839 --> 00:11:27.360
purposes um GitHub co-pilot is code

00:11:25.200 --> 00:11:30.160
completion and it mostly works for

00:11:27.360 --> 00:11:32.440
shorter things so it's like your next

00:11:30.160 --> 00:11:34.760
thought in your code in code that you

00:11:32.440 --> 00:11:37.560
know pretty well something like plot or

00:11:34.760 --> 00:11:40.639
gp4 is much better for really long

00:11:37.560 --> 00:11:44.680
things um where you want to build like a

00:11:40.639 --> 00:11:47.040
full class or something like that and I

00:11:44.680 --> 00:11:48.480
also have found that if you're coding in

00:11:47.040 --> 00:11:50.079
a language that you're very familiar

00:11:48.480 --> 00:11:51.560
with copilot might be more useful

00:11:50.079 --> 00:11:52.959
because you want fine grain control and

00:11:51.560 --> 00:11:55.040
you want it to fill out things to make

00:11:52.959 --> 00:11:56.519
it faster whereas if you're coding in a

00:11:55.040 --> 00:11:58.040
language that you're not very familiar

00:11:56.519 --> 00:11:59.680
with something like Claud is good

00:11:58.040 --> 00:12:01.839
because you can write a whole you know

00:11:59.680 --> 00:12:04.800
program forties so these are the

00:12:01.839 --> 00:12:07.680
differences another thing is GitHub

00:12:04.800 --> 00:12:09.240
co-pilot needs to be frighteningly fast

00:12:07.680 --> 00:12:10.839
because it needs to move at the speed

00:12:09.240 --> 00:12:12.880
that like programmers are thinking in

00:12:10.839 --> 00:12:14.920
programming next whereas something like

00:12:12.880 --> 00:12:16.800
Claud it doesn't you know using it in

00:12:14.920 --> 00:12:18.880
the way that I use cloud here doesn't

00:12:16.800 --> 00:12:22.600
really matter because I can say uh

00:12:18.880 --> 00:12:24.079
programing me a you know a web app and

00:12:22.600 --> 00:12:25.360
then I can go and have dinner and come

00:12:24.079 --> 00:12:28.199
back and have a web app and I'd be

00:12:25.360 --> 00:12:31.720
perfectly happy with that right so um

00:12:28.199 --> 00:12:37.199
the latency request are also

00:12:31.720 --> 00:12:37.199
different cool um any any questions here

00:12:37.399 --> 00:12:42.600
yeah that debugging code they

00:12:43.000 --> 00:12:47.959
are the well so

00:12:45.839 --> 00:12:50.760
co-pilot I haven't actually tried it

00:12:47.959 --> 00:12:52.480
that much um if I wanted to debug code

00:12:50.760 --> 00:12:54.880
I'd probably use something like pla or

00:12:52.480 --> 00:12:56.360
gp4 just because actually I'll I'll

00:12:54.880 --> 00:12:58.320
mention this in a second but co-pilot's

00:12:56.360 --> 00:13:00.360
a much smaller model uh because it needs

00:12:58.320 --> 00:13:01.839
to be very fast or what they're using in

00:13:00.360 --> 00:13:04.040
copilot is a smaller model because it

00:13:01.839 --> 00:13:05.519
needs to be very fast so I would

00:13:04.040 --> 00:13:08.360
probably use a bigger model for anything

00:13:05.519 --> 00:13:10.120
that required like good understanding I

00:13:08.360 --> 00:13:11.480
think it's passable at debugging code

00:13:10.120 --> 00:13:13.079
but it won't find the really difficult

00:13:11.480 --> 00:13:15.639
things and it probably won't find things

00:13:13.079 --> 00:13:18.279
that require spanning across uh multiple

00:13:15.639 --> 00:13:21.240
files but I I'm not 100% sure about that

00:13:18.279 --> 00:13:25.519
like I think it's worth

00:13:21.240 --> 00:13:25.519
testing um any other

00:13:25.880 --> 00:13:30.120
questions okay so if I haven't convinced

00:13:28.360 --> 00:13:32.360
you that as software developers you

00:13:30.120 --> 00:13:34.880
should be using this hopefully this next

00:13:32.360 --> 00:13:37.480
uh this next slide will so this was a

00:13:34.880 --> 00:13:41.199
study that was run by GitHub uh shortly

00:13:37.480 --> 00:13:43.160
after um after co-pilot came out and so

00:13:41.199 --> 00:13:45.440
why do we do code generation why are

00:13:43.160 --> 00:13:47.240
people very excited about it so the

00:13:45.440 --> 00:13:50.240
first is U making software isn't

00:13:47.240 --> 00:13:53.480
important um and I recently calculated

00:13:50.240 --> 00:13:55.920
what from some Labor Statistics and the

00:13:53.480 --> 00:13:59.440
total amount that software developers

00:13:55.920 --> 00:14:01.880
make um in a year is $175 billion so

00:13:59.440 --> 00:14:05.000
that's providing at least that much you

00:14:01.880 --> 00:14:06.800
know value so it's a very high value uh

00:14:05.000 --> 00:14:09.079
profession so if we could make it faster

00:14:06.800 --> 00:14:11.480
you know it would have even more

00:14:09.079 --> 00:14:12.920
value another thing is code generation

00:14:11.480 --> 00:14:15.680
leads to large improvements in

00:14:12.920 --> 00:14:17.160
productivity so uh get Hub ran this

00:14:15.680 --> 00:14:18.680
study where they randomly assigned

00:14:17.160 --> 00:14:21.519
developers to groups who would either

00:14:18.680 --> 00:14:24.440
use co-pilot or not use co-pilot and

00:14:21.519 --> 00:14:26.480
they assigned them the same task and

00:14:24.440 --> 00:14:30.759
basically the people who use copilot

00:14:26.480 --> 00:14:34.199
their rate of um completion went up by

00:14:30.759 --> 00:14:36.320
8% and they finished um in about 40% of

00:14:34.199 --> 00:14:39.279
the time of the people who didn't use it

00:14:36.320 --> 00:14:43.639
and so I think this

00:14:39.279 --> 00:14:45.920
is or uh yeah they say 55% less times so

00:14:43.639 --> 00:14:47.759
this is very impressive but it's also

00:14:45.920 --> 00:14:50.199
not at all surprising if you're using a

00:14:47.759 --> 00:14:52.880
Cod like assisted coding assistant it

00:14:50.199 --> 00:14:54.360
just makes you code faster also if you

00:14:52.880 --> 00:14:56.040
don't like writing doc strings it's

00:14:54.360 --> 00:14:57.519
really good at writing doc strings so

00:14:56.040 --> 00:14:59.680
you can write documentation for your

00:14:57.519 --> 00:15:00.759
code not wor about so

00:14:59.680 --> 00:15:04.399
okay

00:15:00.759 --> 00:15:07.000
cool um

00:15:04.399 --> 00:15:09.720
so there are differences between code

00:15:07.000 --> 00:15:14.000
and natural language uh and I've listed

00:15:09.720 --> 00:15:15.560
a few of them here and the differences

00:15:14.000 --> 00:15:18.120
between code and natural language also

00:15:15.560 --> 00:15:20.160
affect how we build models for this test

00:15:18.120 --> 00:15:23.160
so the first one is that code has strict

00:15:20.160 --> 00:15:26.000
grammar uh if you make a small mistake

00:15:23.160 --> 00:15:27.920
in your code grammar usually it will

00:15:26.000 --> 00:15:29.839
just break and your program won't work

00:15:27.920 --> 00:15:31.319
so you need to be very careful as

00:15:29.839 --> 00:15:32.560
opposed to natural language grammar

00:15:31.319 --> 00:15:33.600
where you can make small mistakes and it

00:15:32.560 --> 00:15:36.120
doesn't make a

00:15:33.600 --> 00:15:40.120
difference another thing is in code you

00:15:36.120 --> 00:15:42.720
know the semantic flow of the code and

00:15:40.120 --> 00:15:44.160
so we know that certain variables

00:15:42.720 --> 00:15:45.560
correspond to each other we know that

00:15:44.160 --> 00:15:48.639
they're flowing through the program in a

00:15:45.560 --> 00:15:50.880
certain way another thing is code is

00:15:48.639 --> 00:15:54.120
executable so we can actually execute it

00:15:50.880 --> 00:15:56.199
and observe the result unlike in natural

00:15:54.120 --> 00:16:00.000
language and another important thing is

00:15:56.199 --> 00:16:03.399
code is created incrementally so code is

00:16:00.000 --> 00:16:05.680
not you know unlike text text is also

00:16:03.399 --> 00:16:07.399
created incrementally but it's not

00:16:05.680 --> 00:16:08.720
usually you write it once you might

00:16:07.399 --> 00:16:11.199
revise it a little bit and then you're

00:16:08.720 --> 00:16:14.040
done and you you don't need to touch it

00:16:11.199 --> 00:16:15.399
again but um in code you touch it over

00:16:14.040 --> 00:16:17.800
and over and over again as you develop a

00:16:15.399 --> 00:16:17.800
sof

00:16:18.040 --> 00:16:23.040
project so if we look at code Generation

00:16:21.079 --> 00:16:27.079
Um I would like to talk a little bit

00:16:23.040 --> 00:16:29.079
about uh subtasks and data sets next so

00:16:27.079 --> 00:16:30.480
the most famous data set for a Cod code

00:16:29.079 --> 00:16:34.279
generation nowadays is something called

00:16:30.480 --> 00:16:38.680
human ofel um this is a very nice data

00:16:34.279 --> 00:16:42.480
set um for a number of reasons uh I

00:16:38.680 --> 00:16:44.240
think it is used too much um nonetheless

00:16:42.480 --> 00:16:46.759
and I I think there are better data sets

00:16:44.240 --> 00:16:51.240
that we maybe should be using more but

00:16:46.759 --> 00:16:54.000
basically human ofel is um it has

00:16:51.240 --> 00:16:55.920
examples of usage of the Python standard

00:16:54.000 --> 00:16:59.360
Library where some are easier some are

00:16:55.920 --> 00:17:02.880
harder and just to give some examples

00:16:59.360 --> 00:17:06.760
uh we're saying given a nonempty list of

00:17:02.880 --> 00:17:10.480
integers return the sum of all the odd

00:17:06.760 --> 00:17:12.959
elements that are in even positions so

00:17:10.480 --> 00:17:16.079
it's kind of like a elite code

00:17:12.959 --> 00:17:19.199
style you know program but maybe one of

00:17:16.079 --> 00:17:22.400
the easier ones and then in order to

00:17:19.199 --> 00:17:25.240
solve that you find all of the put

00:17:22.400 --> 00:17:28.480
elements in even positions and then you

00:17:25.240 --> 00:17:29.679
only return them if uh the value itself

00:17:28.480 --> 00:17:32.799
is

00:17:29.679 --> 00:17:34.200
um so like you can do that in a oneliner

00:17:32.799 --> 00:17:36.600
but you need to think about it a little

00:17:34.200 --> 00:17:38.919
bit um and then you have

00:17:36.600 --> 00:17:43.120
more

00:17:38.919 --> 00:17:43.810
um returns encoded uh sorry takes an

00:17:43.120 --> 00:17:46.910
input

00:17:43.810 --> 00:17:46.910
[Music]

00:17:47.160 --> 00:17:50.919
string yeah actually sorry this is from

00:17:49.320 --> 00:17:53.600
the paper I didn't read it before I copy

00:17:50.919 --> 00:17:57.080
pasted it in here but um yeah that's a

00:17:53.600 --> 00:17:58.880
decoding one and one one thing about

00:17:57.080 --> 00:18:02.240
this uh that's important to know is it

00:17:58.880 --> 00:18:04.200
only has 164 examples so it's actually a

00:18:02.240 --> 00:18:07.600
relatively small number of

00:18:04.200 --> 00:18:09.440
examples um it's also just the python

00:18:07.600 --> 00:18:11.200
standard Library so it's not testing

00:18:09.440 --> 00:18:14.960
usage of any other

00:18:11.200 --> 00:18:17.520
libraries um so these two things

00:18:14.960 --> 00:18:19.720
together make it not the most realistic

00:18:17.520 --> 00:18:21.880
you know examination of your programming

00:18:19.720 --> 00:18:23.640
skills just like leak code is not the

00:18:21.880 --> 00:18:25.640
most realistic examination of your

00:18:23.640 --> 00:18:28.240
programming skills but you know I don't

00:18:25.640 --> 00:18:31.720
know companies use it anyway so maybe

00:18:28.240 --> 00:18:35.159
human devel is reasonable but um so then

00:18:31.720 --> 00:18:37.120
we go um into the inputs and outputs uh

00:18:35.159 --> 00:18:40.679
the inputs and outputs usually include a

00:18:37.120 --> 00:18:43.440
doc string um some input and output

00:18:40.679 --> 00:18:47.640
examples and then they have tests to

00:18:43.440 --> 00:18:47.640
verify the accuracy of your

00:18:47.880 --> 00:18:52.840
outputs so the metric that's used to

00:18:50.559 --> 00:18:58.919
evaluate these systems is something

00:18:52.840 --> 00:19:01.400
called passet K and the basic idea is um

00:18:58.919 --> 00:19:03.400
we generate K examples will at least one

00:19:01.400 --> 00:19:06.960
of them pass the unit

00:19:03.400 --> 00:19:10.720
tests and the idea here is

00:19:06.960 --> 00:19:13.480
that if we have models we might want to

00:19:10.720 --> 00:19:14.960
generate like well there there's a

00:19:13.480 --> 00:19:17.480
couple reasons why we would care about

00:19:14.960 --> 00:19:19.880
this pass it one is kind of obvious

00:19:17.480 --> 00:19:23.200
because we generate one and then we

00:19:19.880 --> 00:19:26.480
measure how um you know how likely it is

00:19:23.200 --> 00:19:29.280
to pass unit tests but pass it five why

00:19:26.480 --> 00:19:30.760
would we care about passet five well

00:19:29.280 --> 00:19:32.159
number one maybe you could show five

00:19:30.760 --> 00:19:34.240
programs to a person and they could

00:19:32.159 --> 00:19:37.039
choose the one that they like the best

00:19:34.240 --> 00:19:39.919
or maybe you could have unit test write

00:19:37.039 --> 00:19:41.720
unit tests in advance and then generate

00:19:39.919 --> 00:19:43.880
five programs check which one pass the

00:19:41.720 --> 00:19:45.480
unit tests and then use the ones only

00:19:43.880 --> 00:19:48.360
that pass the unit test or something

00:19:45.480 --> 00:19:51.000
like that so there's also some interest

00:19:48.360 --> 00:19:53.320
in uh whether you could generate you

00:19:51.000 --> 00:19:54.600
know multiple examples and then pick a

00:19:53.320 --> 00:19:56.919
good

00:19:54.600 --> 00:19:59.080
one there's a little bit of nuance in

00:19:56.919 --> 00:20:02.120
how this is actually calculated so

00:19:59.080 --> 00:20:04.240
basically um if you generate only K like

00:20:02.120 --> 00:20:05.960
if you if you sample only one example

00:20:04.240 --> 00:20:07.400
there's a lot of variance in whether you

00:20:05.960 --> 00:20:10.159
get it right or not so what they

00:20:07.400 --> 00:20:13.440
actually do is they generate like 10

00:20:10.159 --> 00:20:15.600
outputs or 200 outputs and then they

00:20:13.440 --> 00:20:18.159
calculate the expected number of those

00:20:15.600 --> 00:20:20.320
that the expected number of cases where

00:20:18.159 --> 00:20:23.280
that would pass by just doing a little

00:20:20.320 --> 00:20:25.440
bit of uh like math calculating the

00:20:23.280 --> 00:20:28.679
number of combinations where one passes

00:20:25.440 --> 00:20:30.720
or one doesn't and here k n is the total

00:20:28.679 --> 00:20:34.240
number you generate C is the number of

00:20:30.720 --> 00:20:36.520
correct ansers and K is uh your passive

00:20:34.240 --> 00:20:36.520
K

00:20:37.159 --> 00:20:43.360
value

00:20:38.919 --> 00:20:46.280
cool um so any any questions about

00:20:43.360 --> 00:20:47.880
these you'll you'll see a bunch of uh

00:20:46.280 --> 00:20:50.520
people evaluating on this human ofel

00:20:47.880 --> 00:20:52.760
with passive K including all of the you

00:20:50.520 --> 00:20:57.520
know new llms that come out it's a very

00:20:52.760 --> 00:20:57.520
standard Edge yeah

00:21:01.760 --> 00:21:06.039
is yeah that that's a good um question I

00:21:04.919 --> 00:21:07.840
think I'm going to cover that a little

00:21:06.039 --> 00:21:11.039
bit later but I might as well say it now

00:21:07.840 --> 00:21:13.640
so llms

00:21:11.039 --> 00:21:15.080
are llms are good at code because they

00:21:13.640 --> 00:21:16.880
intentionally include a lot of code

00:21:15.080 --> 00:21:19.520
training data in LL training and the

00:21:16.880 --> 00:21:22.679
reason for that is twofold um the first

00:21:19.520 --> 00:21:25.320
one is that code generation is a huge

00:21:22.679 --> 00:21:26.960
application of llms right now and like

00:21:25.320 --> 00:21:28.679
if you had an llm that couldn't do code

00:21:26.960 --> 00:21:32.320
generation it'd be kind of embarrassing

00:21:28.679 --> 00:21:33.960
so um Everybody includes this number two

00:21:32.320 --> 00:21:36.600
uh code has been shown to improve kind

00:21:33.960 --> 00:21:38.080
of the reasoning abilities of llms and

00:21:36.600 --> 00:21:41.640
because of that people include code for

00:21:38.080 --> 00:21:43.440
that purpose so yeah um it's not that

00:21:41.640 --> 00:21:45.600
LMS are inherently good at code or

00:21:43.440 --> 00:21:48.840
anything it's that they have lots of

00:21:45.600 --> 00:21:51.640
lots of code TR and I'll I'll explain

00:21:48.840 --> 00:21:54.279
exactly how they construct this

00:21:51.640 --> 00:21:57.200
St and actually if you remember last

00:21:54.279 --> 00:21:59.640
time uh I talked about the pile which

00:21:57.200 --> 00:22:01.039
was or not last time but uh when I

00:21:59.640 --> 00:22:03.159
talked about the tour of large language

00:22:01.039 --> 00:22:06.360
models I talked about the pile and the

00:22:03.159 --> 00:22:09.799
pile is almost half toe for

00:22:06.360 --> 00:22:12.000
example cool any other

00:22:09.799 --> 00:22:17.240
questions

00:22:12.000 --> 00:22:19.320
okay so another uh a first Improvement

00:22:17.240 --> 00:22:22.080
or at least change that we can make to

00:22:19.320 --> 00:22:23.880
human ofel is uh going to broader

00:22:22.080 --> 00:22:26.720
domains and covering a broader variety

00:22:23.880 --> 00:22:28.559
of libraries and this is a data set that

00:22:26.720 --> 00:22:30.880
we created actually a long time ago but

00:22:28.559 --> 00:22:33.799
but we recently added execution based

00:22:30.880 --> 00:22:36.159
evaluation to it it's called konola and

00:22:33.799 --> 00:22:36.919
the execution based uh evaluation one is

00:22:36.159 --> 00:22:40.360
called

00:22:36.919 --> 00:22:43.039
odex and basically what we did here is

00:22:40.360 --> 00:22:45.720
we scraped data from stack Overflow

00:22:43.039 --> 00:22:48.039
including uh inputs and output uh

00:22:45.720 --> 00:22:50.559
Solutions and then based on this scraped

00:22:48.039 --> 00:22:54.240
data we uh did some manual curation to

00:22:50.559 --> 00:22:57.640
turn these into like actual questions um

00:22:54.240 --> 00:22:59.640
and answers about how you could write uh

00:22:57.640 --> 00:23:01.799
solve programming

00:22:59.640 --> 00:23:04.080
problems and

00:23:01.799 --> 00:23:05.600
um because this is scraped from stack

00:23:04.080 --> 00:23:09.159
Overflow there's no restriction that

00:23:05.600 --> 00:23:10.520
this is from the python standard Library

00:23:09.159 --> 00:23:13.200
which also means that it can cover a

00:23:10.520 --> 00:23:14.919
very wide variety of libraries and it's

00:23:13.200 --> 00:23:16.760
approximately according to the

00:23:14.919 --> 00:23:20.320
popularity of the libraries because we

00:23:16.760 --> 00:23:24.159
took popular posts so um that's a a good

00:23:20.320 --> 00:23:25.400
thing uh you know it it is a reasonable

00:23:24.159 --> 00:23:26.559
way to come up with a realistic

00:23:25.400 --> 00:23:29.520
distribution of libraries that you

00:23:26.559 --> 00:23:31.799
should be looking at um odex adds

00:23:29.520 --> 00:23:34.159
execution based evaluation previously

00:23:31.799 --> 00:23:36.679
what we had was we only had the snippet

00:23:34.159 --> 00:23:40.600
that was able to solve the problem as

00:23:36.679 --> 00:23:42.360
opposed to um as opposed to being able

00:23:40.600 --> 00:23:46.880
to execute unit

00:23:42.360 --> 00:23:49.440
tests and just to show how this has a

00:23:46.880 --> 00:23:52.000
broader variety of libraries on the top

00:23:49.440 --> 00:23:53.919
we have the distribution of odex

00:23:52.000 --> 00:23:57.320
libraries and we can see about half of

00:23:53.919 --> 00:23:59.600
them use libraries and this includes a

00:23:57.320 --> 00:24:01.279
variety of things including pandas

00:23:59.600 --> 00:24:04.799
numpy

00:24:01.279 --> 00:24:06.400
um reg o selections you know all of

00:24:04.799 --> 00:24:09.279
these should be libraries that look

00:24:06.400 --> 00:24:14.559
familiar to you um in contrast if we

00:24:09.279 --> 00:24:17.200
look at human eval human eval is right

00:24:14.559 --> 00:24:18.840
here so you can see almost all of the

00:24:17.200 --> 00:24:20.600
questions require no libraries and all

00:24:18.840 --> 00:24:22.120
of the other ones require libraries that

00:24:20.600 --> 00:24:24.360
were included in the pipe onstead

00:24:22.120 --> 00:24:27.640
libraries so

00:24:24.360 --> 00:24:29.120
um in reality this is probably more what

00:24:27.640 --> 00:24:30.120
your program in queries are going to

00:24:29.120 --> 00:24:31.240
look like they're not going to look like

00:24:30.120 --> 00:24:33.600
lead code they're going to look like

00:24:31.240 --> 00:24:33.600
using

00:24:35.360 --> 00:24:42.080
APS so um originally when we did conal

00:24:40.039 --> 00:24:44.200
we didn't use execution based evaluation

00:24:42.080 --> 00:24:47.480
because creating unit tests uh for lots

00:24:44.200 --> 00:24:51.360
of stack Overflow posts is hard

00:24:47.480 --> 00:24:53.640
um specifically there's two issues the

00:24:51.360 --> 00:24:55.000
first one is that it requires that code

00:24:53.640 --> 00:24:58.880
be easily

00:24:55.000 --> 00:25:02.320
executable um now think about

00:24:58.880 --> 00:25:04.559
how you would do that for Matt plot lib

00:25:02.320 --> 00:25:06.200
for example how would you create a unit

00:25:04.559 --> 00:25:08.080
test to test whether Matt plot lib

00:25:06.200 --> 00:25:10.760
successfully created a bar chart for

00:25:08.080 --> 00:25:12.440
something it's kind of tough right you

00:25:10.760 --> 00:25:13.840
like you would have to get the image and

00:25:12.440 --> 00:25:16.919
you'd have to confirm that the image was

00:25:13.840 --> 00:25:21.200
a bar chart and uh other things like

00:25:16.919 --> 00:25:22.720
that um even worse what if it was uh

00:25:21.200 --> 00:25:25.600
kind of like a server framework like

00:25:22.720 --> 00:25:27.440
ajango how would you confirm that ajango

00:25:25.600 --> 00:25:30.559
you know server is working appropriately

00:25:27.440 --> 00:25:32.600
and that's kind of tricky so um actually

00:25:30.559 --> 00:25:34.480
coming up with realistic unit tests for

00:25:32.600 --> 00:25:36.919
real programs can be

00:25:34.480 --> 00:25:38.840
difficult um another problem with

00:25:36.919 --> 00:25:41.640
execution based evaluation is it ignores

00:25:38.840 --> 00:25:45.320
stylistic considerations so I could

00:25:41.640 --> 00:25:48.279
write very spaghetti like very spaghetti

00:25:45.320 --> 00:25:50.200
code and as long as it executed properly

00:25:48.279 --> 00:25:52.559
it would still be judged as correct and

00:25:50.200 --> 00:25:54.399
sometimes that's actually an issue so

00:25:52.559 --> 00:25:56.360
usually it's not a problem because

00:25:54.399 --> 00:25:58.600
language models write reasonably good

00:25:56.360 --> 00:26:00.600
code but sometimes you want to match the

00:25:58.600 --> 00:26:05.039
or other things like that

00:26:00.600 --> 00:26:06.559
so some alternatives are blue score

00:26:05.039 --> 00:26:09.000
which we've talked about before it's

00:26:06.559 --> 00:26:12.679
basically count calculating the engram

00:26:09.000 --> 00:26:16.919
overlap between a gold standard human uh

00:26:12.679 --> 00:26:20.440
implementation and a uh in the system

00:26:16.919 --> 00:26:24.000
output and there's also specifically

00:26:20.440 --> 00:26:26.480
adapted methods for evaluating code and

00:26:24.000 --> 00:26:29.080
so there's a method called code blue and

00:26:26.480 --> 00:26:31.360
basically the way code blue works is it

00:26:29.080 --> 00:26:35.240
also considers the syntax and semantic

00:26:31.360 --> 00:26:37.080
flow of the code so it measures overlap

00:26:35.240 --> 00:26:40.120
between

00:26:37.080 --> 00:26:42.120
strings in the original code but it also

00:26:40.120 --> 00:26:48.640
considers overlap between the syntax

00:26:42.120 --> 00:26:53.000
trees of the code and uh whether the

00:26:48.640 --> 00:26:56.320
um these like semantic information flow

00:26:53.000 --> 00:26:57.919
graphs look similar so uh all all of

00:26:56.320 --> 00:26:59.440
these things work together to calculate

00:26:57.919 --> 00:27:02.720
the C

00:26:59.440 --> 00:27:04.480
St one thing I I should mention is how

00:27:02.720 --> 00:27:06.840
do we get these syntax trees in the

00:27:04.480 --> 00:27:09.039
first place um for example if we're

00:27:06.840 --> 00:27:12.919
talking about python there's a python

00:27:09.039 --> 00:27:14.760
Library uh for ab abstract syntax tree

00:27:12.919 --> 00:27:16.559
it's just part of the standard library

00:27:14.760 --> 00:27:18.320
and it's necessary to run the python

00:27:16.559 --> 00:27:20.559
interpreter so you can just get these

00:27:18.320 --> 00:27:24.320
trees directly from the python ASD

00:27:20.559 --> 00:27:25.880
Library uh not hard to do uh for this I

00:27:24.320 --> 00:27:27.840
forget what they did in the code blue

00:27:25.880 --> 00:27:30.679
thing but there are uh analyzers that

00:27:27.840 --> 00:27:32.120
allow you to analyze this control FL so

00:27:30.679 --> 00:27:34.159
this is taking advantage of the fact

00:27:32.120 --> 00:27:37.440
that code is you know predictable it has

00:27:34.159 --> 00:27:41.480
predictable syntax and you can you

00:27:37.440 --> 00:27:43.960
can6 um one disadvantage of blue and

00:27:41.480 --> 00:27:45.799
code blue of course is that you know you

00:27:43.960 --> 00:27:47.679
can write two very different looking

00:27:45.799 --> 00:27:49.559
programs that actually are both correct

00:27:47.679 --> 00:27:51.799
and blue will underestimate the goodness

00:27:49.559 --> 00:27:54.440
of those programs so maybe using both of

00:27:51.799 --> 00:27:57.159
them together is uh is

00:27:54.440 --> 00:28:00.120
appropriate uh if if you can write unit

00:27:57.159 --> 00:28:00.120
Test please

00:28:00.559 --> 00:28:04.279
um another one which I'll just cover

00:28:02.600 --> 00:28:05.399
very briefly we talked about BT score

00:28:04.279 --> 00:28:08.159
before when I was talking about

00:28:05.399 --> 00:28:11.120
evaluation of uh you know generated text

00:28:08.159 --> 00:28:13.480
and there's also code BT score which um

00:28:11.120 --> 00:28:15.799
we uh we created here at

00:28:13.480 --> 00:28:20.080
CMU and it's basically an embedding

00:28:15.799 --> 00:28:21.760
based metric uh to compare code and so

00:28:20.080 --> 00:28:23.399
Bert score if you remember basically

00:28:21.760 --> 00:28:25.679
what it did is it calculated the coign

00:28:23.399 --> 00:28:27.840
similarity between each of the tokens uh

00:28:25.679 --> 00:28:30.159
between a generated text and a reference

00:28:27.840 --> 00:28:34.279
text we do exactly the same thing for

00:28:30.159 --> 00:28:36.080
code um so we calculate the Sim cosine

00:28:34.279 --> 00:28:39.200
similarity between tokens for a

00:28:36.080 --> 00:28:42.960
reference code and generated

00:28:39.200 --> 00:28:45.000
code and we released a model called

00:28:42.960 --> 00:28:46.559
codir which was basically Bert but

00:28:45.000 --> 00:28:49.440
continued trained on lots and lots of

00:28:46.559 --> 00:28:51.840
code uh that allowed us to do that and

00:28:49.440 --> 00:28:55.480
um basically we were able to demonstrate

00:28:51.840 --> 00:28:59.200
that this gave better correlation both

00:28:55.480 --> 00:29:01.480
with final execution accuracy and with

00:28:59.200 --> 00:29:05.200
human judgments of whether the the code

00:29:01.480 --> 00:29:08.000
was correct and so um some people uh

00:29:05.200 --> 00:29:09.559
created a data set of human correctness

00:29:08.000 --> 00:29:12.559
judgments and we were able to put a

00:29:09.559 --> 00:29:14.240
little better with that as well um why

00:29:12.559 --> 00:29:15.640
do we care about correlation with

00:29:14.240 --> 00:29:17.399
execution

00:29:15.640 --> 00:29:20.200
accuracy

00:29:17.399 --> 00:29:22.320
um this is important in the cases when

00:29:20.200 --> 00:29:23.559
we can't create unit tests or when

00:29:22.320 --> 00:29:26.120
creating unit test would be too

00:29:23.559 --> 00:29:27.519
expensive so this gives us a better

00:29:26.120 --> 00:29:30.640
approximation for what we would get if

00:29:27.519 --> 00:29:30.640
we ran tests

00:29:39.840 --> 00:29:45.000
in yeah so we did not we did not

00:29:42.600 --> 00:29:46.799
consider code structure here uh would

00:29:45.000 --> 00:29:48.480
different variable names affect it yes

00:29:46.799 --> 00:29:50.159
different variable names would affect it

00:29:48.480 --> 00:29:51.799
but not as much as the other metrics

00:29:50.159 --> 00:29:53.960
which is why it's better why it has

00:29:51.799 --> 00:29:56.720
better

00:29:53.960 --> 00:30:00.000
correlations and like for example

00:29:56.720 --> 00:30:03.679
codir I imagine probably gives very

00:30:00.000 --> 00:30:05.120
similar representations to I and J just

00:30:03.679 --> 00:30:07.960
because they're both used in iterators

00:30:05.120 --> 00:30:09.039
all the time whereas uh a normal Burt

00:30:07.960 --> 00:30:10.960
model would give very different

00:30:09.039 --> 00:30:12.760
representations to I and J right because

00:30:10.960 --> 00:30:14.960
I is like a personal pronoun and J is

00:30:12.760 --> 00:30:17.200
not so um that's the reason why

00:30:14.960 --> 00:30:20.399
continued training would

00:30:17.200 --> 00:30:24.799
help cool any other

00:30:20.399 --> 00:30:26.640
things okay so another um another place

00:30:24.799 --> 00:30:29.480
where code generation can be useful uh

00:30:26.640 --> 00:30:33.440
we had the example of collab uh is in

00:30:29.480 --> 00:30:36.200
collab notebooks and this or in uh data

00:30:33.440 --> 00:30:38.519
science notebooks this paper was by uh

00:30:36.200 --> 00:30:41.440
Google so this might actually even be

00:30:38.519 --> 00:30:43.960
used in the collab thing because collab

00:30:41.440 --> 00:30:45.640
is a Google thing um but data data

00:30:43.960 --> 00:30:47.320
science notebooks allow for incremental

00:30:45.640 --> 00:30:50.519
implementation I'm sure a lot of people

00:30:47.320 --> 00:30:53.559
here or almost everybody here uses them

00:30:50.519 --> 00:30:55.279
um and another interesting thing is say

00:30:53.559 --> 00:30:57.519
allow for evaluation of code generation

00:30:55.279 --> 00:30:58.960
in context uh or incremental code

00:30:57.519 --> 00:31:00.639
generation

00:30:58.960 --> 00:31:02.720
and so you start out with like a

00:31:00.639 --> 00:31:04.880
notebook and then you have AAL

00:31:02.720 --> 00:31:06.600
languageand and then youate the output

00:31:04.880 --> 00:31:09.240
AAL language command you generate the

00:31:06.600 --> 00:31:10.799
output etc etc so this is an extal

00:31:09.240 --> 00:31:14.519
example from the STA

00:31:10.799 --> 00:31:17.519
set um so this paper is very nice it it

00:31:14.519 --> 00:31:20.320
has a lot of uh you know it's a nice

00:31:17.519 --> 00:31:21.720
data set one other thing that was really

00:31:20.320 --> 00:31:24.200
interesting from this paper is it

00:31:21.720 --> 00:31:27.919
demonstrated the problem of data leakage

00:31:24.200 --> 00:31:29.679
in evaluating models and this is a Rel

00:31:27.919 --> 00:31:32.440
relatively large problem I don't know if

00:31:29.679 --> 00:31:33.799
we have a silver bullet solution for

00:31:32.440 --> 00:31:36.120
this but it's an important thing to be

00:31:33.799 --> 00:31:38.120
aware of uh not just for code generation

00:31:36.120 --> 00:31:39.639
but these are examples from code

00:31:38.120 --> 00:31:43.519
generation

00:31:39.639 --> 00:31:45.679
so here um in the arcade data set they

00:31:43.519 --> 00:31:48.519
basically both evaluated existing

00:31:45.679 --> 00:31:51.720
notebooks and they evaluated notebooks

00:31:48.519 --> 00:31:53.279
that um existing notebooks that they got

00:31:51.720 --> 00:31:55.960
from the web and they evaluated

00:31:53.279 --> 00:31:59.000
notebooks that they actually created

00:31:55.960 --> 00:32:00.399
themselves and there's very very Stark

00:31:59.000 --> 00:32:02.600
difference between the notebooks that

00:32:00.399 --> 00:32:04.440
were created on the web and the

00:32:02.600 --> 00:32:07.399
notebooks that they evaluated themselves

00:32:04.440 --> 00:32:10.159
so like most of the code generation

00:32:07.399 --> 00:32:11.679
models except for Palm uh which was the

00:32:10.159 --> 00:32:14.760
best model when they created this data

00:32:11.679 --> 00:32:17.360
set did really poorly or did really well

00:32:14.760 --> 00:32:21.120
on the existing data and quite poorly on

00:32:17.360 --> 00:32:25.279
the new data um which is probably an

00:32:21.120 --> 00:32:28.159
indication of um probably an indication

00:32:25.279 --> 00:32:29.720
of the fact that you know this is to

00:32:28.159 --> 00:32:32.240
some extent leaked into the training

00:32:29.720 --> 00:32:35.320
data of the language models there was

00:32:32.240 --> 00:32:37.760
also a very recent

00:32:35.320 --> 00:32:40.240
um paper actually I think this might be

00:32:37.760 --> 00:32:43.159
2024 there was a very recent paper that

00:32:40.240 --> 00:32:45.880
did a similar thing uh where they

00:32:43.159 --> 00:32:48.440
evaluated on human ofel and then their

00:32:45.880 --> 00:32:52.000
live codebench in live codebench

00:32:48.440 --> 00:32:55.639
basically what they did is they tried to

00:32:52.000 --> 00:32:58.519
pick problems from Le code and other

00:32:55.639 --> 00:33:00.519
websites that were more recent versus

00:32:58.519 --> 00:33:01.960
less recent and they have some really

00:33:00.519 --> 00:33:04.880
nice graphs in their paper where they

00:33:01.960 --> 00:33:06.519
demonstrate that the less recent ones

00:33:04.880 --> 00:33:08.159
before the training cut off have like a

00:33:06.519 --> 00:33:10.080
high accuracy and then suddenly it drops

00:33:08.159 --> 00:33:12.639
right at the trading C off of the the

00:33:10.080 --> 00:33:13.480
models so this is something to to be

00:33:12.639 --> 00:33:17.360
aware

00:33:13.480 --> 00:33:20.519
of and what this figure is showing here

00:33:17.360 --> 00:33:24.039
is this figure is showing on the xaxis

00:33:20.519 --> 00:33:26.840
pass it one on the Live code bench easy

00:33:24.039 --> 00:33:28.679
and then pass it one on human ofel so we

00:33:26.840 --> 00:33:31.480
see this kn

00:33:28.679 --> 00:33:34.039
correlation between

00:33:31.480 --> 00:33:35.919
essentially like passing on life code

00:33:34.039 --> 00:33:37.399
bench easy and passing on human ofel

00:33:35.919 --> 00:33:40.000
then we have this group of models that

00:33:37.399 --> 00:33:42.159
are kind of like up here and these are

00:33:40.000 --> 00:33:43.960
ones where basically it's likely that

00:33:42.159 --> 00:33:46.480
human ofel leaked into the training data

00:33:43.960 --> 00:33:48.840
because they're getting better scores on

00:33:46.480 --> 00:33:50.919
human ofel than you would expect that

00:33:48.840 --> 00:33:53.360
they get uh you know just looking at

00:33:50.919 --> 00:33:55.360
their uh you know performance on another

00:33:53.360 --> 00:33:57.320
data set there's also a nice like

00:33:55.360 --> 00:34:00.000
analogous one for math reasoning

00:33:57.320 --> 00:34:01.519
problems um like this so this is

00:34:00.000 --> 00:34:03.039
definitely something to be aware of if

00:34:01.519 --> 00:34:04.559
you're looking only at like very

00:34:03.039 --> 00:34:06.200
standard benchmarks that people are

00:34:04.559 --> 00:34:11.159
trading

00:34:06.200 --> 00:34:11.159
in cool um any questions about

00:34:12.119 --> 00:34:19.240
this okay um another data set uh that I

00:34:17.720 --> 00:34:20.599
I really like the concept of and

00:34:19.240 --> 00:34:22.919
recently it's gotten a little bit of

00:34:20.599 --> 00:34:25.399
Buzz because it was used in a um an

00:34:22.919 --> 00:34:28.399
evaluation of a new coding assistant

00:34:25.399 --> 00:34:30.480
called Devon but this is um

00:34:28.399 --> 00:34:32.240
something called sbench and it's issues

00:34:30.480 --> 00:34:34.639
from GitHub and code

00:34:32.240 --> 00:34:37.119
bases uh is the input and you want to

00:34:34.639 --> 00:34:39.480
generate a poll request to basically uh

00:34:37.119 --> 00:34:42.919
solve these issues and so your input is

00:34:39.480 --> 00:34:45.800
like data leak in gbdt due to warm start

00:34:42.919 --> 00:34:48.800
this is about non standard then you have

00:34:45.800 --> 00:34:51.159
the code base um it generates a PR for

00:34:48.800 --> 00:34:53.079
you and then it's run through the unit

00:34:51.159 --> 00:34:55.919
tests to see if it passes all the unit

00:34:53.079 --> 00:34:57.160
test post PRS so it's very similar to

00:34:55.919 --> 00:34:59.240
you know what you would be doing in a

00:34:57.160 --> 00:35:01.280
well Main software project you open a

00:34:59.240 --> 00:35:05.240
issue and then you open a poll request

00:35:01.280 --> 00:35:07.800
to fix an issue um this requires things

00:35:05.240 --> 00:35:10.240
like long context understanding um being

00:35:07.800 --> 00:35:13.200
able to do very precise implementations

00:35:10.240 --> 00:35:14.720
based on large software projects and

00:35:13.200 --> 00:35:17.920
right now the state-of-the-art on this

00:35:14.720 --> 00:35:20.680
is at about 14% so it's definitely not a

00:35:17.920 --> 00:35:23.119
solv problem at all um in the original

00:35:20.680 --> 00:35:27.920
paper uh the the state-of-the-art method

00:35:23.119 --> 00:35:29.400
was like 6% or something like that so um

00:35:27.920 --> 00:35:32.079
I imagine that we're not going to get up

00:35:29.400 --> 00:35:33.880
to 90% anytime soon because it's

00:35:32.079 --> 00:35:35.720
probably solving the easier ones and the

00:35:33.880 --> 00:35:37.280
harder ones are you know far beyond the

00:35:35.720 --> 00:35:39.920
ability of any language model we have at

00:35:37.280 --> 00:35:42.320
the moment um but I I really like this

00:35:39.920 --> 00:35:43.960
Benchmark one caveat if you really like

00:35:42.320 --> 00:35:45.520
this Benchmark is that it's kind of

00:35:43.960 --> 00:35:47.760
heavy to run so you need to be a little

00:35:45.520 --> 00:35:51.000
bit careful uh because you need to pull

00:35:47.760 --> 00:35:54.280
in like full repositories to um to run

00:35:51.000 --> 00:35:56.319
on so yeah be a little

00:35:54.280 --> 00:35:57.920
bit sorry there's so many like

00:35:56.319 --> 00:35:59.640
interesting data sets recently in this

00:35:57.920 --> 00:36:01.079
area that I I spent a lot of time on

00:35:59.640 --> 00:36:04.240
data set so I'll try to go a little bit

00:36:01.079 --> 00:36:06.200
more quickly but um uh a final one is

00:36:04.240 --> 00:36:09.359
design to code and this is also a very

00:36:06.200 --> 00:36:11.520
recent data set um basically the idea is

00:36:09.359 --> 00:36:16.359
code generation from websites so your

00:36:11.520 --> 00:36:18.119
input is a website and your output is uh

00:36:16.359 --> 00:36:22.520
like JavaScript code that implements

00:36:18.119 --> 00:36:24.960
that website and or or css or HTML code

00:36:22.520 --> 00:36:26.880
that implements the website so I I

00:36:24.960 --> 00:36:30.119
really like this because you know it's a

00:36:26.880 --> 00:36:32.280
good test bed for multi modal models and

00:36:30.119 --> 00:36:34.040
there aren't a whole lot of strong open

00:36:32.280 --> 00:36:36.160
source multimodal models that can solve

00:36:34.040 --> 00:36:36.960
this at the moment so I think it's kind

00:36:36.160 --> 00:36:39.720
of

00:36:36.960 --> 00:36:41.480
cool um they also proposed a design to

00:36:39.720 --> 00:36:43.480
code model that does the best on this

00:36:41.480 --> 00:36:47.119
data set out of uh you know any of the

00:36:43.480 --> 00:36:47.119
open source models but it's still far

00:36:47.400 --> 00:36:53.040
from and then the question becomes how

00:36:50.680 --> 00:36:56.079
do they um evaluate this in the first

00:36:53.040 --> 00:36:59.440
place and basically the idea is that

00:36:56.079 --> 00:37:01.400
they do highle visual similarity and so

00:36:59.440 --> 00:37:03.920
they calculate visual embeddings of the

00:37:01.400 --> 00:37:06.119
generated sites and then they also do

00:37:03.920 --> 00:37:08.240
lowl element similarity so they try to

00:37:06.119 --> 00:37:10.440
identify all of the elements in the

00:37:08.240 --> 00:37:12.119
generated web page and make sure that uh

00:37:10.440 --> 00:37:15.720
they recall all of the generated

00:37:12.119 --> 00:37:18.760
elements so um I think this is nice one

00:37:15.720 --> 00:37:21.000
thing if you notice um if you use even

00:37:18.760 --> 00:37:25.960
state-ofthe-art like closed models like

00:37:21.000 --> 00:37:28.040
CLA 3 or um GPD 4 is they're really bad

00:37:25.960 --> 00:37:29.440
at this recall they it can generate

00:37:28.040 --> 00:37:31.800
something that looks like maybe a little

00:37:29.440 --> 00:37:33.839
bit similar but it will be missing like

00:37:31.800 --> 00:37:35.720
the elements the design will be off you

00:37:33.839 --> 00:37:37.720
know other stuff like that so I think

00:37:35.720 --> 00:37:41.079
even in the closed like strong models

00:37:37.720 --> 00:37:41.079
this is not a Sol

00:37:41.319 --> 00:37:47.079
problem cool uh

00:37:45.000 --> 00:37:49.880
yeah

00:37:47.079 --> 00:37:51.880
problem um so why is that a hard problem

00:37:49.880 --> 00:37:54.200
for the models I don't actually have a

00:37:51.880 --> 00:37:57.200
really confident answer to that but I

00:37:54.200 --> 00:37:57.200
think

00:38:00.240 --> 00:38:05.200
so one thing I can tell you is that they

00:38:02.839 --> 00:38:08.839
are able to

00:38:05.200 --> 00:38:12.000
improve um so they're able to generate

00:38:08.839 --> 00:38:14.720
something and then I say no that's bad

00:38:12.000 --> 00:38:16.160
please like make it better and it's

00:38:14.720 --> 00:38:17.800
generally better the second time

00:38:16.160 --> 00:38:19.920
especially if you give specific things

00:38:17.800 --> 00:38:22.319
like oh uh but the background on the

00:38:19.920 --> 00:38:25.160
generated site is white but actually it

00:38:22.319 --> 00:38:27.599
should be black and if you think about

00:38:25.160 --> 00:38:31.480
like even a skilled human programmer do

00:38:27.599 --> 00:38:35.119
you think you could write like website

00:38:31.480 --> 00:38:37.680
code and then view it once and then it

00:38:35.119 --> 00:38:40.319
would be correct I think you probably

00:38:37.680 --> 00:38:42.160
couldn't right and so like we're asking

00:38:40.319 --> 00:38:44.040
models to do essentially the same thing

00:38:42.160 --> 00:38:46.920
except they're like even worse than us

00:38:44.040 --> 00:38:48.560
and you know keeping track of all the V

00:38:46.920 --> 00:38:50.720
visual elements and stuff so I think

00:38:48.560 --> 00:38:52.480
it's more like this problem probably

00:38:50.720 --> 00:38:54.720
just needs iterative refinement

00:38:52.480 --> 00:38:58.839
otherwise it's like asking too much of a

00:38:54.720 --> 00:39:02.640
model maybe I don't know

00:38:58.839 --> 00:39:04.520
cool okay so um let's go into methods

00:39:02.640 --> 00:39:06.920
and code generation has some unique

00:39:04.520 --> 00:39:09.400
things um the basic method that you can

00:39:06.920 --> 00:39:11.240
always use is a code generating LM and

00:39:09.400 --> 00:39:13.040
so you feed in previous code or you feed

00:39:11.240 --> 00:39:16.040
in whatever context you have into the LM

00:39:13.040 --> 00:39:18.079
and you generate um uh from it and

00:39:16.040 --> 00:39:20.079
virtually all Serius LMS are trained on

00:39:18.079 --> 00:39:23.079
code nowadays like I I just mentioned

00:39:20.079 --> 00:39:23.079
before

00:39:23.119 --> 00:39:29.920
um one one important thing here is uh

00:39:28.560 --> 00:39:31.240
when you're generating if you're

00:39:29.920 --> 00:39:33.040
generating for something like code

00:39:31.240 --> 00:39:34.480
generation I definitely suggest that you

00:39:33.040 --> 00:39:36.119
modify your temperature settings

00:39:34.480 --> 00:39:38.359
appropriately and set it to a low

00:39:36.119 --> 00:39:42.160
temperature um otherwise you'll get kind

00:39:38.359 --> 00:39:45.079
of crazy uh code but if you set it to a

00:39:42.160 --> 00:39:45.079
low temperature you can get

00:39:46.440 --> 00:39:52.160
better anyway um one really core

00:39:49.640 --> 00:39:54.240
capability of code LMS especially ones

00:39:52.160 --> 00:39:55.599
that you use in your IDE like uh

00:39:54.240 --> 00:39:58.160
co-pilot is

00:39:55.599 --> 00:40:00.000
infilling and um

00:39:58.160 --> 00:40:03.680
the the paper that proposed this is

00:40:00.000 --> 00:40:05.920
actually by Daniel Freed at LTI here and

00:40:03.680 --> 00:40:09.160
um

00:40:05.920 --> 00:40:11.240
the basically what you want to do often

00:40:09.160 --> 00:40:13.000
is you have previous code you have next

00:40:11.240 --> 00:40:14.680
code and you want to just fill in like a

00:40:13.000 --> 00:40:17.960
line that's missing like you want to add

00:40:14.680 --> 00:40:19.040
an extra you know if statement or or

00:40:17.960 --> 00:40:22.720
some sort of

00:40:19.040 --> 00:40:24.880
modification and so the way that at

00:40:22.720 --> 00:40:27.000
least this paper proposed it and the way

00:40:24.880 --> 00:40:29.800
that I think most LMS are actually doing

00:40:27.000 --> 00:40:30.640
this is they take a standard left to

00:40:29.800 --> 00:40:33.200
right

00:40:30.640 --> 00:40:36.040
LM and what they want to do is they want

00:40:33.200 --> 00:40:39.040
to infill this code chunk and so what

00:40:36.040 --> 00:40:40.440
they do is they put a mask in the place

00:40:39.040 --> 00:40:42.119
where they want to fill the chunk which

00:40:40.440 --> 00:40:46.280
would also be where your cursor is in

00:40:42.119 --> 00:40:49.960
your IDE right uh at that point and then

00:40:46.280 --> 00:40:52.680
they have Mas to zero and then at the

00:40:49.960 --> 00:40:57.400
end they put mask to zero again and then

00:40:52.680 --> 00:40:59.000
they output the like you know all of the

00:40:57.400 --> 00:41:01.040
code that you want to generate there and

00:40:59.000 --> 00:41:02.839
so you can just kind of arbitrarily

00:41:01.040 --> 00:41:05.480
generate these trunks by pulling you

00:41:02.839 --> 00:41:07.000
know masking out chunks uh putting in

00:41:05.480 --> 00:41:08.960
The Mask token and then moving it to the

00:41:07.000 --> 00:41:10.440
end of the sequence and then you can

00:41:08.960 --> 00:41:13.160
just use a standard left to right Auto

00:41:10.440 --> 00:41:15.359
regressive language model to solve this

00:41:13.160 --> 00:41:17.040
problem so this is really important if

00:41:15.359 --> 00:41:18.520
you want to build like a co-pilot style

00:41:17.040 --> 00:41:20.160
thing and all of the code language

00:41:18.520 --> 00:41:23.680
models that I talk about at the end of

00:41:20.160 --> 00:41:23.680
this class uh use this

00:41:24.800 --> 00:41:30.440
technique um another thing is there's

00:41:28.160 --> 00:41:33.760
lots of available information uh for

00:41:30.440 --> 00:41:36.040
learning coding things um or for solving

00:41:33.760 --> 00:41:38.880
coding tasks this includes you know the

00:41:36.040 --> 00:41:40.440
current code context of course um also

00:41:38.880 --> 00:41:41.920
the description of the issue that you

00:41:40.440 --> 00:41:45.160
want to be fixing like if you're solving

00:41:41.920 --> 00:41:49.240
a poll request um repo context from

00:41:45.160 --> 00:41:51.880
other files um what tabs you have open

00:41:49.240 --> 00:41:55.920
uh so that that's also an important

00:41:51.880 --> 00:41:58.599
thing and when GitHub co-pilot came out

00:41:55.920 --> 00:42:01.960
they didn't really tell you the details

00:41:58.599 --> 00:42:04.480
of how they were doing this but um

00:42:01.960 --> 00:42:09.079
GitHub co-pilot is written in JavaScript

00:42:04.480 --> 00:42:11.839
and uh there was a p PhD student I think

00:42:09.079 --> 00:42:14.000
from maybe Georgia Tech or something uh

00:42:11.839 --> 00:42:16.839
who or Master student who basically went

00:42:14.000 --> 00:42:19.160
in and took the JavaScript and like Dem

00:42:16.839 --> 00:42:21.839
minified it and like reverse engineered

00:42:19.160 --> 00:42:23.640
what was actually happening um and uh

00:42:21.839 --> 00:42:26.680
wrote A Blog about it and this blog is

00:42:23.640 --> 00:42:28.800
is great uh so basically what uh

00:42:26.680 --> 00:42:32.200
co-pilot was doing which also kind of

00:42:28.800 --> 00:42:33.839
gives you a gold standard um way of uh

00:42:32.200 --> 00:42:36.920
looking

00:42:33.839 --> 00:42:39.440
at uh you know what kind of information

00:42:36.920 --> 00:42:43.440
is necessary to create a good model is

00:42:39.440 --> 00:42:45.240
first they extract um information for

00:42:43.440 --> 00:42:47.400
the prompt given the current document

00:42:45.240 --> 00:42:49.240
and the cursor position so they take the

00:42:47.400 --> 00:42:51.720
current document where is the cursor and

00:42:49.240 --> 00:42:54.640
what is before this and what is after

00:42:51.720 --> 00:42:56.960
this um they identify the relative path

00:42:54.640 --> 00:42:59.960
of the file and what language it's in so

00:42:56.960 --> 00:43:01.760
they they identifi python files or

00:42:59.960 --> 00:43:04.240
JavaScript files or

00:43:01.760 --> 00:43:07.440
whatever they find the most recently

00:43:04.240 --> 00:43:09.800
accessed 20 files in the same language

00:43:07.440 --> 00:43:12.599
so like if you've opened 20 tabs they

00:43:09.800 --> 00:43:15.559
keep track of which tab you had

00:43:12.599 --> 00:43:18.280
open um and then the actual prompt that

00:43:15.559 --> 00:43:22.119
they send over includes text that is

00:43:18.280 --> 00:43:23.640
before text that's after um similar

00:43:22.119 --> 00:43:26.520
files out of the 20 files that you've

00:43:23.640 --> 00:43:29.480
opened recently um also information from

00:43:26.520 --> 00:43:31.760
imported files and metadata about the

00:43:29.480 --> 00:43:33.079
language and the path so all of this is

00:43:31.760 --> 00:43:37.079
sent to the

00:43:33.079 --> 00:43:38.720
model um and so this is just basically

00:43:37.079 --> 00:43:40.160
it's really good prompt engineering

00:43:38.720 --> 00:43:41.760
right they're figuring out a good way to

00:43:40.160 --> 00:43:44.200
get all of the information that would be

00:43:41.760 --> 00:43:45.680
useful uh for getting this model to work

00:43:44.200 --> 00:43:49.559
into the

00:43:45.680 --> 00:43:50.920
prompt um so I there's much much more

00:43:49.559 --> 00:43:52.839
information in this plug it's a really

00:43:50.920 --> 00:43:57.400
nice blog if you uh if you want to see

00:43:52.839 --> 00:43:57.400
about it but um that's the basic

00:43:57.640 --> 00:44:00.240
any any

00:44:01.240 --> 00:44:07.160
questions okay

00:44:03.520 --> 00:44:11.240
cool yeah is this just what gets sent

00:44:07.160 --> 00:44:13.520
over to theot server or does

00:44:11.240 --> 00:44:15.240
copilot this is what gets sent over to

00:44:13.520 --> 00:44:17.920
the co-pilot server but the way they're

00:44:15.240 --> 00:44:20.960
sending it makes me guess that like all

00:44:17.920 --> 00:44:22.839
of this is red so like they also are

00:44:20.960 --> 00:44:24.559
considering I didn't mention it here but

00:44:22.839 --> 00:44:26.000
they're considering the token limit and

00:44:24.559 --> 00:44:27.599
other stuff like that so that kind of

00:44:26.000 --> 00:44:30.760
makes me feel like this is

00:44:27.599 --> 00:44:30.760
actually the

00:44:32.240 --> 00:44:38.440
pr uh cool

00:44:35.359 --> 00:44:41.040
so another uh thing that you can do is

00:44:38.440 --> 00:44:42.520
retrieval based code generation and

00:44:41.040 --> 00:44:45.640
retrieval based code

00:44:42.520 --> 00:44:47.599
generation uh basically what it does is

00:44:45.640 --> 00:44:50.920
it's like rag for code

00:44:47.599 --> 00:44:53.240
Generation Um and this has been around

00:44:50.920 --> 00:44:55.640
for a while including our work that I

00:44:53.240 --> 00:44:57.680
cited here and a few more in in

00:44:55.640 --> 00:44:59.960
2018 um

00:44:57.680 --> 00:45:03.000
and so one way you can do this is you

00:44:59.960 --> 00:45:07.160
can retrieve similar code from online

00:45:03.000 --> 00:45:09.720
and then use it to basically prompt a

00:45:07.160 --> 00:45:11.920
retrieval augmented language model uh

00:45:09.720 --> 00:45:14.480
this is good if you have a model that's

00:45:11.920 --> 00:45:16.920
not super good at code in the first

00:45:14.480 --> 00:45:19.920
place or you know it's making mistakes

00:45:16.920 --> 00:45:21.680
it's also good if you have a large code

00:45:19.920 --> 00:45:23.040
base like that's inter internal and you

00:45:21.680 --> 00:45:24.200
know the language model was not trained

00:45:23.040 --> 00:45:26.359
on it but you still want to use that

00:45:24.200 --> 00:45:27.559
code base for code generation so it's

00:45:26.359 --> 00:45:29.599
really good if you're working at like a

00:45:27.559 --> 00:45:32.160
big company for example that has a very

00:45:29.599 --> 00:45:33.319
constant coding style but hasn't trained

00:45:32.160 --> 00:45:37.160
its own

00:45:33.319 --> 00:45:39.720
LM um also particularly in code there's

00:45:37.160 --> 00:45:43.559
also documentation uh which can be

00:45:39.720 --> 00:45:46.920
retrieved and so we have new libraries

00:45:43.559 --> 00:45:51.359
all the time right and one frustrating

00:45:46.920 --> 00:45:53.119
thing when using like uh chat jpt or CLA

00:45:51.359 --> 00:45:57.400
or something like that when you're

00:45:53.119 --> 00:45:59.559
writing programs is that it can use old

00:45:57.400 --> 00:46:03.480
versions of libraries that are no longer

00:45:59.559 --> 00:46:05.359
compatible and so um in this paper uh

00:46:03.480 --> 00:46:08.359
which this is one of our papers too we

00:46:05.359 --> 00:46:10.079
called it DOC prompting um basically the

00:46:08.359 --> 00:46:13.720
idea is that

00:46:10.079 --> 00:46:17.440
you have your natural language input and

00:46:13.720 --> 00:46:20.119
then you look up uh similar thing

00:46:17.440 --> 00:46:23.240
similar documentation so you find like

00:46:20.119 --> 00:46:25.319
pigment is a general syntax highlighter

00:46:23.240 --> 00:46:28.160
uh so you can uh find syntax

00:46:25.319 --> 00:46:31.160
highlighting um you can also look up the

00:46:28.160 --> 00:46:32.640
lexer you can look up the HTML formatter

00:46:31.160 --> 00:46:35.119
and then all of the things that have

00:46:32.640 --> 00:46:37.000
similar documentation then you can uh

00:46:35.119 --> 00:46:39.480
append that to the prompt and then have

00:46:37.000 --> 00:46:41.680
that Genera output and we demonstrate

00:46:39.480 --> 00:46:43.200
that this is good both in general but

00:46:41.680 --> 00:46:44.800
also it's particularly good when you're

00:46:43.200 --> 00:46:46.240
dealing with new libraries that haven't

00:46:44.800 --> 00:46:48.280
been seen before or libraries that have

00:46:46.240 --> 00:46:50.119
been updated so this is another thing

00:46:48.280 --> 00:46:53.000
that you can

00:46:50.119 --> 00:46:55.720
do

00:46:53.000 --> 00:46:57.520
cool um another thing that you can do

00:46:55.720 --> 00:47:00.040
with code that you can't do easily with

00:46:57.520 --> 00:47:04.040
natural language is execution

00:47:00.040 --> 00:47:06.119
feedback and so this is a a paper where

00:47:04.040 --> 00:47:09.359
basically they do something that's

00:47:06.119 --> 00:47:10.319
rather simple but they generate multiple

00:47:09.359 --> 00:47:13.359
types of

00:47:10.319 --> 00:47:14.559
code or multiple instances of code so

00:47:13.359 --> 00:47:16.880
they basically sample different

00:47:14.559 --> 00:47:19.960
varieties of code and I was talking

00:47:16.880 --> 00:47:22.720
about like casset K right uh before

00:47:19.960 --> 00:47:25.000
casset K is good if you have some way to

00:47:22.720 --> 00:47:26.520
confirm which output is correct like you

00:47:25.000 --> 00:47:28.040
already have unit tests and you can run

00:47:26.520 --> 00:47:29.440
the unit test and identify which one

00:47:28.040 --> 00:47:31.839
passes the unit test or you can have a

00:47:29.440 --> 00:47:34.160
human check it but in the case when you

00:47:31.839 --> 00:47:35.640
can't do that what can you do and

00:47:34.160 --> 00:47:38.079
basically what you can do is you can

00:47:35.640 --> 00:47:40.800
execute all of the code Snippets that

00:47:38.079 --> 00:47:43.839
the model generated and check if the

00:47:40.800 --> 00:47:48.520
outputs overlap with each other and if

00:47:43.839 --> 00:47:50.680
you have um you know 30 programs that

00:47:48.520 --> 00:47:53.680
all generate very similar outputs then

00:47:50.680 --> 00:47:55.079
those outputs you know then that program

00:47:53.680 --> 00:47:56.520
is probably correct and then you can

00:47:55.079 --> 00:48:00.000
just pick one of them according to some

00:47:56.520 --> 00:48:02.160
criteria Ian specifically in this case

00:48:00.000 --> 00:48:03.960
they picked the program that has the

00:48:02.160 --> 00:48:05.599
lowest base risk like when we talked

00:48:03.960 --> 00:48:09.040
about minimum base risk and the decoding

00:48:05.599 --> 00:48:10.839
much so um they they basically execute a

00:48:09.040 --> 00:48:12.800
lot and then calculate the base risk of

00:48:10.839 --> 00:48:17.000
that

00:48:12.800 --> 00:48:17.000
that cool um

00:48:17.680 --> 00:48:24.440
yeah yeah and so like self consistency

00:48:21.599 --> 00:48:26.079
is a variety of Base risk um and they're

00:48:24.440 --> 00:48:27.640
using base risk here because outputs

00:48:26.079 --> 00:48:30.720
might not be exact the same but being

00:48:27.640 --> 00:48:30.720
closer is probably better

00:48:34.160 --> 00:48:39.040
than

00:48:36.760 --> 00:48:40.559
comp comparison of the code yeah that's

00:48:39.040 --> 00:48:42.880
a good question especially if you use

00:48:40.559 --> 00:48:44.319
something good like uh code BT score to

00:48:42.880 --> 00:48:46.280
do that comparison you might not even

00:48:44.319 --> 00:48:50.280
need to that's

00:48:46.280 --> 00:48:50.280
that I don't think they did that in

00:48:50.559 --> 00:48:57.240
this cool um another interesting thing

00:48:54.920 --> 00:48:59.760
um is there's

00:48:57.240 --> 00:49:04.119
several lines of work on fixing based on

00:48:59.760 --> 00:49:06.720
eror messages so the basic idea is you

00:49:04.119 --> 00:49:08.160
generate code you try to run it you get

00:49:06.720 --> 00:49:13.280
an airor message from it and then you

00:49:08.160 --> 00:49:16.200
feed that back to the llm um in order to

00:49:13.280 --> 00:49:17.520
you know correct the error and like llms

00:49:16.200 --> 00:49:19.119
if you give them an err and you give

00:49:17.520 --> 00:49:20.839
them buggy code they do have some

00:49:19.119 --> 00:49:24.599
capacity to do that especially as you

00:49:20.839 --> 00:49:28.839
get to theer llm so uh this is kind of a

00:49:24.599 --> 00:49:31.200
a nice uh paradigm this paper intercode

00:49:28.839 --> 00:49:33.880
actually generalizes this a bit and it's

00:49:31.200 --> 00:49:38.359
more recent that's why I cited it here

00:49:33.880 --> 00:49:40.000
and uh so this also um like says you can

00:49:38.359 --> 00:49:42.640
do single turn code generation you can

00:49:40.000 --> 00:49:44.960
also say oh could you please try again

00:49:42.640 --> 00:49:46.400
um you can also uh do planning and

00:49:44.960 --> 00:49:48.160
solving and other stuff like that so

00:49:46.400 --> 00:49:49.960
this is a good kind of like environment

00:49:48.160 --> 00:49:52.079
if you're interested in making these

00:49:49.960 --> 00:49:56.720
more like interactive coding assistance

00:49:52.079 --> 00:49:56.720
for example so you could take a look bre

00:49:58.359 --> 00:50:03.359
cool

00:50:00.119 --> 00:50:07.119
um another important topic is code

00:50:03.359 --> 00:50:08.880
synthesis from input output examples so

00:50:07.119 --> 00:50:12.319
actually when you said code generation

00:50:08.880 --> 00:50:14.760
or code synthesis like five years ago or

00:50:12.319 --> 00:50:17.440
10 years ago a lot of people would think

00:50:14.760 --> 00:50:19.440
about this uh so this is actually this

00:50:17.440 --> 00:50:22.440
has been around a lot longer than code

00:50:19.440 --> 00:50:24.160
synthesis um than serious inquiries into

00:50:22.440 --> 00:50:27.680
code synthesis from natural

00:50:24.160 --> 00:50:30.680
language um

00:50:27.680 --> 00:50:33.839
so basically the way this works is it

00:50:30.680 --> 00:50:35.319
can have no natural language whatsoever

00:50:33.839 --> 00:50:39.119
um but you still can try to guess the

00:50:35.319 --> 00:50:42.000
input from uh input output examples when

00:50:39.119 --> 00:50:44.319
would you want to do this so one example

00:50:42.000 --> 00:50:45.839
of this is something called flashfill

00:50:44.319 --> 00:50:48.599
which has been around for a very long

00:50:45.839 --> 00:50:51.839
time in Microsoft Excel and basically

00:50:48.599 --> 00:50:55.400
the way it works is you have one column

00:50:51.839 --> 00:50:58.640
and um the column might be

00:50:55.400 --> 00:50:58.640
like uh

00:50:59.559 --> 00:51:02.880
R new

00:51:03.040 --> 00:51:12.799
big and uh

00:51:06.559 --> 00:51:12.799
else just pick on three because he also

00:51:14.040 --> 00:51:19.599
up and so we have this column and then

00:51:17.160 --> 00:51:19.599
we have like

00:51:20.400 --> 00:51:26.760
gig um and from like one or a couple

00:51:25.160 --> 00:51:28.400
examples basically what it does is it

00:51:26.760 --> 00:51:30.319
tries to induce a program that can

00:51:28.400 --> 00:51:33.319
generate all the other examples properly

00:51:30.319 --> 00:51:35.599
so in this particular case that would be

00:51:33.319 --> 00:51:38.440
um you know like

00:51:35.599 --> 00:51:40.480
split take the first character from the

00:51:38.440 --> 00:51:43.280
first one and all of the last one and

00:51:40.480 --> 00:51:45.280
then concatenate and then M or something

00:51:43.280 --> 00:51:48.280
like that right

00:51:45.280 --> 00:51:50.079
um and so this is useful in some cases

00:51:48.280 --> 00:51:51.599
like you know in Excel when you have

00:51:50.079 --> 00:51:53.359
this long sheet and you want to fill in

00:51:51.599 --> 00:51:56.160
the rest of it and this has actually

00:51:53.359 --> 00:51:57.720
been deployed uh you know in Excel in

00:51:56.160 --> 00:52:00.960
white

00:51:57.720 --> 00:52:02.559
used um if you're interested in this

00:52:00.960 --> 00:52:06.040
topic there's a fair amount of work in

00:52:02.559 --> 00:52:08.839
it um my there's a little bit less work

00:52:06.040 --> 00:52:10.240
now because most people are focusing on

00:52:08.839 --> 00:52:12.400
uh learning programs from natural

00:52:10.240 --> 00:52:14.839
language and other stuff like this but

00:52:12.400 --> 00:52:16.480
uh this slightly older Pap paper called

00:52:14.839 --> 00:52:19.359
interpret explains a bunch of the

00:52:16.480 --> 00:52:22.880
different methods that people used and

00:52:19.359 --> 00:52:25.920
um how you uh like how they compare and

00:52:22.880 --> 00:52:28.119
stuff and also um Joshua ten and bums

00:52:25.920 --> 00:52:29.880
group from MI has done a lot on program

00:52:28.119 --> 00:52:31.319
synthesis from input output examples so

00:52:29.880 --> 00:52:32.359
you could also take a look at that that

00:52:31.319 --> 00:52:35.079
sounds

00:52:32.359 --> 00:52:38.240
interesting um one thing about this is

00:52:35.079 --> 00:52:40.280
these generally are mostly done on

00:52:38.240 --> 00:52:43.319
domain specific languages so they're

00:52:40.280 --> 00:52:46.839
mostly done like only for reg X's or

00:52:43.319 --> 00:52:48.480
they're done only for you know SQL or

00:52:46.839 --> 00:52:50.079
something like that not for the more

00:52:48.480 --> 00:52:51.960
general purpose languages just because

00:52:50.079 --> 00:52:54.079
the problem without any natural language

00:52:51.960 --> 00:52:56.520
specification is harder and so you need

00:52:54.079 --> 00:52:57.520
to like make the search space smaller or

00:52:56.520 --> 00:53:01.559
Additionally you needed to make the

00:52:57.520 --> 00:53:04.440
search small for theable so um that's a

00:53:01.559 --> 00:53:04.440
another thing to know

00:53:04.799 --> 00:53:09.440
about cool um any questions about

00:53:09.480 --> 00:53:14.440
these nice okay so finally in the the

00:53:12.559 --> 00:53:15.599
last few minutes I'd like to talk about

00:53:14.440 --> 00:53:18.480
um code

00:53:15.599 --> 00:53:22.880
LMS and I'm going to go through about

00:53:18.480 --> 00:53:24.599
four of them the first one is codex and

00:53:22.880 --> 00:53:26.200
so yeah actually what I should mention

00:53:24.599 --> 00:53:28.079
is all of the LMS that I talked about up

00:53:26.200 --> 00:53:30.640
until this point are code LMS because

00:53:28.079 --> 00:53:31.680
every LM trains on code so I'm mainly

00:53:30.640 --> 00:53:36.119
going to be talking about one

00:53:31.680 --> 00:53:39.200
specifically for code this time um so

00:53:36.119 --> 00:53:42.480
codex is the first and kind of like

00:53:39.200 --> 00:53:45.880
first really big impact Cod LM um it was

00:53:42.480 --> 00:53:47.720
created by open AI um originally I don't

00:53:45.880 --> 00:53:49.079
know about the deployed model now

00:53:47.720 --> 00:53:51.599
because you know they don't release the

00:53:49.079 --> 00:53:53.799
details of it but originally this was

00:53:51.599 --> 00:53:57.920
trained by continued training from

00:53:53.799 --> 00:53:59.799
gpt3 so they had a text M and then they

00:53:57.920 --> 00:54:03.079
just continued training it on lots and

00:53:59.799 --> 00:54:05.680
lots of code from GitHub um so yeah the

00:54:03.079 --> 00:54:08.799
data was lots of data from GitHub um if

00:54:05.680 --> 00:54:11.280
you did anything on GitHub at any point

00:54:08.799 --> 00:54:14.119
in your life uh you might be uh

00:54:11.280 --> 00:54:17.720
contributing to codep so thank you on

00:54:14.119 --> 00:54:22.440
behalf of open AI a 80 billion dollar

00:54:17.720 --> 00:54:24.599
company and uh importantly it Powers I

00:54:22.440 --> 00:54:27.599
believe it still Powers GitHub

00:54:24.599 --> 00:54:31.160
co-pilot one interesting thing is they

00:54:27.599 --> 00:54:33.119
had a large version of codex um and then

00:54:31.160 --> 00:54:35.799
they had a smaller version of codex

00:54:33.119 --> 00:54:38.359
called code kushman and the thing

00:54:35.799 --> 00:54:40.040
actually powering GitHub co-pilot is not

00:54:38.359 --> 00:54:42.839
the the largest version it's not code Da

00:54:40.040 --> 00:54:46.359
Vinci it's code kushman which is uh

00:54:42.839 --> 00:54:48.680
smaller and much faster and the reason

00:54:46.359 --> 00:54:50.640
why is probably twofold number one um

00:54:48.680 --> 00:54:54.160
you need really fast responses when

00:54:50.640 --> 00:54:55.760
you're you know working on code and

00:54:54.160 --> 00:54:57.440
there's actually in co-pilot there's

00:54:55.760 --> 00:55:00.280
some cach and other stuff like that to

00:54:57.440 --> 00:55:01.960
make your responses very fast as well um

00:55:00.280 --> 00:55:03.400
the second reason is probably it' just

00:55:01.960 --> 00:55:05.040
be too expensive for them to run Da

00:55:03.400 --> 00:55:06.760
Vinci over all the code bases for how

00:55:05.040 --> 00:55:10.400
much they're charging you for co-pilot

00:55:06.760 --> 00:55:12.119
so like every single time you like

00:55:10.400 --> 00:55:14.280
change something in one of your files if

00:55:12.119 --> 00:55:17.079
you're using copilot it's rerunning in

00:55:14.280 --> 00:55:19.359
llm and that would become very expensive

00:55:17.079 --> 00:55:20.599
if you look look at the token count so I

00:55:19.359 --> 00:55:21.839
think they're using a smaller model

00:55:20.599 --> 00:55:22.920
because of that but nonetheless it's

00:55:21.839 --> 00:55:27.039
very

00:55:22.920 --> 00:55:28.640
good um cool

00:55:27.039 --> 00:55:30.680
so now I want to get into some more

00:55:28.640 --> 00:55:33.880
modern models uh the first one I want to

00:55:30.680 --> 00:55:35.520
get into is uh star coder 2 and the

00:55:33.880 --> 00:55:38.359
reason why I want to talk about this

00:55:35.520 --> 00:55:40.160
first is because uh not necessarily that

00:55:38.359 --> 00:55:41.880
it's like absolutely the best one

00:55:40.160 --> 00:55:43.400
although it's very good but it's one of

00:55:41.880 --> 00:55:45.319
the models that actually tells us

00:55:43.400 --> 00:55:47.240
everything about their training data and

00:55:45.319 --> 00:55:50.400
training process and stuff so we know uh

00:55:47.240 --> 00:55:53.039
everything about them so the creator of

00:55:50.400 --> 00:55:54.440
This was um the big science project

00:55:53.039 --> 00:55:56.880
which was led by hugging face and

00:55:54.440 --> 00:55:58.680
service now um

00:55:56.880 --> 00:56:02.079
and includes lots and lots of people

00:55:58.680 --> 00:56:04.960
from various universities and things um

00:56:02.079 --> 00:56:09.319
the architecture is mostly llama style

00:56:04.960 --> 00:56:11.960
it has 3B 7B and 15b variants um one

00:56:09.319 --> 00:56:15.480
interesting thing about all code LMS is

00:56:11.960 --> 00:56:17.680
that they all do long context they all

00:56:15.480 --> 00:56:20.359
do longer context and they all

00:56:17.680 --> 00:56:23.200
reconfigure rope for longer context

00:56:20.359 --> 00:56:25.280
specifically so you know rope has a

00:56:23.200 --> 00:56:28.599
Theta parameter that allows you to tell

00:56:25.280 --> 00:56:31.720
how long the um like sign sine waves and

00:56:28.599 --> 00:56:33.720
stuff like that are and they all always

00:56:31.720 --> 00:56:36.079
um change the parameters so that the

00:56:33.720 --> 00:56:38.599
context is longer so that's another good

00:56:36.079 --> 00:56:38.599
thing to know

00:56:38.640 --> 00:56:44.559
about the the training data section of

00:56:42.000 --> 00:56:48.799
this paper is really fascinating I can

00:56:44.559 --> 00:56:51.240
like it it's a really good way to look

00:56:48.799 --> 00:56:54.160
at you know how much data engineering

00:56:51.240 --> 00:56:55.960
goes into making a good model um and

00:56:54.160 --> 00:56:57.960
just very shortly they give a lot more

00:56:55.960 --> 00:57:00.640
detail in the paper but it's trained on

00:56:57.960 --> 00:57:04.839
code uh including the stack which is

00:57:00.640 --> 00:57:06.920
just a huge uh amount like repository of

00:57:04.839 --> 00:57:08.359
code that I'll talk about in a second

00:57:06.920 --> 00:57:10.559
separately from that it was trained on

00:57:08.359 --> 00:57:13.079
GitHub issues it was trained on poll

00:57:10.559 --> 00:57:16.000
requests Jupiter notebooks keggle

00:57:13.079 --> 00:57:18.319
notebooks documentation and also

00:57:16.000 --> 00:57:23.440
intermediate representations from uh

00:57:18.319 --> 00:57:26.440
llvm so llvm is a uh you know like

00:57:23.440 --> 00:57:28.920
intermediate uh compiler style thing

00:57:26.440 --> 00:57:30.839
that is used for compiling code and it

00:57:28.920 --> 00:57:34.400
was also trained on a few code relevant

00:57:30.839 --> 00:57:38.440
natural language data sets

00:57:34.400 --> 00:57:39.960
um so for pre-processing they do

00:57:38.440 --> 00:57:42.640
something pretty interesting which is

00:57:39.960 --> 00:57:44.240
they add metadata tags such as the repo

00:57:42.640 --> 00:57:48.119
name and the file name and other stuff

00:57:44.240 --> 00:57:49.799
like this uh 50% of the time and they do

00:57:48.119 --> 00:57:51.599
this 50% of the time because they want

00:57:49.799 --> 00:57:54.400
the model to work with them but also be

00:57:51.599 --> 00:57:57.079
robust without them um and so you can

00:57:54.400 --> 00:57:59.839
either add them or not add them at test

00:57:57.079 --> 00:58:03.079
time uh they also do infilling every

00:57:59.839 --> 00:58:05.960
serus code LM does infilling Based

00:58:03.079 --> 00:58:07.480
training um one interesting thing about

00:58:05.960 --> 00:58:08.960
this from the training perspective is

00:58:07.480 --> 00:58:12.000
they actually trained it for four to

00:58:08.960 --> 00:58:14.359
five epochs um which is much more than

00:58:12.000 --> 00:58:17.160
we normally do so normally we only train

00:58:14.359 --> 00:58:18.359
for like one Epoch over you know all of

00:58:17.160 --> 00:58:20.079
the data we have but here they were

00:58:18.359 --> 00:58:21.319
training for monger and that's just

00:58:20.079 --> 00:58:23.359
because the amount of data they can get

00:58:21.319 --> 00:58:24.400
for code is less than the amount of data

00:58:23.359 --> 00:58:27.200
they can get for all the national

00:58:24.400 --> 00:58:30.039
language I

00:58:27.200 --> 00:58:33.200
so the data set that they created is uh

00:58:30.039 --> 00:58:36.119
the stack 2 and this is a code

00:58:33.200 --> 00:58:37.839
pre-training data set um one interesting

00:58:36.119 --> 00:58:40.039
thing that they thought about was uh

00:58:37.839 --> 00:58:42.960
license considerations so I talked about

00:58:40.039 --> 00:58:44.480
the um how copyright is a problem when

00:58:42.960 --> 00:58:46.640
trading large language models two

00:58:44.480 --> 00:58:48.880
classes ago and so here they

00:58:46.640 --> 00:58:50.119
specifically tried to find things with

00:58:48.880 --> 00:58:52.520
permissive

00:58:50.119 --> 00:58:53.880
licenses and so what they did is they

00:58:52.520 --> 00:58:57.000
basically looked at the license on

00:58:53.880 --> 00:58:59.520
GitHub um and if the GitHub license was

00:58:57.000 --> 00:59:01.440
permissive they marked it as permissive

00:58:59.520 --> 00:59:02.880
um then they tried to detect licenses

00:59:01.440 --> 00:59:05.720
and then um if all of them were

00:59:02.880 --> 00:59:08.000
permissive they marked it as

00:59:05.720 --> 00:59:10.480
permissive this is a huge table that

00:59:08.000 --> 00:59:14.160
they have in the paper of all of the

00:59:10.480 --> 00:59:15.480
data that they have and um you know I'm

00:59:14.160 --> 00:59:16.920
not going to go through all of this

00:59:15.480 --> 00:59:18.920
obviously but what you can see is some

00:59:16.920 --> 00:59:22.480
of the biggest data sets are like

00:59:18.920 --> 00:59:26.280
Java um

00:59:22.480 --> 00:59:28.640
PHP markdown

00:59:26.280 --> 00:59:30.039
and uh Python and other stuff like that

00:59:28.640 --> 00:59:32.240
so you can see the major programming

00:59:30.039 --> 00:59:35.559
languages have lots of data but there's

00:59:32.240 --> 00:59:38.400
also a long tail so if you like your uh

00:59:35.559 --> 00:59:40.440
you know more esoteric uh but cool

00:59:38.400 --> 00:59:43.960
programming languages like rust yes it

00:59:40.440 --> 00:59:46.160
has rust too so um we can do all all of

00:59:43.960 --> 00:59:46.160
those

00:59:46.480 --> 00:59:53.079
things so the next model that I'd like

00:59:49.799 --> 00:59:55.200
to talk about is cod llama and cod llama

00:59:53.079 --> 00:59:57.920
is another competitive model it came out

00:59:55.200 --> 00:59:59.480
a little bit before star coder and star

00:59:57.920 --> 01:00:02.680
coder 2 and deep sea coder which I'm

00:59:59.480 --> 01:00:04.079
going to talk about um this is a created

01:00:02.680 --> 01:00:08.319
by

01:00:04.079 --> 01:00:11.160
meta and um the architecture is the same

01:00:08.319 --> 01:00:14.280
as llama 2 uh basically and they did

01:00:11.160 --> 01:00:16.400
continued training from llama 2 um but

01:00:14.280 --> 01:00:18.000
they trained it on longer input contexts

01:00:16.400 --> 01:00:21.720
and they also extended the length of

01:00:18.000 --> 01:00:23.559
rope so uh those are you know standard

01:00:21.720 --> 01:00:26.680
things for code language

01:00:23.559 --> 01:00:28.680
models it was trained on DED code and

01:00:26.680 --> 01:00:30.400
also synthetically created instruction

01:00:28.680 --> 01:00:33.280
data so they created like instruction

01:00:30.400 --> 01:00:37.920
tuning data specifically for

01:00:33.280 --> 01:00:39.480
code um and the training was incremental

01:00:37.920 --> 01:00:42.559
with various data sets and what I mean

01:00:39.480 --> 01:00:45.599
by this is they trained on 500 billion

01:00:42.559 --> 01:00:47.599
uh I believe tokens of code and then

01:00:45.599 --> 01:00:50.400
they did long context fine tuning on 20

01:00:47.599 --> 01:00:52.599
billion tokens and then they also did

01:00:50.400 --> 01:00:55.400
instruction tuning they also have a

01:00:52.599 --> 01:00:57.079
python specific one and the reason why

01:00:55.400 --> 01:00:59.640
they have a p specific one is not

01:00:57.079 --> 01:01:02.319
because python is more import important

01:00:59.640 --> 01:01:03.839
uh uh necessarily but because a lot of

01:01:02.319 --> 01:01:05.559
the benchmarks are in Python because

01:01:03.839 --> 01:01:06.920
machine learning people like who are

01:01:05.559 --> 01:01:09.240
creating benchmarks they also like

01:01:06.920 --> 01:01:11.200
python so python is more common in the

01:01:09.240 --> 01:01:14.240
benchmarks so they basically wanted to

01:01:11.200 --> 01:01:15.720
do well on the benchmarks I think uh and

01:01:14.240 --> 01:01:17.920
and created a data set that does well in

01:01:15.720 --> 01:01:19.240
the benchmarks but um if you are

01:01:17.920 --> 01:01:23.160
creating python you can use the code

01:01:19.240 --> 01:01:25.280
llama python it's better at pipelines so

01:01:23.160 --> 01:01:28.000
um and then the final one I'd like to

01:01:25.280 --> 01:01:29.839
talk about is is a deep seek coder uh

01:01:28.000 --> 01:01:32.079
this is notable because it's a very

01:01:29.839 --> 01:01:34.599
strong model it it's maybe the strongest

01:01:32.079 --> 01:01:38.799
model on average over all the code

01:01:34.599 --> 01:01:41.599
models um they did 87% the data is not

01:01:38.799 --> 01:01:44.640
super clear but they did 87% source code

01:01:41.599 --> 01:01:46.359
10% English um from markdown in stock

01:01:44.640 --> 01:01:51.160
exchange and 3% Chinese because it's

01:01:46.359 --> 01:01:53.559
from a Chinese company deep seek um and

01:01:51.160 --> 01:01:54.960
they did standard prepr uh but one

01:01:53.559 --> 01:01:57.319
interesting thing they did is they

01:01:54.960 --> 01:01:59.200
included Library dependencies so they

01:01:57.319 --> 01:02:01.799
basically crawled the dependency graph

01:01:59.200 --> 01:02:03.640
of libraries pulled out files from the

01:02:01.799 --> 01:02:06.000
libraries that were referenced and then

01:02:03.640 --> 01:02:07.440
used them in training and so that's

01:02:06.000 --> 01:02:09.319
particularly useful if you want the

01:02:07.440 --> 01:02:12.920
model to be able to reference external

01:02:09.319 --> 01:02:14.039
libraries well um so that's kind of an

01:02:12.920 --> 01:02:17.279
interesting

01:02:14.039 --> 01:02:19.599
thing um the architecture is pretty

01:02:17.279 --> 01:02:22.960
standard it's llama likee with 1.3

01:02:19.599 --> 01:02:24.599
billion 6.7 billion in 33b variants and

01:02:22.960 --> 01:02:27.279
it has a reconfigured work like the

01:02:24.599 --> 01:02:30.520
others and they on two trillion

01:02:27.279 --> 01:02:34.200
tokens um so then a question becomes

01:02:30.520 --> 01:02:36.680
which one to use um and I created a

01:02:34.200 --> 01:02:39.160
summary here um all of them have

01:02:36.680 --> 01:02:40.760
somewhat similar performance uh this is

01:02:39.160 --> 01:02:42.760
they're compared in the star coder 2

01:02:40.760 --> 01:02:45.640
paper so you can go in and look at

01:02:42.760 --> 01:02:48.160
details at the starcode to paper um

01:02:45.640 --> 01:02:51.119
deeps coder seems to be strong on

01:02:48.160 --> 01:02:52.799
standard programming tasks um whereas

01:02:51.119 --> 01:02:54.799
star coder seems to be strong on data

01:02:52.799 --> 01:02:56.680
science notebooks so like on average

01:02:54.799 --> 01:02:59.160
it's better at kind of sound notebooks

01:02:56.680 --> 01:03:02.079
but all of them are good models um all

01:02:59.160 --> 01:03:05.440
of them are not quite as good as uh like

01:03:02.079 --> 01:03:08.920
gp4 quad on like they're very uh you

01:03:05.440 --> 01:03:10.799
know more complex tasks but uh they're

01:03:08.920 --> 01:03:12.359
available and you can find to them and

01:03:10.799 --> 01:03:16.880
do other things like that as

01:03:12.359 --> 01:03:21.599
well one caveat about the Deep seek

01:03:16.880 --> 01:03:24.640
thing is actually if I go back to this

01:03:21.599 --> 01:03:27.559
slide um a lot of the models up here are

01:03:24.640 --> 01:03:29.640
deep seek um so you do need to be a

01:03:27.559 --> 01:03:31.400
little bit careful about like

01:03:29.640 --> 01:03:34.400
interpreting their human Evel results

01:03:31.400 --> 01:03:36.319
because it's possible that the model uh

01:03:34.400 --> 01:03:38.799
was trained on data very similar to

01:03:36.319 --> 01:03:40.279
human eval or something like that so do

01:03:38.799 --> 01:03:42.880
take that with a grain of salt but even

01:03:40.279 --> 01:03:44.520
on other data sets where presumably the

01:03:42.880 --> 01:03:46.760
model has not seen those data sets it

01:03:44.520 --> 01:03:49.920
still does very well so it's not like

01:03:46.760 --> 01:03:51.480
it's um you know as you can see it's

01:03:49.920 --> 01:03:54.640
still one of the most competitive code

01:03:51.480 --> 01:03:57.680
models even on this new LCB um data set

01:03:54.640 --> 01:04:01.359
so uh that's want into the

01:03:57.680 --> 01:04:03.000
a cool um that's all I have for today I

01:04:01.359 --> 01:04:04.359
you know I love to talk about this topic

01:04:03.000 --> 01:04:06.480
I've done a lot of research on it so I'm

01:04:04.359 --> 01:04:11.200
happy to discuss any questions if people

01:04:06.480 --> 01:04:14.720
have them either in front of everyone or

01:04:11.200 --> 01:04:14.720
after any any

01:04:16.480 --> 01:04:24.160
questions uh yeah just wondering there a

01:04:20.359 --> 01:04:27.720
like enfor the outut during using things

01:04:24.160 --> 01:04:27.720
other than models

01:04:30.599 --> 01:04:36.599
yeah great question is there a way to

01:04:33.640 --> 01:04:38.200
enforce uh restrictions at decoding time

01:04:36.599 --> 01:04:39.760
other than using the model's uh

01:04:38.200 --> 01:04:42.240
probabilities because this is code and

01:04:39.760 --> 01:04:42.240
we know the

01:04:42.440 --> 01:04:51.079
syntax yes and no um there

01:04:46.319 --> 01:04:53.200
are for code it's not always immediately

01:04:51.079 --> 01:04:54.400
obvious like I mean one one thing you

01:04:53.200 --> 01:04:55.960
could do is just generate a bunch of

01:04:54.400 --> 01:04:58.520
results and throw out all the syntax

01:04:55.960 --> 01:04:59.480
incorrect on that's easy right um but if

01:04:58.520 --> 01:05:02.520
you don't want to do that and you want

01:04:59.480 --> 01:05:04.839
to do it at decoding time it's dependent

01:05:02.520 --> 01:05:07.480
on you being able to have an incremental

01:05:04.839 --> 01:05:09.079
syntax parser that allows you to like

01:05:07.480 --> 01:05:12.400
throw out bad

01:05:09.079 --> 01:05:14.160
hypotheses like incrementally and that's

01:05:12.400 --> 01:05:16.240
possible that's very easy for some

01:05:14.160 --> 01:05:17.200
languages and not possible not as easy

01:05:16.240 --> 01:05:20.559
for other

01:05:17.200 --> 01:05:23.720
languages um one really big thing right

01:05:20.559 --> 01:05:26.599
now is Json so like a lot of the time

01:05:23.720 --> 01:05:28.319
people want to Output Json uh in you

01:05:26.599 --> 01:05:31.559
know then par the Json and use it in

01:05:28.319 --> 01:05:36.640
some Downstream test and there actually

01:05:31.559 --> 01:05:36.640
are libraries um just to give a

01:05:38.559 --> 01:05:45.839
few um here's one this Library called

01:05:42.640 --> 01:05:48.799
outlines um is one that basically allows

01:05:45.839 --> 01:05:50.440
you to incorporate syntactic constraints

01:05:48.799 --> 01:05:53.240
through like weighted finite State

01:05:50.440 --> 01:05:55.160
automata and other stuff like this um to

01:05:53.240 --> 01:05:57.680
allow you to throw away anything that

01:05:55.160 --> 01:06:02.039
doesn't here to your grammar another

01:05:57.680 --> 01:06:02.039
popular one which

01:06:02.720 --> 01:06:06.880
is nice but a little bit more

01:06:07.160 --> 01:06:12.760
complicated is

01:06:09.799 --> 01:06:15.160
um this one uh

01:06:12.760 --> 01:06:17.200
guidance so if you want to look at like

01:06:15.160 --> 01:06:19.720
constrained generation of outputs I

01:06:17.200 --> 01:06:21.640
would definitely recommend uh looking at

01:06:19.720 --> 01:06:22.839
one of these two either outlines or or

01:06:21.640 --> 01:06:24.440
guidance and they both give you

01:06:22.839 --> 01:06:26.520
different ways to add constraints to

01:06:24.440 --> 01:06:29.079
Output um we did actually talk about

01:06:26.520 --> 01:06:31.200
outlines a little bit during the like uh

01:06:29.079 --> 01:06:34.599
generation class but um we didn't go

01:06:31.200 --> 01:06:35.760
into a lot of details so uh yeah but I I

01:06:34.599 --> 01:06:39.559
would recommend

01:06:35.760 --> 01:06:39.559
this cool any other

01:06:39.599 --> 01:06:43.920
questions okay if not uh I guess we can

01:06:42.079 --> 01:06:47.880
finish up and I'm happy to talk we have

01:06:43.920 --> 01:06:47.880
a little bit of extra time