# Setting up Jupyter for Deep Learning on EC2

This post is a simple guide on setting up an EC2 server for deep learning as quickly as possible.

## Launching an Instance

In EC2, select ‘Launch Instance’. Select your AMI, choose Deep Learning AMI (Ubuntu). You could use the Amazon Linux version, I just personally prefer Ubuntu.

For actual deep learning, you will want to select a p* instance, ideally a p3 instance. If you are initially testing and writing prototype code, you will probably want to select a small t* instance. You can change this later on the EC2 Dashboard.

Move to Review and Launch. On the security groups you will need to open ports 22, 443 and 8888

Click ‘Launch’ and select your key pair (or create a new one).

On security, while we are opening 22, 443 and 8888 to the world it should not be a security risk. For SSH only the person with your key pair should be able to SSH in. For 443 and 8888, these are for Jupyter. As long as your Jupyter instance remains password or token protected (it is by default) it should not be a security risk.

## Configuring HTTPS

SSH into the server with:

It is a good idea to update any packages using

Create a Jupyter config

Create a certificate directory

Create a self-signed certificate valid for one year

Edit the file to include the following four lines

Note: I don’t set a password as I think it is safer to use the token (you will need to be SSH’d into the server to obtain the token)

## Running Notebooks

Now run:

Copy and paste the URL into your browser. It will look like https://localhost:8888/?token=ef0f…

Change ‘localhost’ to be the IP or DNS of your server.

You will get a warning screen

At this point you will have your notebook interface!

The AMI comes with most packages you need installed. If you need to install anything else, go to the terminal. Ensure you activate the conda environment you are using in your notebook e.g. if you are using Tensorflow Python 3, run

Then install your package via conda

# Static Blog: Jekyll, Hyde and GitHub Pages

This post is a short tutorial on setting up a static Jekyll blog using GitHub pages.

## Install Jekyll

Intructions for installing Jekyll can be found here: https://jekyllrb.com

### MacOS X Install Instructions

1. Download XCode via App Store – Search for ‘Xcode’ and click install.
2. In the latest version of XCode the Command Line tools will be atomically installed
3. On the terminal run  gem install jekyll bundler

## Setting up Hyde

We will be using an updated version of the Hyde template for Jekyll  called Hydeout

On the command line, clone the Hydeout template into a new directory using  git clone https://github.com/fongandrew/hydeout

Move into this directory and run

You will now have a working Hydeout blog running locally on your machine.

## Setting up GitHub Pages

The following assumes you are using the master branch for your blog.

Repoint the Hydeout template to your personal git repo

Push your changes to this repo.

In GitHub:

1. Go to the Settings of your Project
2. Go to GitHub pages
3. Set Source to be your master branch
4. Wait 30 seconds or so before trying to load your new website.

## Updating a post

1. Ensure your local repo is up-to-date using git pull
2. Create a new Markdown post under the _post directory
3. Run   jekyll serve to test your post looks the way you want
5. Your new post will now appear on the website

# Collaborative Filtering using Alternating Least Squares

Collaborative filtering is commonly used in recommender systems. The idea is if you have a large set of item-user preferences, you use collaborative filtering techniques to predict missing item-user preferences. For example, you have the purchase history of all users on an eCommerce website. You use collaborative filtering to recommend which products a user might purchase next. The key assumption here is people that agreed in the past (purchased the same products) will agree in the future.

In this post I will look at how to perform Matrix Factorisation via Alternating Least Squares as a method of Collaborative Filtering. This method gave one of the best results of a single method on the Netflix dataset.

# Matrix Factorisation

The basic idea behind any matrix factorisation method is to find a smaller set of latent factors that can be used to predict missing entries

In the above example, we want to decompose the purchases matrix into a set of user latent factors and a set of product latent factors.

Usually we are not able to perform this factorisation using direct methods (e.g. SVD) as the input matrix contains mostly missing values. To solve this we treat the latent factors as parameters to be learned and treat the factorisation as an optimisation problem.

# Explicit versus Implicit data

One major distinction is the type of data we have available as this will affect how we model the data. Broadly speaking it is split into explicit and implicit data.

