Dear viewer, these subtitles were generated by a machine via the service Trint and therefore are (very) buggy. If you are capable, please help us to create good quality subtitles: https://c3subtitles.de/talk/418 Thanks!
And now it is my particular pleasure to
announce Professor Professor Rachel
Grinstead and Eileen
Collins can Islam and Rebekah OverDog
from the Privacy, Security and
Automation Lab from Drexel University.
They are quite old hands at speaking at
the Congress already.
And so.
Well, please
give them a warm round of applause.
And there we go.
It would be absolutely wonderful if we
could get the present there.
Thank you.
Yes, that's much better.
Hello, I'm Rachel Green, stat
professor at Drexel University and
where I lead the Privacy, Security and
Automation Lab, this is joint work with
my students, Eileen Coskun Islam
and Becca Oberdorfer, who will be
speaking later.
So we're going to talk today about
authorship, attribution in source code
and in social media.
So first, I'm going to talk about
stylometry, which is how we do
authorship attribution in my lab usually.
So the idea behind it, the theory behind
it is that everybody's writing style and
speaking style indeed is unique because
we all learn language individually
on an individual basis.
And each of us, even though we might
speak the same language, speak sort of
our own individual dialect of it.
For example, in English there are
regional differences, whereas some people
may say that one piece of furniture is a
couch, whereas other people might say
it's a sofa.
Furthermore, there are there are words
that have similar meanings, but they're
actually different words like although in
though and you know, which ones people
particularly prefer is sort of a
stylistic idiosyncrasy in
writing. People may use the same word
with different spellings.
And there are also just many ways to
express very similar ideas.
Like someone might say, the fork is to
the left of the plate versus the fork
is at the plates left.
So these differences are how we,
in writing and documents can distinguish
authors often in many times.
And that's a lot of the work that we do
in my lab, which is the Privacy, Security
and automation lab.
So this is a research lab at Drexel
University. It has about 10 students
in them in a mixture of graduate and
undergraduate students.
And in general, we study sort of how to
have machines, help humans make decisions
about security, privacy and trust,
often using machine learning and natural
language processing techniques.
In particular, we're very interested in
what we can learn when we analyze
unstructured in some way structured sort
of human textual communication.
And this is what we've spoken at
ETECSA about in the past.
So Mike Brennan spoke at
2063 on sort of privacy
and stylometry and how authorship
recognition techniques can
be attacked and and how they could
be deceived.
Again, in twenty eight, C3 with Saudi
Afroz and Eileen and Saadia
spoke two years ago on
applying stylometry to sort of online
underground markets.
And this year we're going to talk about
source code and costumey.
And Salvatore, people always ask us
sort of what about source code, what
about tweets, stuff like that.
So we're going to answer some of those
questions in this talk.
In general in the lab, we also do a
number of a lot of work, like doing a
social network analysis of online
communities and also textual analysis and
also studying the secure machine
learning.
So instead, we were a privacy
lab, sort of what is the connection
between privacy and stylometry?
Well, so there are very good techniques
for location privacy that the privacy
enhancing technologies community has
worked on.
You're probably pretty familiar her
my T-shirt and mixes
in other types of techniques.
They could hide your IP address from
people on the Internet.
But in some cases, when you're expressing
yourself in text online, that might be
insufficient. And that's where my
research comes in.
Stylometry can be used to identify
authors based on their writing.
And this is important because this
is a potential threat to people that are
exposing crime and corruption, political
organization, especially if they're
speaking in first hand testimonial
accounts.
And it's also just important for normal
people who want to express their opinions
or write code and share it online without
necessarily having the thing that they
wrote online, follow them forever through
their life like a dossier.
So let's go back to stylometry
and let me talk a little bit, just give a
sort of short tutorial on how it works.
So basically.
So true methods
that are used today use machine learning
and so so you have two authors, Cormac
McCarthy and Ernest Hemingway.
So they're both authors that have
somewhat distinct styles,
so coming here, they might say, you know,
what's the bravest thing you ever did?
He spent in the road in bloody phlegm
getting up in the morning, he said.
And then there's Ernie Ernest Hemingway.
He no longer dreamed of storms,
nor women, nor of great occurrences, nor
of great fish, nor fights, nor contests
of strength, nor of his wife.
So the question is, how can you tell
the difference between these people
so we can just feed the text straight
and we have to extract features from it?
Other types of features we use an
example of this might be the frequency of
function, words, function.
Words are sort of the small little words
that don't necessarily mean anything.
And also look at, say, the frequency of
punctuation.
It tells us something about the
structure.
We also use a lot more features in our
work, which we'll talk about later, but
we feed these into a machine learning
model. In many cases, we'll use a support
vector machine.
Sometimes we'll use random forest.
And a good model generally needs a sort
of forty five hundred to seventy five
hundred words of training data and
greater than or equal to a thousand
features. These these are maybe many
features of the same type like
word Ingrams, for example.
Oh, I'm sorry, am I not being,
am I? Is this better?
I hope that I hope the
system is working.
Sorry about that,
OK.
So to actually to actually
use this, say we have an unknown
document, which is our text, our test
document. Just remember the things that
you put into your head or there forever.
He said you might want to think about
that. And we don't know whether this is
written by Ernest Hemingway or Cormac
McCarthy.
So we extract features
for from this document.
Now, this is a very short text snippet
for best results.
We need about 500 words
and we'd ask the model who wrote it,
and it would tell us that it's Cormac
McCarthy, which indeed it is.
So in general, stylometry
methods are pretty good
when you're dealing, especially when
you're dealing with sets of authors in
the sort of one hundred authors range
where that's sort of the world of
suspects that you have, then Bazian
tend to have a method that works at sort
of above 90 percent accuracy.
Now these methods can be scaled.
People have done experiments, a couple at
all, 10000 authors
and younan it all in
with over 100000 authors.
And you can see that even in these cases,
the results are much, much better than
sort of random chance.
Which do allow you to sort of narrow,
narrow the world of suspects quite a bit.
So previously, ask
the other question that we asked in my
lab was sort of how how
strong are these techniques
when people are actually trying to fool
them?
And we found that people in general
were able to reduce the accuracy of these
techniques by writing in a sort of
a specific way to try and hide the
writing style or to imitate another
author.
We had to actually ask people to imitate
Cormac McCarthy in this case.
Now, I wouldn't necessarily recommend
just doing that. If you wanted to hide
your writing, you'd probably want to
verify in some way that you'd actually
done it correctly.
So we actually do have some tools in our
lab.
Jay Stilo is an authorship analysis
tool and not a mouth
is a sort of authorship anonymization
tool, which is a very much a work in
progress.
We have these are available on
our GitHub page.
We'd love to have your comments, help,
thoughts, et cetera, on them.
And we looked at underground forums,
so.
This is an excerpt from the Carters
forum where people trade sort of credit
card information, and
to do this work, we had to actually
extend our analysis told to German.
So just let us talk in German.
And these are the types of features we
use, the frequency of Ingrams, the
punctuation, the special characters,
the function words in this case, German
specific function, words and parts of
speech. And that's another case where you
need specific
parts of specific language, specific
features.
So the question that
you might wonder is like sort of is this
purely an academic concern?
Do people actually use stylometry
in the real world to actually identify
people who might not want to be
identified?
And the answer to this is yes.
So in a rather
sensational case, J.K.
Rowling, who as we know is the author of
the Harry Potter novels, wrote
another book under a pseudonym, Robert
Galbraith and Uihlein
Associates is a stylometry firm.
And they actually did some work
using tools that are
part of our analysis engine, actually, as
well on the request of a reporter
who'd receive an anonymous tip over
Twitter after their linguistic
analysis, he felt confident enough to run
with this story and indeed did expose.
J.K. Rowling is the author of this book.
And our doppelganger finder code, which
we designed to give the sort of the
probability of two accounts are
this are the same person
is actually used by the FBI.
We pointed them in at our GitHub and we
don't know exactly what they use it for
exactly. But they they did tell us that
they found it useful.
So and there are many expert
witnesses that use this in forensic
proceedings, legal proceedings throughout
the world.
I know the most about US law where
forensic linguistic evidence is covered
under the Fenwick opinion,
which speaks to sort of how it can be
used and how it can be considered.
So, OK, so this is all the
stuff that we've done and gives you some
context, so hopefully you have an idea a
little bit about stylometry is and what
it's what it how
it works.
But we're going to talk today about sort
of to particularly kind of interesting
and difficult cases.
The first one is, what if you have an
unknown Twitter feed?
Can you learn its author from blogs
or from comments on a news site like
Reddit?
Like because you might not have a Twitter
feed for that person.
And the answer to this is yes.
However, if you do have a Twitter feed
for the suspect, then you should probably
use that instead.
And then we always get this question
about what? About source code.
Can you detect some of these source code
authorship from their style?
And the answer is that, yes, we can do
that, too.
And particularly neat about this
is even if you run it through an off the
scanner, it still works.
So I'm going to now turn the talk over to
Eilene, who's going to talk about that
work.
Hi, everyone.
So now you'll be looking at stylometry
and here we are trying to find out
who wrote this piece of anonymous
caught by looking at their coding
style. And there are two common scenarios
we can think of.
One source code at authorship attribution
comes to mind.
The first one is, let's say that Elissa's
computer got infected and
she has a piece of source code left
from the malware.
And Bob has a collection of malware
with known.
So Bob can look at his collection of
malware to identify who's Alice's
adversary was.
And in the second scenario, this applies
to plagiarism.
Let's say that Alice got an extension
to her program assignment and heard
Professor Bob has everyone
else's submissions.
So Bob can look at everyone else's
submission, compare it with Alice's
new submission to see if Alice
plagiarized.
And in this case, we're talking
about some serious security enhancing
waste of sorting out authorship,
attribution.
But unfortunately, sometimes security
enhancing technologies are actually
privacy in infringing cases.
For example, said
Molik, poor he's their Web
programmer. He was sentenced to
death because he was identified
the programmer of a porn site
by the Iranian government.
And so he was held
under solitary confinement for
one year without legal representation.
And his family says that he's also a
permanent resident of Canada
and he didn't know that the porn
site developers were using his
photo uploading software.
And so it also said that
if you knew that this was going to be
used by a porn site, he would never put
his name there because it's illegal in
Iran.
And under after that, he
says that under pressure, he said that
he regrets his actions and now his
death sentence is canceled.
When you look at source code, authorship,
attribution, we can define this as
a machine learning problem with four
main experimental settings.
In the first one we can think of software
forensics.
And here we have multiple ORTA,
which corresponds to Multiclass Lerner.
And this is in an open world setting,
which means that we don't know the
suspect set in the regular
case of authorship attribution, which we
can also call psychometric plagiarism
detection.
We have the multiclass case with multiple
authors and we know the suspect said
here. So it's a close work machine
learning problem.
And we can also apply source code
stylometry to a copyright investigation
where we have two parties in the dispute.
So it's a two class problem and
clothes were world problem because we
know both of the sides in the dispute
and in authorship verification.
We would like to answer is
this person who claims to have written
this piece of source code, did they
really write it or did someone else
write it?
And this is kind of a two class, one
class formulation, which we will look
into detail later.
And this is an open class problem
because this was either written by the
claimed person or it was written by
someone that we have no idea about.
And here is a table of summary
of our main results.
You can see that with the two hundred
and fifty class altar's test,
we get nine to five percent accuracy in
identifying them.
And this is a very high accuracy
compared to previous work.
And this indicates that we introduced
a new principal method with a robust
and syntactic feature set for
performing source code stylometry,
which has not been done before in this
scale and in this way.
In order to do it, in order
to understand coding style, we have
to look at programing features,
our programing style features.
And for that, first of all,
we have a piece of source code
and we look at some lexical features
like variable names
and the use of C++ keywords.
Then we look at layout features like the
spaces, the tabs,
and we extract those from source
code.
After that, we preprocessed the source
code to obtain its abstract syntax tree,
which reveals structural features.
So it's the grammar of the code.
And for that we use the fuzzy
abstract syntax tree parser that
was provided by our collaborator Fabian
Yamaguchi, who presented yesterday.
And since it's a fuzzy parser, it can
even handle incomplete pieces
of code.
And once we have the abstract syntax,
we extract syntactic features
such as the not deps or the
abstract syntax tree, not types
or not type frequency,
inverse document frequency.
And we solve a recurring subset
of features coming up in many of our
datasets with hundreds of
authors and thousands of programing
files.
And for example, we see here that most of
these in this list are syntactic
and these features are the most important
features because they have the highest
information gain.
And the syntactic features are mostly
the note that
in the abstract syntax tree
abstract syntax to not term frequency
or TFI depth.
And also we see some lexical features
like C++ keyword
typedef and some layered features
such as the number of types
that were used.
And this slide
illustrates our general method in
many different experimental settings
in order to do experiments, first of all,
we need the datasets of you went ahead
and scraped the submissions
of contestants from
Google called Google Culture is
an international annual programing
competition.
And since 2008, Google has been
publishing their correct submissions
online. So we you went ahead and
scraped all the correct C++
submissions from 2008 until
2014.
And we ended up with a data set with
more than 100000 users.
And once we have the source code, we
preprocess it with the fuzziest
Pozzo urine and then we extract
lexical, syntactic and layered features.
And as a classifier, we use a random
forest to avoid overfitting
with three hundred trees and these
trees by majority voting to the final
classification, depending on our task.
And I would like to give some statistics
about our Google Kojm dataset.
We saw that in the 2014
data set, which we used as our main one
because it was the largest one in C++.
The average lines of code was 70
per solution.
And in this programing contest,
everyone is implementing the
same problem or the same functionality
at the same time and
in a limited time.
And whenever we are performing a machine
learning task, we always train on
the same problems that people answer to.
And then when we are testing, we choose
a problem that was not in the training
set.
So it makes it a further, more difficult
machine learning problem because the
question was not seen in the training set
before.
And here on the right pie chart, we see
that C++ was the most common language
and that was also true for other years.
Now, I will go about some scenarios
where we can apply source code,
authorship, attribution,
and in the first one, like I'll give
examples as I'm talking about the
scenarios, I would like
to explain the first one, which is
regular authorship attribution.
By giving the Satoshi example, everyone
is trying to find out who Satoshi is and
we have Satoshi source code as well.
So like from the initial contributions
or comments on get from the Bitcoin
repository, we
have his card, but we don't know who this
anonymous programmer actually is.
So we can train
our data with a suspect
set.
And after that we can test on
this initial Bitcoin call to see
who Satoshi is.
And for this experimental setup, we took
two hundred and fifty Auteur's trained
on their files and we had 2250
anonymous program files.
And when we trained and tested, we
got 95 percent accuracy incorrectly
identifying these more than 2000
files.
And if we only had a suspect set
for Satoshi that we could train
and we would have the like.
If you had a suspect set for Satoshi,
this would be the training
part. And then we will use
the Bitcoin code like the initial
Bitcoin code for testing and
we might be able to predict who
the good contributor
Satoshi might be.
Not that we are trying to do this, but
this is just an example.
In the second case, we will talk about
obfuscation.
There are several reasons people try to
obfuscate their court to make it
unrecognizable.
First of all, you might have plagiarized
then you might be trying to hide that you
copied someone else's work or
you might have a malware and you might be
trying to make it unrecognizable so that
it won't be detected.
Or in other cases, you might
just be trying to stay anonymous
and hide your coding style.
But we saw that our authorship
attribution technique is not affected
by common off the shelf commercial
obfuscatory.
I'll give an example with the obfuscatory
that we use, which is like you can buy
it like I think for four hundred dollars.
It's called Dynex.
We are not related to it.
We just use it because it was the
cheapest commercial one
and a widely used one
here.
In this example, we will see how C++
code is obfuscated.
We see some variable names, they are
being hashed and all the
spaces and comments are being
stripped, if there are any numbers,
they are going to be replaced
with a combination of hexadecimal,
binary and decimal numbers.
And also, if there are any characters,
they are going to be replaced with
hexadecimal escape's.
And you can choose different settings for
your harshing or your combinations.
And we see that like everything is
refactored, but the functionality
or the structure of the program remains
the same. And as long as the structure
is the same, our features are not
affected by this obfuscation.
As a result, we saw that when
we tried to the authorship attribution on
obfuscated code versus original code
with twenty five alters, we
got twenty nine to seven percent
accuracy in both of them.
So our code is,
our method is impervious to
such common
off the shelf obfuscatory.
But this is only for this
obfuscatory, which is not changing
structure or functionality.
Oh another case is copywrite
investigation.
I would like to give a copyleft example
here.
Copyleft software is free
but it still has a license.
So you have to you can modify
it, you can use it, but you have to make
sure that you still include the copyleft
license that it came with.
And in this example, we
would like to see that this program would
take a copyleft code and then
make it copywrite.
There was a very famous case in north
California a few years ago.
It was with Jacobsson versus
Katzir and Jacobsson
had JOA model railroad
interface called the T put
an artistic license on and the artistic
license is less restrictive
than the copyleft license.
And after that, Katzir, who is also
interested in railroad models and
he is working for railroad
harvest as a software developer.
He took this call and then he
put a copyright on it and he started
distributing this commercially.
And also he filed a patent using
Jacobsen's court.
And after that, this was on
court. And some people claimed that
like since this is just artistic license,
he can do whatever he wants with it
because it's free could.
But that was not the case.
Even if it's an artistic license, you
still have to make sure that when
you modify it, it still has an artistic
license and everyone else can use
it the same way the first person intended
it to be used.
And this can be
used. This can be experimented
in a two class machine learning problem.
In the first class, we will have the
copyleft quote from Jacobsson and
in the second class we will have the
copyright code and we will compare them
to each other to see if any code
was taken from the other one.
And in this case, we had
20 pairs of altars,
which means that we had 40 orders each
with nine files, and we tried
to identify their files correctly
and we had 99 percent accuracy
in identifying these.
In the Ford case, we will look at voter
verification here.
We are trying to find out if this person
who claims to have written to Scott, is
he the real programmer or was it written
by someone else?
And this is a two class problem,
but it's not exactly to class because the
first class is only Mallory.
Mallory claims to have written the test
code and and we train
on Mallory as the first class.
We also train on a second class.
That's a combination of several other
authors. And all these are
the same problem solutions
or like each one corresponds to
the same problem from different alters.
And must we train on these two classes?
Here we have the code that Mallory claims
to have written and we have calls from a
bunch of other random authors.
And in this task, we
reach 93 percent accuracy
in 80 different experimental
setup. So that means
that hundreds of different users with
thousands of different files.
We also wanted to see if programing
style is consistent throughout years,
because if, yes, when we're constructing
our data sets, we can mix and match from
different years.
And we took
we found the contestants that were bought
in 2012 and 2014.
And here is an example, and
this is a random example of their, quote,
the same person in 2012 and 2014.
The layered features look extremely
similar.
The structure is very similar.
The four comes at the same depth.
And we see the lexical features such
as the variable name is very similar,
except that in 2014 they
decided to capitalize the T.
And as a result, we were
able to identify 25
authors that were bought in 2012
and 2014, but 88
percent accuracy, the 88
percent might seem low to you after
hearing the previous results with 99
or 93.
But in this case, when we took these
25 out authors just within
2012, we were able to identify
them with 92 percent accuracy.
So it's just a four percent drop in
accuracy, which shows that coding
style is up to some degree
persistent throughout years.
We also wanted to gain some insights
about coding style, so we wanted to
see how people implement
difficult versus easier functionality.
And we took a set of six to do authors
that were able to answer 14 questions.
We took the seven easy problems and said
seven more difficult problems.
And we saw that these authors
program in style was more unique when
they were implementing
harder functionality.
As we can see, with the five percent
increase in accuracy, we were able
to identify them with 95 percent
accuracy.
We also wanted to see the differences
between advanced programing versus a
programmer that has a smaller skill set
and how this is reflected to their
coding style.
And we saw the.
Advanced programmers had a lot
more unique coding style
compared to coders that had
a smaller skill set, and the difference
here is 15 percent.
And this shows a large
and very significant difference in
coding style.
Oh, in the future, source
code, authorship applications,
source code, authorship, attribution can
be applied to many different
areas.
For example, we can
use this to find programmers
or the coders of malicious
code. We can look at open source
repositories and find
anonymous people who are contributing
malicious code and try to identify
them by comparing them to other
good contributors.
Or we can identify the styles
of coders who have a
vulnerable style by looking at the bug
numbers they have on Gett or
another Tengiz companies might use this.
For example, let's say they're interested
in a particular coding style.
They can train on it and after that
they can search for that on get to
recruit employees
directly from get.
And when we compare our work to
previous work, we see a huge increase
in accuracy, even though our data set
is larger in magnitude compared
to theirs, the last two lines
are results with the nine
to five percent accuracy and 250
authors.
So this shows that our method
is with the syntactic
features.
It's doing a lot better
and the previous methods
did not use any syntactic feature said.
I would also like to thank our
collaborators, Dr.
Frank from
the United States Army Research
Laboratory, Dr. Clairvaux from United
States Army Research Laboratory and
really from University of Maryland,
Dr. Ivan Narayanan from Princeton
University and also Fabia Yamaguchi from
University of Getting It.
And I talked about a particular
domain, which was source code.
Now, BECC is going to talk about other
domains and cross domains, stylometry.
Thanks.
All right, so as you just saw from
Eileen's presentation, we're really good
at this.
We are very good at this in a lot of
domains as well.
So the ones I have up here, for example,
source code, of course, but also anything
you really put on the Internet we've
looked at as a community.
So we have e-mails, chat, messages,
even things you don't put on the Internet
like books or historical documents have
been studied. And in a few slides, you'll
see just how good we are at these types
of things.
This is Rahm Emanuel and this
is his Twitter feed.
Rahm Emanuel is an American politician.
He's currently the mayor of Chicago.
And while he was running for his office,
a rogue Twitter feed was developed
to imitate his Twitter feed.
This is not Rahm Emanuel's Twitter feed.
This Twitter feed was written instead by
a a man named
Dan cincher,
and this is a really good example of why
we would need to use stylometry kind of
in the real world.
And if we have Twitter feeds, we can test
on Twitter feeds and we do really well.
The problem that I'm going to discuss
today arises if Dan Cincher
here didn't have a Twitter feed to
compare it to.
So he is a writer, so he has a lot
of writing. So if you didn't have a
Twitter feed, what we could hopefully do
instead was take a number of suspect
authors. And during the campaign, he was
actually named possibly
as one of the suspects.
So we would have some data on a list of
suspects. And if they weren't, all
Twitter feeds of some of them were blog
posts or articles that they'd written.
Hopefully we'd still be able to identify
the author of The Rogue Twitter feed.
So my main problem here is domain
adaptation and stylometry.
We're given a sample text in some domain
and we're trying to identify the author
of some of their document, which is in a
distinct domain.
The features that we use for this
analysis.
Some of them are up here.
First does bag of words, bag of words is
really popular not just in stylometry,
but in natural language processing in
general.
These are, for example, how many times
you use the word the how many times you
use the word computer, etc..
Another popular one.
And so I'm tree and natural language
processing our character or word and
grims. And there's an example of
character diagrams underneath
and other specific features, function
words or stop words.
So these are non content words, basically
words that don't mean anything for to
the and part of
speech tags and part of speech.
Anagrams are also important and not
context specific.
It's also popular to combine a bunch of
features into one what we call a feature
set, here's a popular one that works well
within a bunch of domains known as write
prints.
You can see it's broken up into lexical
syntactic content.
And on the bottom of the screen should be
misspellings as well.
But you can add other features
like a cut off.
When we're looking at Dumain adaptation
specifically, we're talking about
different domains and types of places
where people are writing things, it's
important to look at non content features
because if you're writing in different
places, you're probably writing about
different things.
So the ones on the screen here are
some examples of those.
The one that's been studied most
extensively in this context are function
words. So these are stock words.
You can see the accuracy's are pretty
good with these words.
The first example up
there with eighty one percent accuracy
had eight people write different
texts in different genres.
So they were asked, for example, to
recreate the story of Little Red Riding
Hood and then ask to write an essay on
something else. And compared this isn't
exactly domain in the way that we're
discussing it today.
That's more genre
or topic.
Similarly, books were
analyzed in the second grouping up here
and were divided by genre and
topic as well.
And all function words were used.
So I said, we're really good at this, we
are you
can see across it within a bunch of
domains of emails, we get eighty six
percent accuracy. The bottom two lines
are my own work getting and
ninety eight percent accuracy, almost 99
with Twitter feeds and
using blog entries, we get about a ninety
three percent accuracy.
So we do pretty well.
The lower accuracies for chat messages in
Java form comments are because they're
using a smaller amount of text for the
testing document.
And as Rachel mentioned the beginning,
you want something closer to five hundred
words for your testing documents.
This is a tweet on your
left and a blog
on your right.
These are from our data set and were
written by the same person.
The tweet has about, I don't know, three
real words in it that aren't
misspelled or replaced with something
else, but you can see the blog
on the other side of the screen is very
well constructed. This correct
punctuation that there aren't
replacements for short words.
We don't see any of that.
So you can really see the challenge here
in trying to identify the author of this
tweet or a group of tweets that look like
this from a blog that looks like
that.
And that's really our challenge.
The data we collected for this project,
we collected five hundred
tweets and blog users and then thirty
eight Reddit comment, Reddit users who
also had Twitter feeds.
We collected the Twitter and blog users
by simply querying Twitter for
the phrase dot word, press, dot com,
and we're able to collect tons and tons
of data linking those
two accounts.
And then for Reddit comments,
there's a sub Reddit called our Twitter
where people post their Twitter handles
in order to gain more followers.
And so that was a very easy way
to link them across accounts.
However, they didn't have as much data in
there. So were we were only about we were
only able to get about thirty eight users
for that data set. But it works well to
confirm that our methods are working
across different domains and not simply
for blogs.
Possible solutions for this work,
the first is looking at
bright prints, which I showed in the
beginning, kind of throw as many features
at it as you can and hope it works.
The second is,
what if we were very careful about what
features we selected? Instead, we only
fixed features, for example, that aren't
context specific.
And so we look at function words as
others have in the past.
And the final is that we look at our own
method called Doppelganger Finder, which
I'll get it later.
These are the domain results for
blogs and then tweets and then Reddit
comments and then tweets.
We have two different Twitter data sets
because one was collected with the blogs
and the other with tweets. And you can
see that we do really, really well.
The purple lines are function words
and they don't do quite as well as the
right prints, which are the bluish lines
on the screen.
But in general, we're doing pretty well
with this.
The green lines are the cross domain
results, so
you can see that there's a huge gap in
accuracy.
So it's if we're testing on blogs
and then her training on blogs and then
testing on Twitter feeds or training on
Reddit comments and testing on Twitter
feeds. And so you can see that we
do very poorly and that these results are
unacceptable using the first two methods
which are right and then the careful
feature selection of function words.
So what do we do about it?
Doppelganger Finder is a
new algorithm that was presented,
it was created to link user
accounts across cyber criminal forums and
this kind of naturally seems like it
would work for a problem, because really
what we're trying to do is link accounts
across the Web.
This method works by calculating
the probability that each author wrote
another author's documents and then
for each pair of authors combined
these probabilities and every probability
above a certain inputted threshold is
considered to be the same person and
below it is considered to be different
people. For example,
we have some author, author,
AI, and we find
the probability that author, a real
author is documents and that author E
wrote authorized documents.
And we do this for all of them.
And then whichever probabilities are
above a certain threshold we
use, we say that they're the same author
and if they're below, we say they're
distinct. This code can be found on
GitHub at the bottom of the screen.
It also appears at the end of the
presentation, if you miss it,
we are actually able to augment this
doppelganger finder algorithm to work
better in the domain adaptation case
as well. Here we had to we had to compare
it to EFG, all of them
over here. We don't have to compare
A to B, C and D because they're all in
the same, let's say, Twitter.
If they're all on Twitter, they're all
tweets. So we know they're not written by
the same people. They're distinct.
And we get a little bit of an advantage
here. And the algorithm and also we don't
have to use a threshold, which is
definitely a huge advantage.
We just take the highest of all the
probabilities because we know that
they're somehow linked in even
the open world case.
And the open road case is one where you
don't know, the suspect said.
So you say that I'm not
sure if it's one of these people or
you're not sure that there's a perfect
one to one pairing between the two, then
you'd have to threshold it and you have
that same issue again.
Here are the cross domain results
for the blog and Twitter
data. Set the green
lines at the bottom where the green bars
on the on the slide
on the notation slide.
So we do have to vary terribly
in cross domain using those methods.
And then the blue lines are the domain
results and the bold red line are the
doppelganger finder results using
our augmented doppelganger finder.
So you can see we were able to recover
the accuracy to
almost as high as some of the
domain accuracy's.
And then.
The limitations of Doppelganger Finder,
first of all, you need a lot of text even
in the training documents or testing
documents, and so maybe more than 500
words even you would need of testing
documents to make this really work.
Additionally, it's made for a specific
case, which is account linking
work for more
specific cases than this.
The next question that naturally arises
is what if I'm trying to
identify the author of a Twitter feed and
I have a bunch of blog data, but I have
some Twitter data.
Do I use the Twitter data or one
of them in one of these limited cases?
Is it should I use the Twitter data or
should I try to use them? Ended up
invitation in the
with the blog data.
And the answer really is if you have
Twitter data, you should use Twitter
data. You can see it the first point
there on the screen, that 10 percent,
that is that 10 percent of the data is
Twitter data and
the rest are blogs.
And this is just using bright prints,
support vector machines for machine
learning. And you can see that we get a
huge jump in accuracy from having no
tweets to having some tweets.
And so if you have any Twitter data, you
can use it. This is mirrored as well
in other domain application methods
and natural language processing.
Open problems left in domain adaptation,
the first is looking at other
domain adaptation solutions, probably
from other natural language processing
problems like sentiment classification,
also looking at how topic effects style.
So if you are a blogger and you have a
Twitter feed that probably written on the
same thing, but if you are a reader and
you have a Twitter feed, they're probably
written on different things.
And so how does that affect it?
Or even if you have a Reddit account and
you write in different subjects on
different topics, can we still identify
you as well if you're not writing about
the same thing?
Another thing to look at would be other
domains.
And finally, is it possible for us to
change how a document feels
or how its actual content is to make
it feel more like the other domain?
So, for example, we had that tweet up
there that had barely any words in it.
What if we were able to make it look a
little more like plain text and make it
look like that blog?
Is that changing it too much or
would that work? And so that's definitely
a huge open question. That's not very
easy to answer right now.
So anonymity is really hard.
Trying to make yourself anonymous, even
through a lot of these methods is
difficult. And it's really not only about
what you're writing, but it's also about
how you write it.
And so even if you're doing things like
monitoring the content of what you write
to make sure it can't be traced back to
you or hiding your location through
things like Tor, we can probably
still identify you through only your
writing style.
So while stylometry can combat online
abuses, it's also a huge anonymity
threat.
Finally, we're very surprisingly
good at anonymizing text across many
domains and not just within them.
So not all is lost.
What can we do about it?
Our library now is developing a tool
called Anonymous.
This piece of software
helps you anonymize yourself,
anonymize your text as you write it, and
uses Stilo in the background
to verify that you're to
monitor that you're not the same author.
This is definitely a work in progress.
It could use a lot of work and analysis
and feedback.
So if anyone's interested in playing
with it or contributing to it or helping
with it, the get is at the bottom
and you can contact us with anything
else.
So thank you all for listening to all
three of us.
Special thanks to my contributors Travis
Dutko and Sadie Afroz, and
we'll take any questions.
Well, thank you very much.
And now we have about 20 minutes for
questions.
Feel free to occupy the
phones.
We have phones, microphones,
and we'll start with number three.
Thanks for the talk. I got a question
about across the main research.
I was wondering if you ever try to enrich
your your your future sets by by
metadata like activity patterns
or links used or something
like that.
So am I on?
Can anyone hear me?
We've done a little bit.
We looked at Twitter specifically because
there's just so much metadata associated
with Twitter and we found that we could
improve our Twitter results a little bit.
But in the cross domain case, it doesn't
particularly help.
But our Twitter results are already
ninety eight point nine, so any
improvement isn't really an improvement.
Do you have any idea why that is so?
Because my expectation would be that it's
like it's a very good fingerprint
of someone,
like at what time that person
is writing something or
how many links are in the text or
something that could write.
So we don't have data for I didn't we
didn't collect any data for when things
were posted for the blogs.
So we haven't done analysis with that.
When we looked at the
metadata, we're talking about hash tags,
tags and links.
So the hash tags in the tags don't really
translate over to blogs.
And as far as links go, I just don't
think that there's enough similarity
between them to get any real
improvement out of it.
Thank you.
Number four, please.
It is anonymous,
limited to English
or is it
independent of the natural language
you choose?
So I think that the current
implementation is
is limited to English, but it wouldn't
take a lot of work to extend it to,
say, German in particular,
because we have the analysis background
and we have the analysis back end
in German.
So it would be just a question of
of adding a little to a couple tweaks to
the interface to do that, to get
extensions to further languages where
you basically need to do is
augment the.
The analysis
engine to have function words in part
of speech shagger for that language.
Now, it may be a little more difficult to
you say, Asian languages that have
that require segmentation.
So you need a segmentation engine for
that. But other than that,
it's it shouldn't be that hard.
Yeah, the like I said, you could
already use the analysis
for for some languages, but
the front end of Anonymous doesn't
doesn't do that currently is an
abstraction layer in the
code.
Yet there is an API.
Yeah.
Thank you.
I, uh, well,
uh, thanks for the talk.
I think it's a fascinating subject.
In the first half of the lecture you were
talking about, you know, source
code analysis, etc..
I'm trying to understand, since you were
one of your results, is that the best
feature is to look, you have nothing
to do with the actual code.
It was no, you know, um, indentation
and stuff like that.
But with the structure of the program
itself, why are you limited to source
code analysis?
I mean, you dump it into the pro
and you get a photograph of the
program you can analyze.
So, yeah, you're right.
This was the first time you were trying
to syntactic feature set because it
wasn't tried before.
And we first wanted to see that our
intuition is really correct and
this will get us somewhere.
So right now with C++, we
saw that this works very well.
And as long as we have a parser to
get the structure of a program
or anything, this would be very helpful.
So we're willing to extend our
work with like different languages.
Then we have a lot of other things left
to do in future.
Yeah, and we would like to get to the
binary case, and that is next
sort of on the agenda. But we wanted to
sort of confirm this in.
The nice thing now that we can do is we
can compile these programs and
then we can directly compare the accuracy
that we get from the source code to the
to the binary so we can see what the the
differences, I guess you know that.
But it's a really it's a very
realistic problem, like insert,
uh, malware research in general.
Thanks. Thanks.
So you've said that you used
to quote from Kojm to analyze
to check how your program
works. And did
you strip out Macarius?
Because I know that people in such
programing contests use quite a
lot markers that they are to
every day profile because it makes
it easier to program
later. And it's about 20
years of such macarius
and they trip to doubt because
if you didn't, you might
even not compare.
Ah, if it is the code
of the same outr, but
if it is the same code, actually
we looked at the macros, we
had a layered feature
just for macros and also
our ESTIE parser is an
honor function by function basis.
So most of the time macros
were excluded from the
structural information.
So we kept that separately,
but we tried to find out if there
are any like similarities like
that in court and we didn't see too
many. But if we investigate
further just for that specific thing,
we might find more similarities.
So that's a very good point.
I'll check that.
OK, and the second question is,
are you found that for more
advanced problems, the
accuracy of checking
code is much higher?
Could be it artifact
because of that?
Ah, there were
less solutions for more advanced problems
and because of that list autres.
I mean, there were more outdoors
writing solutions for easier problems
and less outdoors writing
solutions for more for
harder programs and dirt
because there are less outdoors.
The accuracy should be right.
The dataset sizes are
always kept the same so that we
can compare the results.
So we grouped into our
two groups into heart
problems and easy problems and to
maintain the same size of yes.
And it was a complete random
selection from like hundreds or thousands
of users to make sure that
it represents a real world
scenario.
And thank you for your targets.
Interesting. Thanks.
Number two, please.
Um, there was a assaying
lost in translation.
Uh, have you tried taking a passage
and passing it through Google Translate
or some other translating program a few
times and seeing if
it's recognizable when it comes back
as being from the original author,
perhaps with some, uh, corrections
to spelling and grammar?
Is it still.
Yeah, a few years ago, I had a project
on that where we would like take
the writing translated to German,
translated to Japanese, translated
back, and we would do that with several
different translators, such
as Google Bing and
Language Rewa and a few others.
And we saw that
in most of the cases, depending
on the quality of the translator
and on that particular language,
we were able to identify those people
with very good accuracy.
But again, the quality
of the translator on a particular
language has a very big effect here.
We were able to observe that.
I mean, the the longer the path
that you translate through, like if you
go through 12 different intermediate
languages, you're going to
get almost unrecognizable at the end.
Now, if someone was trying to subvert a
system like this, could they
just do that, end up with the final
product after 10, 20 translations
and then just make simple,
uh, spelling?
Correct.
Spoke about simple grammatical,
uh, phrasing corrections.
Uh, what sort of length,
uh, did you did you test this on how many
translations did you run the passage
through before, uh, before bringing it
back to the original language?
So Arsène Total was three.
It was German and Japanese, some back to
English or maybe two in the middle.
But a recent paper show that they did
many translations, I think up to 20.
And the more you did translations, the
more unidentifiable the author
became. But at the same time, the text
lost its semantics, like
there was not much context or meaning
left in the text.
One thing that we have experimented with
in the anonymous program is actually what
we would use on a sentence by sentence
basis, translate it to a whole
bunch of different languages and back
just one way, but then rank
the sentences that the translations that
were produced by the ones that had the
most anonymity to the least anonymity and
put the ones at the top.
And then the person can look at them and
find ones that have more anonymity that
still are close to the meaning and bring
those back in.
So that was one thing we experimented
with.
OK, thank you.
I was wondering if your work is one
way and by that I mean is
how far away are you from producing
a quote unquote genuine letter
from Angela Merkel or a long lost play
from Shakespeare with all the
information you have?
So text generation
is much, much harder than text analysis.
It's sort of, I would argue, like
an MLP complete problem.
So I don't think
we're very what we what
we would be able to do is probably
help somebody create
a letter that was that was imitating that
style. Like you could you could have it
be sort of a collaboration between the
analysis engine and a person.
And that would probably work quite well.
Um, but to do it automatically
would be much harder.
So it could be used to hate
impersonation as well.
Yes.
Um, I've two questions, actually,
my first one is, will there be
something like an
animal for forest
code, actually?
Yeah, it's actually available on it,
but I didn't do the licensing
yet, but if you want to play with it, you
can play with it and I'll fix the
documentation and the licensing
information as soon as possible.
What she means is her analysis code.
We have not written an anonymizer
for source code yet.
We don't have an anonymizer for source
code, which can be called an obfuscatory.
Maybe you could edit
Anonymous to probably
work OK if you're trying to anonymize
source code to some extent.
Yeah, but the suggestions would be bad.
Yes.
OK, um, and the
second one is
when you try to compare
different codings,
um, did you also try
to compare between
different languages or
did you just always compare the
source codes of the same language?
We always looked at C++ in
this case because our asked parser
was for C++.
Yeah, sure.
But you think it's possible
to find
out, um,
also the similarities
between different source codes?
Well, um, from different languages.
Since each programing language has a
structure and its own grammar, this
should be possible as long as you have
the parser so it can be extended
to other languages in the same manner.
OK, yeah.
And Patros domain case might be tricky.
We'd have to do some experiments.
I actually wanted to ask the question
of my predecessor,
just I just want to say thank you
for a great presentation.
Thanks.
OK, I have so many questions from ARACY.
OK, if I might ask.
OK, the first one was about the
case of Kaisa versus Jacobsson,
where you had this comparison between
this free code and the, um,
uh, the, uh, copyrighted
code.
And they wanted to know, uh,
how you got to the source code of the
copyrighted code or if it was open source
code or which license it was under.
No, we didn't compare it because
it's copyright code, so we didn't try
to access it because
it's not publicly available.
Thank you. I was just an example.
Number four, please.
Okay, first of all, sorry, first of
all, thanks for a very interesting
thought and also thanks for doing work
on this anonymous solution,
because it would be more concerning if it
was only being applied to
reduce people's privacy, which in some
countries can end quite badly.
And my question is, if people use
this tool to
make their language less identifiable,
can they then be identified as having
used that tool with high confidence?
Does it leave a signature if you use
Anonymous and
and what's the size of the set
of people that use it? Because you're
only as anonymous as the number of people
using that tool if it's identifiable.
So I don't know how many
people use Anonymous.
Probably not a huge amount, because if
you actually try using it, it's kind of
difficult.
But the and I don't
know if using anonymous itself
would would really would
create a signature. And my guess is it
probably would, given the way that
people tend to know what the experiment
that we did do was, looking at the people
that we just told to imitate someone
else's style or just to try and hide
their style without anonymous.
And we were able to create a classifier
that was able to distinguish people
that had had tried to do that from people
who hadn't without necessarily being
able to identify the original author.
It just seems to me that if the stakes if
the stakes were high and
the amount of safety that you'd get from
using this, it would be difficult to
kind of calculate the function of when
it's safer to start using this and
obfuscated this tool
versus just saying less.
And it'd be nice to be able to have more
analysis so that people can make that
decision on an informed basis.
I agree that it would be nice.
OK, number one, please.
Hi.
Yes. Many, many development
houses and coding houses use style guides
and they're pretty strict about it.
And like and you'll run things
like Rubick and things like that.
They'll say remove spaces and,
you know, use single quotes and double
quotes. Have you taken that into account?
Um, first of all, we thought that
people have to implement the
functionality in a limited time.
So they use, like, the
things that they would like, naturally
use or they would
express their style because they
are limited in time.
On the other hand, if you think
that their style has to follow
a certain format, that would make
everyone more similar.
And in that scenario, the machine
learning problem will become even more
difficult if they're following a certain
style guide.
But there is no way for us to tell that
because we don't have ground truth
information from these contestants about
how they were implementing
the functionality at the time of the
competition.
What we can say is it really depends
on the style guide because we know the
features that we use.
So like in the obvious case,
if the if the style guide really only
talks about spacing and layout and
variable names and stuff like that, it
doesn't affect the deeper structure of
the code, like the variable depths
and things like that, then it wouldn't
then it wouldn't really be relevant.
But if it does affect that, then it would
be so probably depends on the specific
style guide itself.
But we don't have any data to suggest
that it's just in in
development. How do you do a pull request
and someone criticizes your code?
You have to change to make it look like
everyone else's. And so I was wondering
if you could pick out three thousand
developers here, which weren't actually
wrote that code and that sort of thing.
OK.
Hello. Yeah, I think we are going to take
the last three questions and then wrap it
up. OK. So number two, please.
And when we're when we're done, we'll go
to the cafeteria area and
sit down in a chair and a table there.
And if people want to ask more questions,
they can.
OK.
OK, so the next question from ask
is, what about multiple authors
like an open source projects?
What happens to the
protection of the author in such a case?
OK, so we haven't done anything with
source code on this yet because
that's, I think, a difficult problem that
we just haven't looked at.
We're currently, though, looking at
different Macías that are written by
multiple authors and these are similar
problems and getting preliminary
results. So keep looking forward to
it and we'll have something there, I
guess.
Do anything.
Well, I lead to the preliminary results
get but those were very good because I
wasn't using the abstracts initially.
So.
OK, number two.
My question is quite similar.
Is it possible to detect to
detect a text as written by
one person or by more persons?
I think that's definitely part of
that problem.
It may be a first step to completing that
problem.
Yeah, it's something we're actively
working on, but we don't have any results
yet.
It does cross
the main actually also work
across languages.
For example, if I'm on
one mailing list in German and on one
forum in English.
Would you be able to match these
accounts by
styles that that are independent of of
the language I'm using for posting?
You can't use a language independent
features that or you can try translating
the code and then I'm sorry, not
the code, the writing, and then
do an autocratic retribution
with an English feature set and
look at whichever one works better.
Yeah, I think I think translating
actually probably the best way to do that
would be to translate both of them and
then do both analysis and in both of
the individual languages and see what the
results are.
That's how I would go about it, because
because the translation, because
it's hard to do like the Ingrams and
stuff will be different for the different
languages.
So you probably want to translate them
so.
OK, I think that's that.
Thank you so much for coming, and we hope
that you'll be back next year,
Ceressus.