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:
Shell
1
ssh-i<your pem>ubuntu@<your host orip>
It is a good idea to update any packages using
Shell
1
sudo apt-getupgrade
Create a Jupyter config
Shell
1
jupyter notebook--generate-config
Create a certificate directory
1
mkdir certs;cd certs
Create a self-signed certificate valid for one year
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:
Shell
1
jupyter notebook
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
As this is your own self-signed certificate, click Advanced and Proceed.
At this point you will have your notebook interface!
Installing additional packages
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
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.
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:
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.
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.
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.
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:
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
10 for an add to basket
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.
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{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.
Remember, as \(\mathbf{U}\) is an orthonormal matrix \(\mathbf{U}^\top=\mathbf{U}^{-1}\)
Computing PCA
Start with the standard steps of PCA:
Mean centre the matrix \(\mathbf{A}\)
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
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
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)
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.
Shell
1
hdfs dfs-text<file>|head
cp/mv
Shell
1
2
hdfs dfs-cp<source><dst>
hdfs dfs-mv<source><dst>
cp is short for copy, copy file from source to destination.
mv is short for move, move file from source to destination.
chmod
Shell
1
hdfs dfs-chmod[-R]<mode><file/dir>
Change the permissions of the file/directory. Uses standard Unix file permissions.
getmerge
Shell
1
hdfs dfs-getmegre<source dir><local file>
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
Shell
1
hdfs dfs-rm[-r][-skipTrash]<file/dir>
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
Shell
1
hdfs dfs-du[-s][-h]<file/dir>
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
Shell
1
hfds dfs-count[-q]<dir>
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).
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.
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.
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.
Figure 1. Train/Test Performance when varying number of parameters in the model
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:
Figure 2. Two example learning curves
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\):
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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Outer Cross Validation Loop
for(iin1:k){
Train=X[folds!=i,]
Test=X[folds==i,]
// Inner Cross Validation Loop
for(jin1:k){
InnerTrain=Train[folds!=j,]
InnerTest=Train[folds==j,]
// Train Model
// Try multiple parameter settings
// Predict on InnerTest
}
// Choose best parameters
// Train model using best parameters from inner loop
// Test performance on Test
}
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.
Bad Statistics
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.
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:
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.
Now randomly shuffle the data assigned to each group.
Measure the test statistic again on the shuffled data.
Repeat 2 and 3 many times
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:
R
1
2
3
4
# Setup the data
set.seed(3)
grp.1<-round(rlnorm(100,6))# With Widget
grp.2<-round(rlnorm(100,6))# Original page
Figure 1. Hypothetical results of the A/B test
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:
1
2
s<-sample(groups,length(groups),FALSE)
diff(by(data,s,mean))
This gave me a difference of 45.69. Now we will repeat this many times:
Figure 2. The histogram produced by randomly re-shuffling the group labels. Black line shows the observed data
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:
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.
Overall the main advantages are:
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.
Disadvantages can be:
Computing large number of re-samples is potentially slow. Although on modern computers this is less of a concern
Relies on the null hypothesis, that there is no association between the dataset and so the group labels are interchangeable under the null hypothesis.
Personally, I like to use both classic statistical tests and random permutation tests, even if all they do is validate one another.
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.