Examples of explicit data collection include the following:

• Asking a user to rate an item on a sliding scale.
• Asking a user to rank a collection of items from favourite to least favourite.
• Presenting two items to a user and asking him/her to choose the better one of them.
• Asking a user to create a list of items that he/she likes.

Examples of implicit data collection include the following:

• Page views in an online store
• Online purchases online.
• Obtaining a list of items a users listens, watches on their computer. Apps they have installed.

Generally companies wishing to solve this sorts of problems have large amounts of implicit data available. I will present how the Alternating Least Squares (ALS) method can be used for explicit data and then extend it to implicit data.

# Preliminaries

Lets assume we have a number of users, and a number of items. We refer to users using the syntax $$u$$ and$$v$$ and refer to items with $$i$$ and$$j$$.

The users and items are associated through $$r_{u,i}$$ which we will call observations. For explicit datasets this would be the ratings a user has given an item. Higher numbers mean stronger preference. For implicit datasets these would indicate user actions. For instance it might be the number of times a user has purchased an item or viewed an item online.

# Model

We will associate each user $$u$$ with a user-factor vector $$x_u$$ and each item with a item-factor vector $$y_i$$. Our aim is to predict our observations from the latent factors:

$$\hat{r}_{u,i} = x^\top_uy_i$$

We want our predictions to be as close to the ground truth as possible. Therefore to find the latent vectors we frame it as an optimisation problem using a standard squared loss with regularisation:

$$\min_{x, y} \sum_{r_{u,i}\text{is known}}(r_{u,i} -x^\top_uy_i )^2 + \lambda(\sum_u||x_u||^2 + \sum_i||y_i||^2)$$

Let’s group all the user-factors in an $$m \times f$$ matrix $$X$$ and all the item-factors in an $$n \times f$$ matrix $$Y$$. If we assume either the user-factors or item-factors was fixed, this would look exactly like a regularised least squares problem. So, first lets assume $$Y$$ is fixed and solve for $$x_u$$:

$$x_u=(Y^{\top}Y + \lambda I)^{-1}Y^\top r_u$$

Likewise if we assume $$X$$ is fixed, and solve for $$y_i$$:

$$y_u=(X^{\top}X + \lambda I)^{-1}X^\top r_i$$

The idea is to iterate these two steps until some stopping criterion is reached. The original paper suggested 10 iterations.

For further ways to model explicit data, see this paper on the Netflix prize.

Example python implementation

# Implicit data

Using the raw observations directly has been found not to work as well on implicit data 1. Instead we define a set of binary observation variables:

$$p_{u,i}=\begin{cases}1& \text{if } r_{u,i}\gt 0\\0&\text{otherwise}\end{cases}$$

Now we want to define some confidence levels for each $$p_{u,i}$$. When $$r_{u,i} = 0$$ we have low confidence, it may be the user has never been exposed to that item or it may be unavailable at the time. When $$r_{u,i}$$ is small, it could be explained by the user buying a gift for someone else etc., hence we should still have low confidence. When $$r_{u,i}$$ is larger, we should have much more confidence.

We have complete freedom how we define confidence. The original proposal was

$$c_{u,i}=1+\alpha r_{u,i}$$

We have some level of confidence for each $$p_{u,i}$$. The $$\alpha$$ parameter is tuneable, to the dataset via cross-validation.

Our new optimisation function is

$$\min_{x, y} \sum_{r_{u,i}\text{is known}}c_{u,i}(p_{u,i} -x^\top_uy_i )^2 + \lambda(\sum_u||x_u||^2 + \sum_i||y_i||^2)$$

We define the diagonal matrix $$C^i$$, where $$C^i_{u,u}=c_{u.i}$$. The parameter learning is the same as a standard weighted least squares setup:

$$y_u=(X^{\top}C^iX + \lambda I)^{-1}X^\top C^ip_i$$

$$x_u=(Y^{\top}C^uY + \lambda I)^{-1}Y^\top C^up_u$$

