AI Intentions and Code Completion
Datalore supports intentions – code suggestions based on what you’ve just written. They cover a wide range of situations from generating code to warnings and optimization suggestions. While Datalore is aware of what intentions can be applied to the particular block of code, it can’t determine which intention will be the most useful for the user and should be shown first. Although Datalore is the web application, we can’t access our users’ source code – and hence can’t match it with intentions they are invoking and use this data for training our model. As for now, the model architecture follows more or less the same architecture approach, except for using bidirectional LSTM connections. The current proof-of-concept version obtains up to 57% top-1 accuracy while requiring about 200 ms for one prediction.
This session took place in track PyData and was classified suitable for some domain / basic python by the speaker.
Transcript (auto)
Auto-generated from the recording utilizing Open-Source AI. Speaker labels (Speaker 1, Speaker 2) reflect diarization, not identity. Timestamps refer to the recording.
Speaker 1 [00:04]
Hi there, I'm glad to be here and I like to take
Speaker 2 [00:07]
like to tell you about some of our recent
Speaker 1 [00:10]
recent data-related projects at JetBrains. Let me briefly introduce my
Speaker 2 [00:14]
introduce myself. My name is Vasily. I
Speaker 1 [00:17]
I work at JetBrains as a data scientist and product manager in
Speaker 2 [00:21]
in Datalog's team.
Speaker 1 [00:22]
JetBrains is a software vendor. We develop and sell IDs and developer tools.
Speaker 2 [00:29]
and since
Speaker 1 [00:30]
And since we are...
Speaker 2 [00:31]
we are at the data
Speaker 1 [00:31]
at the data conference.
Speaker 2 [00:32]
conference you might
Speaker 1 [00:34]
have heard or use PyCharm. And regarding datalore, datalore is our recent
Speaker 2 [00:39]
recent product for
Speaker 1 [00:40]
product for data analysis
Speaker 2 [00:41]
data analysis and machine
Speaker 1 [00:42]
and machine learning, you can easily
Speaker 2 [00:43]
You can easily create
Speaker 1 [00:44]
create some predictive models, reach visualization,
Speaker 2 [00:47]
visualization
Speaker 1 [00:48]
and share it with your colleagues.
Speaker 2 [00:49]
with your colleagues get some code review there.
Speaker 1 [00:51]
there everything in cloud and for free and my product my project called
Speaker 2 [00:57]
called AI Intentions and Code Completion. So I'll guess all of you...
Speaker 1 [01:03]
All of you have heard a lot about
Speaker 2 [01:05]
a lot about AI in
Speaker 1 [01:06]
in use and
Speaker 2 [01:07]
use and
Speaker 1 [01:08]
in the web and I apologize
Speaker 2 [01:09]
and I apologize for mentioning
Speaker 1 [01:10]
for mention these two letters in my topic but it's a good way to
Speaker 2 [01:12]
but it's a good way just to indicate the idea behind this.
Speaker 1 [01:17]
meaning to predict something based
Speaker 2 [01:19]
something based on the users'
Speaker 1 [01:20]
users behavior patterns and
Speaker 2 [01:22]
and content. And also when you give
Speaker 1 [01:25]
And also when you giving a talk it's like
Speaker 2 [01:26]
in a talk it's like AI when you
Speaker 1 [01:27]
AI, when you're working on it, it's ML, and when you think
Speaker 2 [01:29]
And when you're thinking...
Speaker 1 [01:30]
how to solve this problem it's usually a linear algebra or statistics
Speaker 2 [01:34]
statistics.
Speaker 1 [01:35]
So I hope you won't blame me for that two capital letters, and let's get started. My presentation is divided into two parts.
Speaker 2 [01:42]
into two parts. First will be about
Speaker 1 [01:44]
intentions and the second about code completions. Let's start from intentions. So the idea of the project
Speaker 2 [01:53]
was quite simple.
Speaker 1 [01:54]
DataLog supports intentions, which is basically
Speaker 2 [01:57]
which is basically a piece of code some
Speaker 1 [02:00]
some recommendation based on your
Speaker 2 [02:02]
based on your previous sales online
Speaker 1 [02:04]
cells or lines of code.
Speaker 2 [02:05]
of code.
Speaker 1 [02:06]
and intentions cover
Speaker 2 [02:08]
over, we're
Speaker 1 [02:09]
variety of actions such as generating code
Speaker 2 [02:12]
code if you load your
Speaker 1 [02:14]
load your csv then you
Speaker 2 [02:15]
then you have
Speaker 1 [02:16]
intentions to drop an A, for example, in
Speaker 2 [02:18]
for example in pandas,
Speaker 1 [02:19]
pandas or it could be some optimization suggestion
Speaker 2 [02:21]
suggestion.
Speaker 1 [02:22]
and the idea was to rank this list
Speaker 2 [02:25]
this list of...
Speaker 1 [02:26]
of intentions and determine the
Speaker 2 [02:29]
top list of intentions based on the previous lines of code.
Speaker 1 [02:34]
lines of code. And the goal is to create
Speaker 2 [02:37]
create smart
Speaker 1 [02:38]
a smart code
Speaker 2 [02:39]
called Code Helper.
Speaker 1 [02:40]
helper and gather some interesting stats from
Speaker 2 [02:43]
stats from the datasets. For sure we faced several
Speaker 1 [02:47]
several challenges during this project. The first one was about
Speaker 2 [02:52]
The first one was about privacy.
Speaker 1 [02:52]
privacy.
Speaker 2 [02:53]
We can't accept
Speaker 1 [02:55]
can't access the users
Speaker 2 [02:55]
the user's source code
Speaker 1 [02:57]
source code.
Speaker 2 [02:58]
and we cannot
Speaker 1 [02:59]
cannot match the exact
Speaker 2 [03:00]
the exact line of code with
Speaker 1 [03:03]
code with
Speaker 2 [03:03]
intention which were
Speaker 1 [03:06]
activated or involved
Speaker 2 [03:07]
invoking.
Speaker 1 [03:08]
and the second we got there
Speaker 2 [03:10]
got the statistic about our usage
Speaker 1 [03:13]
Usage, like events,
Speaker 2 [03:14]
and like events.
Speaker 1 [03:15]
And it's also anonymous.
Speaker 2 [03:17]
anonymous and it was quite
Speaker 1 [03:20]
quite a tricky to make
Speaker 2 [03:21]
to match the
Speaker 1 [03:23]
the activity of users with the intentions from this event data.
Speaker 2 [03:26]
event data so for
Speaker 1 [03:29]
Reinforce our model.
Speaker 2 [03:31]
model, we
Speaker 1 [03:31]
We gathered six million
Speaker 2 [03:33]
6 million public
Speaker 1 [03:34]
public Jupyter notebooks from the web. We filter them out like a Python 2 version or
Speaker 2 [03:35]
jubilee. or just
Speaker 1 [03:42]
or just empty or maybe
Speaker 2 [03:45]
may be very old.
Speaker 1 [03:46]
very old notebooks.
Speaker 2 [03:46]
notebooks.
Speaker 1 [03:47]
and we also use our
Speaker 2 [03:48]
use our internal data
Speaker 1 [03:50]
internal data about usage.
Speaker 2 [03:50]
about usage with more than 1 million events.
Speaker 1 [03:55]
events with timestamps.
Speaker 2 [03:55]
with timestamps.
Speaker 1 [03:57]
And here's the example of
Speaker 2 [03:58]
example of the simple Jupyter notebook
Speaker 1 [04:03]
file with some metadata and cell structures in JSON.
Speaker 2 [04:08]
So before we get started to implement something
Speaker 1 [04:12]
something and create predictive models, we get some insights from this.
Speaker 2 [04:15]
from this
Speaker 1 [04:15]
6 million notebooks.
Speaker 2 [04:17]
notebooks.
Speaker 1 [04:19]
on the slide so basically some of the nobles
Speaker 2 [04:21]
those like 2.6% don't use
Speaker 1 [04:24]
don't use Python at all. There are some Python related Julia language or some exotic ones like
Speaker 2 [04:30]
like F sharp.
Speaker 1 [04:31]
And another interesting fact that more than 300,000 notebooks were with sensitive data, such as credentials, passwords.
Speaker 2 [04:41]
tokens, which is
Speaker 1 [04:42]
which is also quite a lot.
Speaker 2 [04:44]
in that
Speaker 1 [04:47]
data group of six million notebooks and also
Speaker 2 [04:52]
few distributions of some
Speaker 1 [04:53]
of some statistics. Here's like import stats which shows that about 15% of
Speaker 2 [05:00]
of users don't
Speaker 1 [05:01]
use import at all
Speaker 2 [05:02]
at all.
Speaker 1 [05:03]
And, well, the main case cover, then...
Speaker 2 [05:06]
cover them.
Speaker 1 [05:07]
figure with less than 10 imports per
Speaker 2 [05:11]
Notebook.
Speaker 1 [05:12]
And the same for folder structure, which was interesting, because about a third of users don't use any subfolders in their projects. Regarding technical stack, we use...
Speaker 2 [05:26]
We use TensorFlow for training our model.
Speaker 1 [05:30]
training our models
Speaker 2 [05:31]
By the way,
Speaker 1 [05:32]
By the way, PyCharm supports the
Speaker 2 [05:34]
the mission
Speaker 1 [05:34]
New version of TensorFlow fully supported.
Speaker 2 [05:36]
fully supports it, and we use the
Speaker 1 [05:39]
We use standard flow serving for production and for serving our
Speaker 2 [05:42]
serving our models and we use
Speaker 1 [05:44]
and we use flask to
Speaker 2 [05:45]
Use Flask to
Speaker 1 [05:46]
a pre and post
Speaker 2 [05:47]
post-processing our data sets via an Nginx
Speaker 1 [05:52]
and nginx. So to implement
Speaker 2 [05:55]
And our model of
Speaker 1 [05:58]
of intentions, we use
Speaker 2 [06:00]
two standard services.
Speaker 1 [06:00]
to one service for
Speaker 2 [06:03]
for processing data.
Speaker 1 [06:05]
processing data, and another for predictions. And regarding prediction...
Speaker 2 [06:08]
prediction so each action of the user were mapped
Speaker 1 [06:13]
to the vector.
Speaker 2 [06:15]
And then we use a LSTM model.
Speaker 1 [06:19]
and map this feature with the probability.
Speaker 2 [06:22]
of the next tutorial.
Speaker 1 [06:24]
of the next iteration. So the idea to get the list of
Speaker 2 [06:27]
of
Speaker 1 [06:27]
top top top useful intentions based
Speaker 2 [06:30]
based on the previous expectations.
Speaker 1 [06:32]
actions of user. So I can show you the
Speaker 2 [06:35]
you the scheme which is better for
Speaker 1 [06:36]
scheme which is better
Speaker 2 [06:36]
later.
Speaker 1 [06:38]
represent the idea of
Speaker 2 [06:39]
idea of the
Speaker 1 [06:39]
the architecture. So it's like the two-way
Speaker 2 [06:42]
two-way model where we have actions from the user's notebook, tokenized,
Speaker 1 [06:49]
tokenize this data
Speaker 2 [06:50]
this data and then make prediction use
Speaker 1 [06:52]
make prediction using LSTM and at the final step we add some probabilities to get the
Speaker 2 [06:57]
to get the final list.
Speaker 1 [06:58]
final list with
Speaker 2 [06:59]
with top-ranked
Speaker 1 [07:00]
ranked intentions. And the next slide shows
Speaker 2 [07:04]
shows the
Speaker 1 [07:06]
Simple demo of our model.
Speaker 2 [07:07]
of our model.
Speaker 1 [07:09]
So, on the left side it's like the old one, without any kind of
Speaker 2 [07:12]
kind of ML algorithm.
Speaker 1 [07:13]
ML algorithms. And the new one is
Speaker 2 [07:15]
is our AI intentions,
Speaker 1 [07:18]
where you can see the user
Speaker 2 [07:19]
the user loads some CSV file with pandas.
Speaker 1 [07:24]
file with pandas and set their target feature and after that with new model you
Speaker 2 [07:28]
the new model, you get the
Speaker 1 [07:30]
A train and test split prevails over others, whereas with the old one you just get the list of intentions. So that was the idea.
Speaker 2 [07:41]
the idea of the
Speaker 1 [07:43]
AI intentions and as a result
Speaker 2 [07:46]
we get the 60%
Speaker 1 [07:48]
60% accuracy for top one
Speaker 2 [07:49]
for top one intention.
Speaker 1 [07:51]
Intention and 92% for Top 5.
Speaker 2 [07:53]
top 5.
Speaker 1 [07:54]
Which is quite good
Speaker 2 [07:56]
deck and account
Speaker 1 [07:56]
taking account the fact that it's like the five options after you, let's say, upload your CSV file.
Speaker 2 [08:03]
CSV file
Speaker 1 [08:06]
The second part is about code completion.
Speaker 2 [08:07]
code completion. It's also a hot topic
Speaker 1 [08:10]
topic, and lots of companies like to get rid of data scientists or engineers.
Speaker 2 [08:15]
engineers with the AI algorithms.
Speaker 1 [08:18]
and for sure there are lots of existences
Speaker 2 [08:20]
of existing solutions for of small
Speaker 1 [08:22]
of smart helpers and code
Speaker 2 [08:24]
helpers and code completions a jet
Speaker 1 [08:27]
At JetBrains we already have
Speaker 2 [08:28]
have ML completion.
Speaker 1 [08:30]
a completion ranking, which we could
Speaker 2 [08:31]
which you could activate
Speaker 1 [08:32]
you could activate in your settings in
Speaker 2 [08:33]
settings in IntelliJ IDEA and PyCharm.
Speaker 1 [08:36]
PyCharm.
Speaker 2 [08:36]
There are many of them, like, you name it, from...
Speaker 1 [08:41]
from where my
Speaker 2 [08:42]
where major...
Speaker 1 [08:43]
major vendors, but at Datalore we'd like to create a specific
Speaker 2 [08:48]
a specific code completion model because data law works
Speaker 1 [08:52]
data lower work with some subset of
Speaker 2 [08:55]
subset of Python because it's about
Speaker 1 [08:57]
it's about data analysis and
Speaker 2 [08:59]
machine learning.
Speaker 1 [09:01]
learning.
Speaker 2 [09:04]
We have a specific machine learning vocabulary, so...
Speaker 1 [09:09]
but we can also use
Speaker 2 [09:10]
we can also use the whole domain for
Speaker 1 [09:13]
for pre-training our model.
Speaker 2 [09:14]
our model
Speaker 1 [09:15]
And also, where you work with Jupyter Notebook,
Speaker 2 [09:19]
Jupyter Notebooks, you have
Speaker 1 [09:20]
you have the structure of cells and this structure and sequences of
Speaker 2 [09:23]
also might be useful.
Speaker 1 [09:24]
also might be used to
Speaker 2 [09:25]
to get additional
Speaker 1 [09:26]
get additional input features. So with this project we also face some challenging
Speaker 2 [09:32]
some challenges with which are
Speaker 1 [09:35]
a large variety of
Speaker 2 [09:37]
of completion data.
Speaker 1 [09:37]
data and the
Speaker 2 [09:38]
and the classical
Speaker 1 [09:40]
classical imbalance of intentions data
Speaker 2 [09:40]
imagination. data because the
Speaker 1 [09:44]
the vast majority of our users don't use intentions at all, unfortunately.
Speaker 2 [09:49]
Unfortunately,
Speaker 1 [09:49]
So we have unbalanced
Speaker 2 [09:50]
balance problem
Speaker 1 [09:53]
And we use oversampling to solve that.
Speaker 2 [09:57]
Concerning pipeline
Speaker 1 [09:59]
so we're dealing with with the notebooks and at the first step we just
Speaker 2 [10:04]
merge or like join all the
Speaker 1 [10:07]
all the sales.
Speaker 2 [10:08]
and filter out
Speaker 1 [10:09]
filter out markdowns, some
Speaker 2 [10:11]
some images and metadata from the Jupyter notebooks.
Speaker 1 [10:15]
Then we use...
Speaker 2 [10:17]
We use byte pair.
Speaker 1 [10:17]
byte pair encoder for data compression
Speaker 2 [10:21]
for data compression, and we use last-end tokens with
Speaker 1 [10:24]
with different variety to
Speaker 2 [10:26]
variety to path the model for
Speaker 1 [10:28]
the model for predictions.
Speaker 2 [10:28]
predictions the next token will send.
Speaker 1 [10:30]
Wilson
Speaker 2 [10:31]
try different models and different value of n
Speaker 1 [10:37]
and at this step.
Speaker 2 [10:39]
step.
Speaker 1 [10:39]
And on the last step we just use the TopKeyPredictions to
Speaker 2 [10:43]
to understand the list of probabilities for them.
Speaker 1 [10:47]
next line of code or next piece of code for model architecture we use
Speaker 2 [10:52]
use a transformer.
Speaker 1 [10:53]
transformer because
Speaker 2 [10:54]
because it's...
Speaker 1 [10:55]
it's like a state of the
Speaker 2 [10:56]
of the
Speaker 1 [10:58]
the art for the last two years, especially for
Speaker 2 [11:00]
especially for NLP problems.
Speaker 1 [11:04]
But we use only an encoder.
Speaker 2 [11:06]
encoder blocks with positional embedding.
Speaker 1 [11:09]
positional embeddings in it. And the number of attention heads and size of
Speaker 2 [11:14]
and size of blocks also.
Speaker 1 [11:15]
blocks also vary.
Speaker 2 [11:16]
vary. And to implement this model, we generate bit-pair encoding, as I mentioned before, and we mapped it with
Speaker 1 [11:26]
mapped it with like most frequent
Speaker 2 [11:27]
most frequent units.
Speaker 1 [11:29]
and then we trained our model using the
Speaker 2 [11:34]
using the answer
Speaker 1 [11:34]
unsupervised approach where we have
Speaker 2 [11:37]
where we have a few tokens.
Speaker 1 [11:39]
tokens, and we predict the next one.
Speaker 2 [11:43]
And to show the
Speaker 1 [11:45]
The result of our
Speaker 2 [11:46]
of our model.
Speaker 1 [11:48]
have some simple example with
Speaker 2 [11:51]
with our current proof of concept as
Speaker 1 [11:55]
As you can see,
Speaker 2 [11:55]
As you can see,
Speaker 1 [11:57]
So, sometimes it shows quite a good accuracy, but the idea that you type some
Speaker 2 [12:03]
you type sum.
Speaker 1 [12:05]
some string and get the
Speaker 2 [12:06]
and get there
Speaker 1 [12:08]
and get the output for your next
Speaker 2 [12:10]
or your next function or component.
Speaker 1 [12:12]
or command so as a result we have
Speaker 2 [12:16]
have 57% top 1.
Speaker 1 [12:20]
accuracy and moreover it's only 200 ms
Speaker 2 [12:24]
milliseconds performance. So for the further
Speaker 1 [12:30]
further improvement and further steps.
Speaker 2 [12:32]
and further stays because there's
Speaker 1 [12:33]
there's always space to improve your
Speaker 2 [12:35]
to improve your model, we plan to add into our
Speaker 1 [12:40]
into our dataset.
Speaker 2 [12:41]
data set the right
Speaker 1 [12:41]
the runtime metadata as
Speaker 2 [12:44]
as an additional feature because it has
Speaker 1 [12:45]
because it helps us to understand
Speaker 2 [12:46]
helps us to understand the
Speaker 1 [12:47]
the consumption of each line or also
Speaker 2 [12:50]
Also, we can use this for...
Speaker 1 [12:52]
additional loss function. And we can also plan to use domain-specific
Speaker 2 [12:57]
in specific Python language to...
Speaker 1 [13:01]
create new intentions for
Speaker 2 [13:02]
for like the
Speaker 1 [13:03]
for the first project which I mentioned, and the idea was to find some
Speaker 2 [13:06]
find some patterns.
Speaker 1 [13:08]
some patterns during the
Speaker 2 [13:09]
during the data science workflow to create a new
Speaker 1 [13:13]
create a new intentions for datalore. And also we plan to
Speaker 2 [13:16]
we plan to implement the evaluation
Speaker 1 [13:18]
the evaluation metric into
Speaker 2 [13:19]
into Datalog product.
Speaker 1 [13:21]
Datalore product to understand the
Speaker 2 [13:22]
to understand the real performance of our feature.
Speaker 1 [13:27]
feature and this code completion will be implemented in the coming
Speaker 2 [13:32]
in the coming update.
Speaker 1 [13:32]
update of the datalore.
Speaker 2 [13:35]
So it's also a good time to mention
Speaker 1 [13:38]
to mention my teammates.
Speaker 2 [13:39]
and my teammates. Adam from Boston.
Speaker 1 [13:40]
from Boston and Vladimir from Moscow.
Speaker 2 [13:42]
from Moscow, so we...
Speaker 1 [13:44]
now working on this
Speaker 2 [13:45]
project and project relates to machine learning at Datalore
Speaker 1 [13:52]
And the final slide is about references which
Speaker 2 [13:58]
from which we got the inspiration.
Speaker 1 [14:00]
the inspiration to this. to these projects and for example, the second one is
Speaker 2 [14:07]
For the second one, attention is only needed
Speaker 1 [14:08]
all you need is not about
Speaker 2 [14:10]
not about some personal development or mindfulness.
Speaker 1 [14:14]
mindfulness or happiness
Speaker 2 [14:14]
happiness is just specifically about the neural nets transformer
Speaker 1 [14:20]
architecture. So that's basically it. Thank you for your attention.
Speaker 3 [14:31]
All right. Thank you, Vasily. We have lots of time for questions. Any questions in the audience?
Speaker 4 [14:43]
Thank you for the talk. And in regards to code completion, I have a question. Then maybe if nobody has a question, then I'll ask about AI intentions. But first, the code completion. So how did it, how did you, what's the specific, like, the details? Are you predicting, like, based on n previous characters, the next character? Or is it a word-based, like, or is there some rule-based technique in there in order to alleviate the possible problems?
Speaker 1 [15:08]
Right, so we use different number of
Speaker 4 [15:08]
Right.
Speaker 2 [15:10]
number of
Speaker 1 [15:12]
words and symbols to create the prediction for the next one and we try
Speaker 2 [15:16]
we try different like skipping window to create the prediction for for the next line of code
Speaker 1 [15:22]
line of code. And we just choose the
Speaker 2 [15:24]
the one with the
Speaker 1 [15:25]
one with the best performance.
Speaker 2 [15:26]
the best performance.
Speaker 5 [15:36]
First of all, thanks for the talk. And one thing I'm a bit confused about is when you talked about the class imbalance, did you manually tag those or how did you get the actual target intention?
Speaker 1 [15:53]
So as I mentioned,
Speaker 2 [15:54]
As I mentioned, the problem with unbalanced data
Speaker 1 [15:59]
with unbalanced data and for that we use like oversampling with synthesized data of
Speaker 2 [16:05]
of
Speaker 1 [16:06]
uh Intentions Evoking
Speaker 2 [16:08]
a walking and
Speaker 1 [16:09]
and we label this
Speaker 2 [16:10]
these samples.
Speaker 1 [16:12]
as intentions.
Speaker 2 [16:14]
so
Speaker 1 [16:16]
Because for imbalance problem you have several approaches like under-sampling and over-sampling. So we choose over-sampling because we...
Speaker 2 [16:24]
because we gathered six million millions
Speaker 1 [16:28]
public Jupyter notebooks. Also we match them with our
Speaker 2 [16:30]
with our 1 million events of usage of our platform.
Speaker 1 [16:35]
Usage of our product, like the intentions,
Speaker 2 [16:37]
the intentions events.
Speaker 1 [16:38]
events with timestamps. And this helps us to generate the
Speaker 2 [16:42]
generate the
Speaker 1 [16:43]
Additional classes for Intentional and
Speaker 2 [16:45]
and to uh
Speaker 1 [16:46]
get the balanced problem between classes.
Speaker 6 [16:59]
I was wondering how much faster you think you can make it in the near future. Because 200 milliseconds is already pretty fast, but still on the edge of real interactivity.
Speaker 1 [17:15]
Right, thank you for that question.
Speaker 2 [17:16]
question it's really
Speaker 1 [17:17]
It really depends on performance.
Speaker 2 [17:19]
performance because still
Speaker 1 [17:20]
still with the current model we can
Speaker 2 [17:22]
model we can make it faster but
Speaker 1 [17:23]
faster, but with less
Speaker 2 [17:24]
but with less experience.
Speaker 1 [17:25]
accuracy and also we have other limits
Speaker 2 [17:29]
other limits such as web-based product because data lore is
Speaker 1 [17:32]
DataLore is in cloud.
Speaker 2 [17:33]
is in cloud, you don't need some local
Speaker 1 [17:34]
some local environment or
Speaker 2 [17:36]
or your...
Speaker 1 [17:38]
Machine with lots of memory.
Speaker 2 [17:39]
So we stuck into
Speaker 1 [17:40]
we stuck into that limits and I think
Speaker 2 [17:43]
I think the...
Speaker 1 [17:45]
threshold of 200 milliseconds is quite
Speaker 2 [17:48]
is quite good for data
Speaker 1 [17:50]
data science workflow because you don't need
Speaker 2 [17:53]
don't need to think what
Speaker 1 [17:55]
like to think first when you write
Speaker 2 [17:56]
when you write the next line of code and we
Speaker 1 [17:59]
aim to do this
Speaker 2 [18:00]
this figure for the
Speaker 1 [18:02]
for the next version.
Speaker 2 [18:03]
the next version.
Speaker 3 [18:08]
You want to ask again?
Speaker 4 [18:11]
So I joined two minutes later, so maybe you talked about it in the very beginning, but about these AI intentions, where do you get the ground truth on the intentions? Where does it come from?
Speaker 1 [18:23]
So, in DataLore we have intentions.
Speaker 2 [18:26]
have intentions, like it's just a code
Speaker 1 [18:27]
It's just code suggestions. And when the user...
Speaker 2 [18:30]
other
Speaker 1 [18:31]
press this button or activate it, we collect all the
Speaker 2 [18:34]
collect all the data about these events, like the type of
Speaker 1 [18:37]
like the type of intention and the type of code which user generate. So we got this
Speaker 2 [18:41]
So we got these historical data.
Speaker 1 [18:44]
data and use it for train our model
Speaker 3 [18:50]
Anybody else? I have one more question. How did you determine that there were 300,000 notebooks with sensitive information?
Speaker 2 [18:59]
Basically, we just count them using...
Speaker 3 [19:02]
But not by hand, right?
Speaker 2 [19:03]
But not by hand. No, of course not.
Speaker 3 [19:04]
No.
Speaker 1 [19:05]
We use like a simple string
Speaker 2 [19:06]
string mask, which
Speaker 1 [19:08]
with regular expressions to
Speaker 2 [19:08]
regular to get the pattern
Speaker 1 [19:11]
pattern of best
Speaker 2 [19:11]
of passwords and
Speaker 1 [19:14]
like the form of the regular sensitive data.
Speaker 2 [19:15]
data.
Speaker 1 [19:19]
Right then
Speaker 3 [19:19]
then if there are no more questions let's thank this oh there is one
Speaker 1 [19:27]
How do you split the code of those many notebooks into blocks for suggestions and for training?
Speaker 2 [19:36]
as I shown on the
Speaker 1 [19:37]
shown on this slide with the
Speaker 2 [19:38]
with
Speaker 1 [19:40]
with the sample of Jupyter notebook you can easily
Speaker 2 [19:44]
can easily understand the sequence of cells and
Speaker 1 [19:47]
and you can filter them with some conditions and after that you can
Speaker 2 [19:53]
can concatenate them and split by
Speaker 1 [19:55]
split by, let's
Speaker 2 [19:56]
let's say by
Speaker 1 [19:57]
by packages or libraries,
Speaker 2 [19:59]
depends on your goal.
Speaker 3 [20:10]
All right, so if there are no more questions now, let's thank the speaker again.
