Wouldn’t it be cool if you never had to remember another password again?

I read an article in The New York Times recently about using individual typing styles to identify people. A computer could authenticate you based on how you type your user name without ever requiring you to type a password.

To continue our series of posts about personal analytics, I want to show you how you can do a detailed analysis of your own typing style just by using Mathematica!

Here’s a fun little application that analyzes the way you type the word “wolfram.” It’s an embedded Computable Document Format (CDF) file, so you can try it out right here in your browser. Type “wolfram” into the input field and click the “save” button (or just press “Enter” on your keyboard). A bunch of charts will appear showing the time interval between each successive pair of characters you typed: w–o, o–l, l–f, f–r, r–a, and a–m. Do several trials: type “wolfram,” click “save,” rinse, and repeat (if you make a typo, that trial will just be ignored).

After a few trials the bar chart showing the average intervals should stop changing much between trials. Here’s what mine looked like after five trials:

You can see in the history panel on the top right that each trial has a fairly consistent profile. The time series plots in the middle show how the interval for each letter pair changed from trial to trial. The statistics above each time series plot show that the standard deviation is hovering around 10 milliseconds (ms). That’s pretty consistent! Maybe that’s because I typed “wolfram” about a thousand times while preparing this blog post. :)

Here’s what it looked like after 50 trials:

Notice in the plot on the bottom left how the interval distribution is basically bimodal, with o–l (green) and f–r (red) hovering around 150 ms, while all the other key pairs (w–o, l–f, r–a, and a–m) are clustered around 75 ms. That’s interesting because o–l and f–r are both key pairs that are typed with the same finger on the same hand.

So what about letters involving the same hand but different fingers? Well, the r–a interval requires me to hit “r” with my left index finger and then “a” using my left pinky, and it’s one of the fastest intervals for me at an average of 70 ms.

So it seems like I can transition between letters quickly using the same hand, as long as it’s using different fingers. But as soon as I’m using the same finger for a transition, it takes about twice as long.

Now I’m curious if faster transitions have more or less fluctuation. Do you pay a price for speed with more inconsistency? I’d like to see a plot of interval fluctuation versus interval average. And the measure of fluctuation that I think makes the most sense here is to divide the standard deviation by the mean (which is called relative standard deviation), giving fluctuation as a fraction of the mean.

To do this analysis I’ll need the raw data for all 50 trials, so I click the “data” tab and then click “copy to clipboard”:

After pasting the data into a notebook and assigning it to a variable called keydata, I get a list of trials for each interval like so:

For example, here’s the w–o interval for all 50 trials (in seconds):

Now I create pairs of the form {mean, sd/mean} for each interval:

And plot them together with a linear fit:

There does appear to be lower relative fluctuation for the slower intervals o–l and f–r, at least for my typing style.

The question we really want to answer is whether people can be identified just by the way they type. How could we test that?

Well it just so happens that Wolfram is a company full of data nerds just like me, so I sent out an email asking people to do a bunch of trials with this interface and send me their data. A total of 42 people responded:

People did 12 trials on average—some did as many as 30, and others only did a few:

Here are the average interval charts for each person. You can see there’s quite a range of profiles:

And here’s the combined distribution for everyone:

There’s a hint of the same bimodal structure like there was for just my 50 trials. But which letter intervals are contributing to each peak? We can use ChartLayout → "Stacked" to find out:

It looks like the o–l (green) and f–r (red) transitions are centered around 150 ms, with the others centered around 75 ms, just like they were for me.

What about the relative fluctuations? Now that we have data for the Wolfram population, we can see if that trend still holds:

Yes, indeed! There does seem to be a trend of lower relative fluctuations for longer intervals. So it seems like in general the slower you type, the more consistent you’ll be.

Now let’s test how well these individuals can be identified by their typing styles.

The simplest way to test this is to take the trials from two people and see if a clustering algorithm can separate the trials cleanly into two distinct groups.

For example, here are the trials from two of the individuals (person 1 and person 6):

Each trial (represented here by a bar chart) consists of a vector of six numbers, one number for each letter interval: (w–o, o–l, l–f, f–r, r–a, a–m). So each trial can be thought of as a point in six dimensions, where the similarity of two trials is just their Euclidean distance:

FindClusters is able to partition these trials perfectly, so that all trials from person 1 are in the first cluster and all trials from person 6 are in the second cluster.

But if we try the same thing with person 1 and person 7, the majority of trials for both 1 and 7 end up in the second cluster, so they actually cluster quite poorly:

And here’s an intermediate case, where the clustering algorithm is able to mostly distinguish between person 1 and person 9, but not perfectly:

To quantify the clustering quality, we’ll use the Rand index (see the attached notebook for the implementation). Using the Rand index, a perfect partitioning gets a score of 1:

The 1 versus 9 cluster gets a score of about 78%:

And the 1 versus 7 cluster gets a score of 0, because the clustering doesn’t help distinguish between the two people at all:

Now, since there are only 42 people, let’s just use brute force and measure the quality for all 1,764 pairwise clusterings:

The average cluster quality is about 67%:

Here’s the distribution of Rand quality scores:

And here is the matrix of all pairwise cluster scores, where matrix element {i, j} gives the Rand score for the clustering of trials for person i and person j. Darker is a higher score, and white is a score of 0 (all elements along the diagonal are by definition 0 because it’s impossible to distinguish between two identical sets of trials):

(Note that the matrix isn’t perfectly symmetric—that’s because the ordering of data points given to FindClusters can change the results.)

You can see there are rows with lots of white cells. Those are individuals whose trials tend to cluster poorly against all the other peoples’. If we take the average score for each person, we can see the poorly clustering ones as low points:

I suspect the poorly clustering people tend to be less consistent in their trials, which makes it harder for the clustering algorithm to find a clean partition. Let’s test that by quantifying a person’s typing consistency using a measure of the scatter of their trials in 6D space:

Now that we have a measure of scatter, we plot cluster score versus the average scatter for each pair:

There’s a clear trend here: pairs of people with lower scatter tend to have a higher cluster score (points lying above the red y = x line). So the ability of this method to identify you based on your typing style would require a certain amount of consistency in the way you type.

Using this fun little typing interface, I feel like I actually learned something about the way my colleagues and I type. The time to type two letters with the same finger on the same hand takes twice as long as with different fingers. The faster you type, the more your typing speed will fluctuate. The more your typing speed fluctuates, the harder it will be to distinguish you from another person based on your typing style. Of course we’ve really just scratched the surface of what’s possible and what would actually be necessary in order to build a keystroke-based authentication system. But we’ve uncovered some trends in typing behavior that would help in building such a system.

And hey, we just used the interactive features of Mathematica for real-time data acquisition! Being able to combine that with sophisticated functions like FindClusters for the subsequent data analysis allowed us to quickly find patterns and extract some meaningful conclusions about typing behavior from this dataset. Now I’m curious what other kinds of biometrics we can measure using Mathematica….

Download this ZIP file that includes the post as a CDF file, associated data files, and the code used above.