Computing $$X^{\top}C^iX$$ can be expensive. One optimisation can be used is the fact: $$X^{\top}C^iX=X^{\top}X +X^{\top}(C^i – I)X$$. You can pre-compute $$X^{\top}X$$ at each step, and notice that $$(C^i – I)$$ only has the non-zero entries where $$r_{u,i}$$ was non-zero.

You might wonder, why bother with the confidence weights and why not scale the ratings instead? The problem there is that you turn a very sparse problem into a very dense problem and you will have trouble even numerically computing the MSE on the dense problem.

Example python implementation.

# Discussion

In the last section we will discuss a number of points when applying this algorithms on practical problem.

## Convergence

Let’s look at the loss function again

$$\mathcal{L} = \min_{x, y} \sum_{r_{u,i}\text{is known}}(r_{u,i} -x^\top_uy_i )^2 + \lambda(\sum_u||x_u||^2 + \sum_i||y_i||^2)$$

The loss is non-convex in $$(X, Y)$$. When we assume $$Y$$ is fixed, $$\mathcal{L}$$ is now convex in $$X$$. Each step will move us toward a minimum, but not necessarily a global minimum.

This will mean that each time you the algorithm you will potentially get a different result depending on how you initialise $$X$$ or $$Y$$. It is worth running the algorithm several times when testing different hyperparameter values.

Also note, if you make $$\lambda$$ large enough you will converge to the same solution each time. This is because are constraining your solution space.

## Initialisation

As the problem is non-convex, initialising the parameters in a good way can help you converge to a solution faster.

One suggested approch, currently used in Spark:

Choose a unit vector uniformly at random from the unit sphere, but from the “first quadrant” where all elements are nonnegative. This can be done by choosing elements distributed as Normal(0,1) and taking the absolute value, and then normalising.

One interesting thought here is that better initialisations could start you off closer to a global minimum. I would welcome any comments if anyone is aware of better approaches, I’ve not seen any literature on this.

## Hyperparameters

Exact values of $$\lambda$$ and $$\alpha$$ are data dependent and should be determined  by cross-validation.

## Intercepts

Interestingly, the original paper does not suggest using any form of user or item biases. A better approach could be to define:

$$\hat{r}_{u,i} = \mu + \beta_u + \beta_i + x^\top_uy_i$$

where $$\mu$$ would be a global average, $$\beta_u$$ represents a user bias and $$\beta_i$$ represents an item bias. These biases help us account for the difference in users and items e.g. some users buying lots of products.

The global average $$\mu$$ makes sense with explicit data (the average overall rating). It may not sense to use with implicit data (where most of $$r_{u,i}=0$$ ).

## Regularisation

Zhou et al. suggest weighting each term in the regularisation by $$n_u$$ and $$n_i$$ the number of observations of user $$u$$ and items $$i$$ respectively. The only reason I can see do to this is that it makes $$\lambda$$ less dependent on the scale of the dataset, so $$\lambda$$ from a sampled dataset should work well on a full dataset.

## Stopping Criteria

When to stop the algorithm is usually governed by:

• If a maximum number of iterations is met
• If the difference between the measured MSE of the current iteration and previous iteration goes below some epsilon

## Confidence Functions

You are free to use any function for the confidence weight you like. Straightforward linear scaling might not be what you want. For instance, in a e-Commerce scenario, you might use weights along the lines of

• 3 for a product page view
• 40 for a product purchase
• etc.

## ALS versus SGD

The loss function $$\mathcal{L}$$ could be optimised via stochastic gradient descent. It would potentially be easier and faster than ALS. However ALS offers two advantages:

• ALS is much easier to parallelise.
• In my experience, ALS converges very quickly. Generally I find less than 10 iterations will converge to a decent solution.

Hopefully this post provides an overall introduction to ALS and highlights some of the considerations you should take into account when implementing this algorithm.

1. http://yifanhu.net/PUB/cf.pdf

# Useful External Resources

Links to various useful external resources. Will be continually updated

##### Numpy for R users

http://mathesaurus.sourceforge.net/r-numpy.html

#### Jupyter Features

http://arogozhnikov.github.io/2016/09/10/jupyter-features.html

##### Modern Pandas

https://tomaugspurger.github.io/modern-1.html

##### Interactive Tutorial on Numerical Optimisation

http://www.benfrederickson.com/numerical-optimization/

# Computing PCA with SVD

PCA is a great tool for performing dimensionality reduction. Two reason you might want to use SVD to compute PCA:

• SVD is more numerically stable if the columns are close to collinear. I have seen this happen in text data, when certain terms almost always appear together.
• Spark’s PCA implementation currently doesn’t support very wide matrices. The SVD implementation does however.

# Singular Value Decomposition (SVD)

Below we briefly recap Singular Value Decomposition (SVD).

Let $$\mathbf{A}$$ be a $$m \times n$$ matrix, the singular value decomposition gives

$$\mathbf{A} = \mathbf{U}_{m\times m}\mathbf{\Sigma}_{m\times n}\mathbf{V}^\top_{n\times n}$$

$$\mathbf{U}$$ is an orthonormal matrix and is the eigenvectors of $$\mathbf{A}\mathbf{A}^\top$$.

$$\mathbf{V}$$ is an orthonormal matrix and is the eigenvectors of $$\mathbf{A}^\top\mathbf{A}$$.

$$\mathbf{\Sigma}$$ is a diagonal matrix and contains the square-roots of the eigenvalues of $$\mathbf{A}\mathbf{A}^\top$$ and   $$\mathbf{A}^\top\mathbf{A}$$ e.g.

$$\mathbf{\Sigma}=\begin{pmatrix}\sqrt{\lambda_1}&0&\cdots& 0\\0 &\sqrt{\lambda_2} & \cdots &0\\\vdots & \vdots & \ddots & \vdots \\0&0& \cdots &\sqrt{\lambda_k}\end{pmatrix}$$

Remember, as $$\mathbf{U}$$ is an orthonormal matrix $$\mathbf{U}^\top=\mathbf{U}^{-1}$$

# Computing PCA

1. Mean centre the matrix $$\mathbf{A}$$
2. Optionally scale each column by their standard deviation. You may want to do this if the variables are measured on different scales.

We noted in the previous section that $$\mathbf{V}$$ is the eigenvectors of $$\mathbf{A}^\top\mathbf{A}$$ (the covariance matrix). Thus the principal component decomposition is

$$$$\begin{split}\mathbf{T} & = \mathbf{A}\mathbf{V}\\ & =\mathbf{U}\mathbf{\Sigma}\mathbf{V}^\top\mathbf{V} \\ & =\mathbf{U}\mathbf{\Sigma}\end{split}$$$$

To reduce the dimensionality of $$\mathbf{A}$$, select the $$k$$ largest singular values ($$k \le n$$ ), select the first $$k$$ columns from $$\mathbf{U}$$ and the $$k \times k$$ upper-left part of $$\mathbf{\Sigma}$$. The reduced dimensionality is given by

$$\mathbf{T}_k =\mathbf{U}_k\mathbf{\Sigma}_k$$

Hadoop 2 is a complete overall of some of the core Hadoop libraries. It is a fundamental shift in the way applications run on top of Hadoop and it is worth understanding these changes.

# YARN

In Hadoop 1, the programming API (MapReduce) and resource management of the cluster were all bundled together. In Hadoop 2, resource management is now handled by YARN (Yet Another Resource Negotiator).

YARN manages the resources available to us on the cluster. To understand what YARN does, we need to look at the components that make it up:

## Resource Manager

• Runs on a single master node
• Global resource scheduler across the node
• Arbitrates resources between competing applications
• Nodes have resources – memory and CPU cores – which the resource manager allocates.

## Node Manager

• Sits on each slave node
• Handles communication with Resource Manager

## Applications

• Applications are jobs submitted to the YARN framework
• Could be MapReduce job, Spark job etc.

# Application Master

• One per-application
• Requests containers to actually run the job. Containers will be distributed across the container.

## Containers

• Create by the RM upon request
• Allocate a certain amount of resources ( CPU and memory) on a slave node.

# Applications

In Hadoop 2, applications are no longer limited to just MapReduce. Cluster can be used for multiple different systems at the same time.  The cluster resources can be between utilised and new systems can integrate by implementing the YARN API.

# Scheduling

• Hierarchical queue system
• Various scheduling mechanisms (Capacity Scheduler, Fair Scheduler)
• Cloudera CDH5 uses Fair Scheduling by default.

Useful commands when using Hadoop on the command line

# Filesystem

Full reference can be found in Hadoop Documentation.

#### ls

List the contents of provided directory.

#### put

Put the local file to provided HDFS location

#### get

Copy the file to the local file system

#### cat/text

Outputs the contents of HDFS file to standard output. Text command will also read compressed files and output uncompressed data.

Common usecase is that you want to check contents of the file, but not output the whole file. Pipe the contents to head.

#### cp/mv

cp is short for copy, copy file from source to destination.

mv is short for move, move file from source to destination.

#### chmod

Change the permissions of the file/directory. Uses standard Unix file permissions.

#### getmerge

Takes a source directory and concatenates all the content and outputs to a local file. Very useful as commonly Hadoop jobs will output multiple output files depending on the number of mappers/reducers you have.

#### rm

Deletes a file from HDFS. The -r means perform recursively. You will need to do this for directories.

By default the files will be moved to trash that will eventually be cleaned up. This means the space will not be immediately freed up. If you need the space immediately you can use -skipTrash, note this will mean you can reverse the delete.

#### du

Displays the sizes of directories/files. Does this recursively, so extremely useful for find out how much space you have. The -h option makes the sizes human readable.  The -s option summarises all the files, instead of giving you individual file sizes.

One thing to note is that the size reported is un-replicated.  If your replication factor is 3, the actual disk usage will be 3 times this size.

#### count

I commonly use this command to find out how much quota I have available on a specific directory (you need to add the -q options for this).

To work out how much quota you have used, SPACE_QUOTA – REMAINING_SPACE_QUOTA, e.g. 54975581388800 – 5277747062870 or 54.97TB – 5.27TB = 49.69TB left.

Note this figures are the replicated numbers.

Useful command for finding out total usage on the cluster. Even without superuser access you can see current total capacity and usage.

Commonly you will have a fat jar file containing all the code for your map reduce job. Launch via:

A Scalding job is launched using:

If you need to kill a map-reduce job, use:

You can find the job id in the resource manager or in the log of the job launch. This can be used to kill any map-reduce job (Standard Hadoop, Scalding, Hive, etc.) but not Impala or Spark jobs for instance.

# Setting up IntelliJ for Spark

Brief guide to setting up IntelliJ to build Spark applications.

# Create new Scala Project

Select:

1. Create New Project
2. Scala Module
3. Give it an appropriate name

# Setup Directory Structure

Move to the project root. Run the following:

# Setup gen-idea plugin

In the project directory you just created, create a new file called plugins.sbt with the following content:

# Create the build file

In the project root, create a file called build.sbt containing:

# Run SBT

At the project root level, run the following

You should now be setup and ready to write Spark Applications

# Common Pitfalls in Machine Learning

Over the past few years I have worked on numerous different machine learning problems. Along the way I have fallen foul of many sometimes subtle and sometimes not so subtle pitfalls when building models.  Falling into these pitfalls will often mean when you think you have a great model, actually in real-life it performs terribly. If your aim is that business decisions are being made based on your models, you want them to be right!

I hope to convey these pitfalls to you and offer advice on avoiding and detecting them. This is by no means an exhaustive list and I would welcome comments on other common pitfalls I have not covered.

In particular, I have not tried to cover pitfalls you might come across when trying to build production machine learning systems. This article is focused more on the prototyping/model building stage.

Finally, while some of this is based on my own experience, I have also drawn upon John Langford’s Clever Methods of Overfitting, Ben Hamner’s talk on Machine Learning Gremlins and Kaufman et al. Leakage in Data Mining. All are worth looking at.

Traditional overfitting is where you fit an overly complicated model to the trained dataset. For example, by allowing it to have too many free parameters compared to the number of training points.

To detect this, you should always be using a test set (preferably you are using cross validation). Plot your train and test performance and compare the two. You should expect to see a graph like figure 1. As your model complexity increases, your train error goes to zero. However, your test error follows an elbow shape, it improves to a point then gets worse again.

Potential ways to avoid traditional overfitting:

#### More training data

In general, the more training data you have the better. But it may be expensive to obtain more.

Before going down this route it is worth seeing if more train data will actually help. The usual way to do this is to plot a learning curve, how the training sample size affects your error:

In the left-hand graph, the gradient of the line at our maximum training size is still very steep. Clearly here more training data will help.

In the right-hand graph, we have started to reach a plateau, more training data is not going to help too much.

#### Simpler Predictor Function

Two ways you could use a simpler predictor:

• Use a more restricted model e.g. logistic regression instead of a neural network.
• Use your test/train graph (figure 1) to find an appropriate level of model complexity.

#### Regularisation

Many techniques have been developed to penalise models that are overly complicated (Lasso, Ridge, Dropout, etc.). Usually this involve setting some form of hyper-parameter. One danger here is that you tune the hyper-parameter to fit the test data, which we will discuss in Parameter Tweak Overfitting.

#### Integrate over many predictors

In Bayesian Inference, to predict a new data point $$x$$:

$$p(x|\mathbf{D},\alpha) = \int_{\theta} p(x|\theta,\alpha) \, p(\theta|\mathbf{D},\alpha)$$

where $$\alpha$$ is some hyper-parameters, $$\mathbf{D}$$ is our training data and $$\theta$$ are the model parameters. Essentially we integrate out the parameters, weighting each one by how likely they are given the data.

# Parameter Tweak Overfitting

This is probably the type of overfitting I see most commonly. Say you use cross validation to produce the plot in figure 1. Based on the plot you decide the 5 parameters is optimal and you state your generalisation error to be 40%.

However, you have essentially tuned your parameters to the test data set. Even if you use cross-validation, there is some level of tuning happening. This means your true generalisation error is not 40%.

Chapter 7 of the Elements of Statistical Learning discuss this in more detail. To get a reliable estimate of generalisation error, you need to put the parameter selection, model building inside, etc. in an inner loop. Then run a outer loop of cross validation to estimate the generalisation error:

For instance, in your inner loop you may fit 10 models, each using 5X CV. 50 models in total. From this inner loop, you pick the best model. In the outer loop, you run 5X CV, using optimal model from the inner loop and the test data to estimate your generalisation error.

# Choice of measure

You should use whatever measure is canonical to your problem or makes the most business sense (Accuracy, AUC, GINI, F1, etc.). For instance, in credit default prediction, GINI is the widely accepted measurement.

It is good to practice to measure multiple performance statistics when validating your model, but you need to focus on one for measuring improvement.

One pitfall I see all the time is using accuracy for very imbalanced problems. Telling me that you achieved an accuracy of 95%, when the prior is 95% means that you have achieved random performance. You must use a measure that suits your problem.

# Resampling Bias and Variance

When measuring your test performance you will likely use some form of resampling to create multiple test sets:

• K-fold cross validation
• Repeated k-fold cross validation
• Leave One Out Cross Validation (LOOCV)
• Leave Group Out Cross Validation (LGOCV)
• Bootstrap

Ideally we want to use a method that achieves low bias and low variance. By that I mean:

• Low bias – The generalisation error produced is close to the true generalisation error.
• Low variance (high precision) – The spread of the re-sampled test results is small

In general, the more folds you use the lower the bias, but the higher the variance.

You will need to pick a resampling method to suit your problem. With large training sets, k-fold cross validation with a k of 5 may suit. With small training sets, you will need a larger k.

Max Kuhn has done a fantastic empirical analysis of the different methods in relation to bias and variance (part I, part II). In general repeated 10-fold cross validation seems to be quite stable across most problems in terms of bias and variance.

Once you have computed the results of your cross validation, you will have a series of measurement of your test performance. The usual thing to do here is to take the mean and report this as your performance.

However just reporting the mean may hide the fact there is significant variation between the measurements.

It is useful to plot the distribution of the performance estimates. This will give you and idea  of how much variation there is:If you need to boil it down to a single number, computing the standard deviation (or variance) can be useful. However you often see performance quoted like: 80% +/- 2% where the 80% is the mean and the 2% is the standard deviation. Personally I dislike this way of reporting as it suggests the true performance is between 78%-82%. I would quote them separately; mean and standard deviation.

If you want to write 80% +/- 2%, you would need to compute bounds on the estimate.

# Information Leakage

Information Leakage occurs when data on your training label leaks into your features. Potentially it is even more subtle, where irrelvant features appear as highly predictive, just because you have some sort of bias in the data you collected for training.

As an example, imagine you are an eCommerce website and want to predict converters from the way people visit your website. You build features based on the raw URLs the users visit, but take special care to remove the URLs of the conversion page (e.g. Complete Purchase). You split your users into converters (those reaching the conversion page) and non-converters. However, there will be URLs immediately before the conversion page (checkout page, etc.) that will be present in all the converters and almost none of the non-converters. Your model will end up putting an extremely high weight on these features and running your cross-validation will give your model a very high accuracy. What needed to be done here was remove any URLs that always occur immediately before the conversion page.

#### Feature Selection Leakage

Another example I see regularly is applying a feature selection method that looks at the data label (Mutual Information for instance) on all of the dataset. Once you select your features, you build the model and use cross-validation to measure your performance. However your feature selection has already looked at all the data and selected the best features. In this sense your choice of features leaks information about the data label. Instead you should have performed inner-loop cross validation discussed previously.

#### Detection

Often it can be difficult to spot these sorts of information leakage without domain knowledge of the the problem (e.g. eCommerce, medicine, etc.).

The best advice I can suggest to avoid this is to look at the top features that are selected by your model (say top 20, 50). Do they make some sort of intuitive sense? If not, potentially you need to look into them further to identify if their is some information leakage occurring.

#### Label Randomisation

A nice method to help with the feature selection leakage is to completely randomly shuffle your training labels right at the start of your data processing pipeline.

Once you get to cross validation, if your model says it has some sort of signal (an AUC > 0.5 for instance), you have probably leaked information somewhere along the line.

# Human-loop overfitting

This is a bit of a subtle one. Essentially when picking what parameters to use, what features to include, it should all be done by your program. You should be able to run it end-to-end to perform all the modelling and performance estimates.

It is ok to be a bit more “hands-on” initially when exploring different ideas. However your final “production” model should remove the human element as much as possible. You shouldn’t be hard-coding parameter settings.

I have also seen this occurring when particular examples are hard to predict and the modeller decides to just exclude these. Obviously this should not be done.

# Non-Stationary Distributions

Does your training data contain all the possible cases? Or could it be biased? Could the potential labels change in the future?

Say for example you build a handwritten digit classifier trained on the the MNIST database. You can classify between the numbers 0-9. Then someone gives you handwritten digits in Thai:

How will your classifier behave? Possibly you need to obtain handwritten digits for other languages, or have an other category that could incorporate non Western Arabic numerals.

# Sampling

Potentially, your training data may have gone through some sort of sampling procedure before you were provided it. One significant danger here is that this was sampling with replacement and you end up with repeated data points in both the train and test set. This will cause your performance to be over-estimated.

If you have a unique ID for each row, check these are not repeated. In general check how many rows are repeated, you may expect some, but is it more frequent than expected?

# Summary

My one key bit of advice when building machine learning models is:

If it seems to good to be true, it probably is.

I can’t stress this enough, to be a really good at building machine learning models you should be naturally sceptical. If your AUC suddenly increases by 20 points or you accuracy becomes 100%. You should stop and really look at what you have done. Have you fallen trap of one of the pitfalls described here?

When building your models, it is always a good idea to try the following:

• Plot learning curves to see if you need more data.
• Use test/train error graphs to see if your model is too complicated.
• Ensure you are running inner-loop cross validation if you are tweaking parameters.
• Use repeated k-fold cross validation if possible.
• Check your top features – Do they make sense?
• Perform the random label test.
• Check for repeated unique IDs or repeated rows.

# Random Permutation Tests

At the 2014 Strata + Hadoop conference John Rauser gave a great keynote title “Statistics Without the Agonizing Pain“.  It is probably worth watching before reading the rest of this article, in it he introduces the concept of Random Permutation Tests.

“Classic” statistical tests usually make some sort of assumption about the distribution of the data e.g. normally distribution data . Are these assumptions always true? Probably not, but they are often approximately close enough to give you a useful result. By making these assumptions, these tests are called parametric.

Random Permutation Tests make no assumptions on the underlying distribution of the data. They are considered non-parametric tests. This can be extremely useful when:

• Your data just doesn’t seem to fit the distribution the classic statistical test assumes. For instance, perhaps it is bi-modal and the test assumes normality.
• You have outliers e.g. users who spend significantly more than others.
• You have a small sample size.

Random Permutation Tests can be used in almost any setting where you would compute a p-value. In this article I will focus on there use in experimental studies, you want to see if there is a difference between two treatment groups (A/B Tests, medical studies, etc.)

# Overview

The essential idea behind random permutation tests is:

1. Compute a test statistic between two (or more) groups. This could be the difference between two proportions, the difference between the means of the two groups etc.
2. Now randomly shuffle the data assigned to each group.
3. Measure the test statistic again on the shuffled data.
4. Repeat 2 and 3 many times
5. Look at where the test statistic from 1 falls in the distribution of test statistics from 2-4.

We have used steps 2-4 to empirically estimate the sampling distribution of the test statistic. From this distribution you can compute the p-value for your observed test statistic.

# Example

Let’s imagine we want to add a new widget on our checkout page of our e-commerce site to upsell products to a user.

The question we want to answer is, does adding the widget increase our revenue?

We run an A/B test with:

• Original checkout page
• Checkout page with widget

We know how much each user spent and what variant they have been given.

Lets generate some example transaction data in R:

We have randomly sampled the data from a log-normal distribution with equal mean and variance. We set the seed to ensure the results are repeatable. So in this case, we are looking to find there is no significant difference between the two datasets.

The classic statistical approach here would be to use a t-test. Let’s instead apply our random permutation test.

First, let’s compute the difference between the means of the two groups:

This gives a difference of 193.47. How likely is this to have happened by chance?

What we want to do is randomly shuffle our data between the two groups. If we were to sample (without replacement) once and compute the difference using the randomly shuffled version of groups:

This gave me a difference of 45.69. Now we will repeat this many times:

If we plot the examples, along with where our observed difference falls:

Straight away, it is fairly clear this observation could  just be due to random chance. It is not on the very extreme of the distribution. However let’s compute a p-value

On the two-tailed test, we get a p-value of 0.102, so we would accept the null hypothesis of there being no difference. Notice the add one here on both the denominator and numerator. Essentially we are adding our original measured test statistic to the random permutations. This ensures we never get a zero probability.

The standard t-test would give a p-value of 0.0985, so roughly similar. However, what if we didn’t care about the mean, but the median transaction value? Using random permutation tests, this is very simple to compute (a simple change to our code). Under classic statistical tests, we would have to go off and find the exact test we need to use under those conditions.

## Speed Improvements

On simple speed improvement is to parallelise the loop to compute the re-samples:

# Coin Package

As usual, R already has a package to help us do all of this. Using the same data as before we would run:

Generally you will find this is much faster for running large numbers of iterations.

One downside is you don’t get the visualisation of how extreme the observed data is compared to the empirical sampled histogram (Figure 2). I find this graph extremely useful when explaining how extreme a result appears to be, extremely to a non-statistical audience

# Summary

Random permutation tests are a nice alternative to classic hypothesis tests. In many cases they will give you almost exactly the same results. Being able to visualise the distribution (Figure 2) can be a massive assistance in explaining the p-value.

• Almost no assumptions on the underlying dataset being analysed
• Can be used for any test statistic (either it is implemented in coin or can be programmed yourself).
• Can be applied to all sorts of data types (numerical, ordinal, categorical) without having to remember the exact parametric test you should use.