# Installing R Studio on Manjaro

Manjaro is amazing. But, it sometimes lacks resources and help to install “common” (it is a matter of point of view) packages. sudo pacman -S rstudio will not be enough, unfortunately.

But this will do it :

sudo pacman -S yaourt
sudo pacman -S r
yaourt -S rstudio-desktop-bin


You will have to press “no” a couple of times:

==> Edit PKGBUILD ? [Y/n] ("A" to abort)
==> ------------------------------------
==> n

==> Edit rstudio-desktop-bin.install ? [Y/n] ("A" to abort)
==> -------------------------------------------------------
==> n



And finally, yes, when asked whether you want to continue:

==> Continue building rstudio-desktop-bin ? [Y/n]
==> ---------------------------------------------
==> y


# Not so fast !

## What is exactly yaourt ?

Yaourt stands for “Yet Another User Repository Tool”. It is a command line tool for installing packages on Arch Linux. It is a wrapper for Pacman, the shipped package management utility for Arch Linux with extended features and remarkable AUR (Arch Linux User Repository) support.

It differs from pacman because pacman will only access what is in the official repos. But the packages created by members of the community which have not (yet) made their way into the official repos can be found on the AUR.

Hope this helped!

# Random forest vs extra trees

## A little bit of context

Quite some time ago, I asked a question on stats.stackexchange about differences between random forests and extremly random forests. Though the answers were good, I was still lacking some informations. Beyond the nice theoretical arguments, I run some simulations to have a better idea of their behavior.

Though these are, by no means, definite conclusions about their respective behaviors, those simulations performed on toy datasets, from specific implementations, I hope they will provide more insights to the reader!

## Summary of the simulations

Extra trees seem much faster (about three times) than the random forest method (at, least, in scikit-learn implementation). This is consistent with the theoretical construction of the two learners.

On toy datasets, the following conclusions could be reached :

• Extra trees seem to keep a higher performance in presence of noisy features,
• When all the variables are relevant, both methods seem to achieve the same performance.

## Theoretical point of view

A decision tree is usually trained by recursively splitting the data. Each split is chosen according to an information criterion which is maximized (or minimized) by one of the “splitters”. These splitter usually take the form of x[i]>t were t is a threshold and x[i] indicates the i-th component of an observation.

Decision trees, being prone to overfit, have been transformed to random forests by training many trees over various subsamples of the data (in terms of both observations and predictors used to train them).

The main difference between random forests and extra trees (usually called extreme random forests) lies in the fact that, instead of computing the locally optimal feature/split combination (for the random forest), for each feature under consideration, a random value is selected for the split (for the extra trees).

This leads to more diversified trees and less splitters to evaluate when training an extremly random forest.

The point here is not to be exhaustive, there are more references and the main articles at the bottom of the article.

## Timing

First, let’s observe the timing for each model. I will use the methods implemented in scikit-learn and I will reuse a code seen in another post (the code with new minor updates is at the bottom of the post). Without a detailed analysis, it seems that Extra Trees are three times faster than the random forest method.

N P Time RF Time ET
500 5 0.093678 0.0679979
500 10 0.117224 0.0763619
500 20 0.176268 0.097132
500 50 0.358183 0.157907
500 100 0.619386 0.256645
500 200 1.14059 0.45396
1000 5 0.139871 0.0846941
1000 10 0.211061 0.106443
1000 20 0.385125 0.151639
1000 50 0.805403 0.277682
1000 100 1.39056 0.501522
1000 200 2.76709 0.926728
2000 5 0.269487 0.122763
2000 10 0.474972 0.171372
2000 20 0.771758 0.264499
2000 50 1.81821 0.539937
2000 100 3.47868 1.03636
2000 200 6.95018 2.1839
5000 5 0.86582 0.246231
5000 10 1.2243 0.373797
5000 20 2.20815 0.624288
5000 50 5.13883 1.41648
5000 100 9.79915 3.25462
5000 200 21.5956 6.86543

Note the use of tabulate which allows a pretty print for python dataframes ;)

import numpy as np
import ComplexityEvaluator
from sklearn.ensemble import RandomForestRegressor, ExtraTreesRegressor, AdaBoostRegressor
from tabulate import tabulate

def random_data_regression(n, p):
return np.random.rand(n, p), np.random.rand(n)

regression_models = [RandomForestRegressor(),
ExtraTreesRegressor()]

names = ["RandomForestRegressor",
"ExtraTreesRegressor"]

complexity_evaluator = ComplexityEvaluator.ComplexityEvaluator(
[500, 1000, 2000, 5000],
[5, 10, 20, 50, 100, 200])

i = 0
for model in regression_models:
res, data = complexity_evaluator.Run(model, random_data_regression)
print(names[i])
i = i + 1


## Irrelevant variables

Now, let’s try to see how they compare when we add irrelevant variables. First, we need to propose a data set where there is something to learn (as opposed as what was previously done).

Let’s fix a linear dependency between the target variable and the first three variables, along the lines of:

def linear_data_generation(n, p):
X = np.random.rand(n, p)
beta = np.zeros([p, 1])
beta[0,0] = 1
beta[1,0] = 2
beta[2,0] = -1
Y = np.ravel(np.dot(X, beta))
return X, Y


Fig. 1: Comparison of random forests and extra trees in presence of irrelevant predictors

In blue are presented the results from the random forest and red for the extra trees.

The results are quite striking: Extra Trees perform consistently better when there are a few relevant predictors and many noisy ones.

import numpy as np
import AccuracyEvaluator
from sklearn.ensemble import RandomForestRegressor, ExtraTreesRegressor
from sklearn.metrics import mean_squared_error
from tabulate import tabulate
import matplotlib.pyplot as plt

def linear_data_generation(n, p):
X = np.random.rand(n, p)
beta = np.zeros([p, 1])
beta[0,0] = 1
beta[1,0] = 2
beta[2,0] = -1
Y = np.ravel(np.dot(X, beta))
return X, Y

n_columns = [5, 10, 20, 30, 50, 80, 100]

accuracy_evaluator = AccuracyEvaluator.AccuracyEvaluator(
[500],
n_columns,
mean_squared_error,
10)

data_rf = accuracy_evaluator.Run(RandomForestRegressor(), linear_data_generation)
data_et = accuracy_evaluator.Run(ExtraTreesRegressor(), linear_data_generation)

plt.errorbar(n_columns, data_rf["Metric"], yerr= data_rf["Std"], fmt="o", ecolor = "blue", color="blue")
plt.errorbar(n_columns, data_et["Metric"], yerr= data_et["Std"], fmt="o", ecolor = "red", color="red")
plt.xlabel('Number of columns')
plt.ylabel('Mean Squared Error')
plt.show()


## Many relevant variables

Starting from the code above and changing the decision function to be a sum of each predictor:

def linear_data_generation(n, p):
X = np.random.rand(n, p)
beta = np.ones([p, 1])
Y = np.ravel(np.dot(X, beta))
return X, Y


Fig. 2: Comparison of random forests and extra trees in presence of many relevant predictors

In blue are presented the results from the random forest and red for the extra trees.

It seems that both methods perform equally in presence of many relevant features.

## Code

import numpy as np
import pandas as pd
import time
from sklearn.linear_model import LinearRegression
import math

class ComplexityEvaluator:

def __init__(self, nrow_samples, ncol_samples):
self._nrow_samples = nrow_samples
self._ncol_samples = ncol_samples

def _time_samples(self, model, random_data_generator):
rows_list = []
for nrow in self._nrow_samples:
for ncol in self._ncol_samples:
train, labels = random_data_generator(nrow, ncol)

start_time = time.time()
model.fit(train, labels)
elapsed_time = time.time() - start_time

result = {"N": nrow, "P": ncol, "Time": elapsed_time}
rows_list.append(result)

return rows_list

def Run(self, model, random_data_generator):
orig_data = pd.DataFrame(self._time_samples(model, random_data_generator))
data = orig_data.applymap(math.log)
linear_model = LinearRegression(fit_intercept=True)
linear_model.fit(data[["N", "P"]], data[["Time"]])
return linear_model.coef_, orig_data

if __name__ == "__main__":
class TestModel:

def __init__(self):
pass

def fit(self, x, y):
time.sleep(x.shape[0] / 1000.)

def random_data_generator(n, p):
return np.random.rand(n, p), np.random.rand(n, 1)

model = TestModel()

complexity_evaluator = ComplexityEvaluator(
[200, 500, 1000, 2000, 3000], [1, 5, 10])

res = complexity_evaluator.Run(model, random_data_generator)

print(res)



And then :

import numpy as np
import pandas as pd
import time
from sklearn.linear_model import LinearRegression
import math
from Stacker import Stacker

class AccuracyEvaluator:

def __init__(self, nrow_samples, ncol_samples, penalty, n_folds=5):
self._nrow_samples = nrow_samples
self._ncol_samples = ncol_samples
self._stacker = Stacker(penalty, n_folds, False)

def _accuracy_samples(self, model, random_data_generator):

def predict(model, X):
return model.predict(X)

rows_list = []
for nrow in self._nrow_samples:
for ncol in self._ncol_samples:
train, labels = random_data_generator(nrow, ncol)

mean_perf, std_perf,  _ = self._stacker.RunSparse(train,
labels, model, predict)

result = {"N": nrow, "P": ncol,
"Metric": mean_perf, "Std": std_perf}
rows_list.append(result)

return rows_list

def Run(self, model, random_data_generator):
orig_data = pd.DataFrame(
self._accuracy_samples(model, random_data_generator))
return orig_data


I will come back to stacking in another post some day, which I also use for cross-validation (stacking can be obtained almost for free during a cross validation). Plus the naming of some functions is quite unfortunate (RunSparse() should probably be called RunNumpyArray() or something like this, likewise, the Run() should probably be RunPandas()…). The code is here for the sake of completeness.

import pandas as pd
import numpy as np

from time import time
from sklearn import cross_validation

class Stacker:

def __init__(self, penalty, n_folds, verbose=True, random_state=1):
self._penalty = penalty
self._n_folds = n_folds
self._verbose = verbose
self._random_state = random_state

def Run(self, X, y, model, predict_method):
kf = cross_validation.KFold(
y.shape[0], n_folds=self._n_folds, shuffle=True, random_state=self._random_state)
trscores, cvscores, times = [], [], []
i = 0
stack_train = np.zeros(len(y))  # stacked predictions
for i, (train_fold, validation_fold) in enumerate(kf):
i = i + 1
t = time()
model.fit(X.iloc[train_fold], y.iloc[train_fold])

tr_pred = predict_method(model, X.iloc[train_fold])

trscore = self._penalty(y.iloc[train_fold], tr_pred)

validation_prediction = predict_method(
model, X.iloc[validation_fold])
cvscore = self._penalty(
y.iloc[validation_fold], validation_prediction)

trscores.append(trscore)
cvscores.append(cvscore)
times.append(time() - t)

stack_train[validation_fold] = validation_prediction

if self._verbose:
print("TRAIN %.5f | TEST %.5f | TEST-STD %5f | TIME %.2fm (1-fold)" %
(np.mean(trscores), np.mean(cvscores), np.std(cvscores), np.mean(times) / 60))
print(model.get_params(deep=True))
print("\n")

return np.mean(cvscores), stack_train

def RunSparse(self, X, y, model, predict_method):
kf = cross_validation.KFold(
y.shape[0], n_folds=self._n_folds, shuffle=True, random_state=self._random_state)
trscores, cvscores, times = [], [], []
i = 0
stack_train = np.zeros(len(y))  # stacked predictions
for i, (train_fold, validation_fold) in enumerate(kf):
i = i + 1
t = time()
model.fit(X[train_fold], y[train_fold])

tr_pred = predict_method(model, X[train_fold])

trscore = self._penalty(y[train_fold], tr_pred)

validation_prediction = predict_method(
model, X[validation_fold])
cvscore = self._penalty(
y[validation_fold], validation_prediction)

trscores.append(trscore)
cvscores.append(cvscore)
times.append(time() - t)

stack_train[validation_fold] = validation_prediction

if self._verbose:
print("TRAIN %.5f | TEST %.5f | TEST-STD %5f | TIME %.2fm (1-fold)" %
(np.mean(trscores), np.mean(cvscores), np.std(cvscores), np.mean(times) / 60))
print(model.get_params(deep=True))
print("\n")

return np.mean(cvscores), np.std(cvscores),stack_train


## Learning more and references

Classification and Regression Trees by Leo Breiman, Jerome Friedman, Charles J. Stone, R.A. Olshen

Breiman L (2001). “Random Forests”. Machine Learning. 45 (1): 5–32.

Geurts P, Ernst D, Wehenkel L (2006). “Extremely randomized trees”. Machine Learning. 63: 3–42

Python data science handbook

# Product-sum numbers

## Statement

The problem can be found here.

A natural number, N, that can be written as the sum and product of a given set of at least two natural numbers, {a1, a2, … , ak} is called a product-sum number: N = a1 + a2 + … + ak = a1 x a2 x … x ak.

For example, 6 = 1 + 2 + 3 = 1 x 2 x 3.

For a given set of size, k, we shall call the smallest N with this property a minimal product-sum number. The minimal product-sum numbers for sets of size, k = 2, 3, 4, 5, and 6 are as follows.

k=2: 4 = 2 x 2 = 2 + 2

k=3: 6 = 1 x 2 x 3 = 1 + 2 + 3

k=4: 8 = 1 x 1 x 2 x 4 = 1 + 1 + 2 + 4

k=5: 8 = 1 x 1 x 2 x 2 x 2 = 1 + 1 + 2 + 2 + 2

k=6: 12 = 1 x 1 x 1 x 1 x 2 x 6 = 1 + 1 + 1 + 1 + 2 + 6

Hence for 2≤k≤6, the sum of all the minimal product-sum numbers is 4+6+8+12 = 30; note that 8 is only counted once in the sum.

In fact, as the complete set of minimal product-sum numbers for 2≤k≤12 is {4, 6, 8, 12, 15, 16}, the sum is 61.

What is the sum of all the minimal product-sum numbers for 2≤k≤12000?

## Ideas

The fact that the sum of the “product-sum numbers” was asked by counting only once each number lead me to think that there was some way to test wether a number is a “product-sum” easily.

Though it was quite easy to prove that prime numbers cannot be product sum numbers, other criterions were not that obvious.

12000 did not seem to be that far for a naive approach : for each number, find the first product-sum number following it.

For this, only a test “is this number a sum product number for k terms” was needed. The simplest way to perform it simply was to enumerate all the possible ways to write an integer as a product of integers (different from 1).

let enumerate_products n =
let rec aux k i acc =
if i == k then [i::acc]
else if i > k then []
else
if k mod i == 0 then
(aux (k/i) i (i::acc))@(aux k (i+1) acc)
else (aux k (i+1) acc)
in
aux n 2 []


Testing is now easy:

let is_sum_product n k =
if is_prime n then
false
else
let product_representations = enumerate_products n in

let pseudo_sum product_representation =
(sum_list product_representation) + k - (List.length product_representation) in

List.exists (fun x -> (pseudo_sum x) == n) product_representations


Using the fact that a number n, decomposed in k factors needs to be bigger than k and smaller than 2k in order to be a product sum, finding the next product-sum number is easy:

let find_smallest_sum_product k =
let rec aux i =
if i > 2*k then
failwith "error somewhere"
else if is_sum_product i k then i
else aux (succ i) in
aux (succ k) (* would not work for n=k=1... *)


## A simple solution

The whole code to find the solution is the following. With ocamlopt, it took me around 3 minutes on a laptop.

let is_prime n =
let rec is_not_divisor d =
d * d > n || (n mod d <> 0 && is_not_divisor (d+1)) in
n <> 1 && is_not_divisor 2

let sum_list input_list =
List.fold_right (fun x y -> x + y) input_list 0

let enumerate_products n =
let rec aux k i acc =
if i == k then [i::acc]
else if i > k then []
else
if k mod i == 0 then
(aux (k/i) i (i::acc))@(aux k (i+1) acc)
else (aux k (i+1) acc)
in
aux n 2 []

let is_sum_product n k =
if is_prime n then
false
else
let product_representations = enumerate_products n in

let pseudo_sum product_representation =
(sum_list product_representation) + k - (List.length product_representation) in

List.exists (fun x -> (pseudo_sum x) == n) product_representations

let find_smallest_sum_product k =
let rec aux i =
if i > 2*k then
failwith "error somewhere"
else if is_sum_product i k then i
else aux (succ i) in
aux (succ k) (* would not work for n=k=1... *)

let sum_sum_product a b =
let integer_interval = List.init (b-a+1) (fun i -> i+a) in
let sum_products = List.map find_smallest_sum_product integer_interval in
let unique_sum_products = List.sort_uniq compare sum_products in
sum_list unique_sum_products ;;

(* Unit testing *)
assert (sum_sum_product 2 12 == 61);

(* Result *)
print_int (sum_sum_product 2 12000);
print_string "\n";


# More problems

If you like this kind of problems, I strongly recommend The Art of Mathematics: Coffee Time in Memphis, by Béla Bollobás.

To find out more about OCaml this book provides a detailed presentation of the language.

# Acronyms of data science

Every field has its acronyms, machine learning does not avoid this rule. I am not a big fan of heavy acronyms usage, but if you happen to be lost in the middle of meeting, this may help!

Below is a list of acronyms, if I missed any, or if you have nice references regarding each topic, feel free to comment, I will do my best to keep this list as up-to-date as possible!

AE Auto encoder

ANN Artificial Neural Network

API Application Programming Interface

ARD Automatic Relevance Determination

ASR Automatic Speech Recognition ASR

BPTT Back Propagation Through Time

BPTS Back Propagation Through Structure

BNN Binary Neural Net

COCO Common Objects in Context

CPPN Compositional Pattern-Producing Network

CTC Connectionist Temporal Classification

CNN Convolutional Neural network

DBN Deep Belief Network

DCGAN deep convolutional generative adversarial networks

DNN Deep Neural Network

DT Decision tree

EBM Energy Based Model

ESP Enforced SubPopulations

ELU Exponential Linear Unit

GMM Gaussian Mixture Model

GRU Gated Recurrent Unit GRU

HMM Hidden Markov Model

NB Naive Bayes

NN Neural Network

KPCA Kernel Principal Component Analysis

KSVM Kernel Support Vector Machine

GA Genetic algorithm GA

HTM Heirarchal temporal memory

HMM Hidden Markov Model

HAM Hierarchical Attentive Memory

KNN k-Nearest Neighbors

LOOCV Leave one out cross validation

LReLU Leaky ReLU

LTU Linear Threshold Unit

LSTM Long Short Term memory

MCMC Markov chain Monte Carlo

MDP Markov Decision Processes

ML Machine Learning

MLP Multi-layer Perceptrons

NLP Natural Language Processing

NTM Neural Turing Machine

NEAT NeuroEvolution of Augmenting Topologies

OLS Ordinary Least Squares Regression

PReLU Paramaterized ReLU

OCR Optical Character Recognition.

PCA Principal Component Analysis.

PAC-MDP Probably Approximately Correct in Markov Decision Processes

RTRL Real Time Recurrent Learning

ReLU Rectified Linear Unit

RNN Recurrent Neural Network

RNTNRecursive Neural Tensor Network

RL Reinforcement Learning

RVM Relevance Vector Machine

ResNet Residual Neural Network

RBM Restricted Boltzmann Machines

SIFT Scale-Invariant Feature Transform

SRN Simple Recurrent Network

SVD singular value decomposition

SVM Support Vector Machine

TF TensorFlow

TFIDF Term Frequency Inverse Document Frequency

VLAD Vector of Locally Aggregated Descriptors

WFST Weighted Finite-State Transducers

# Updating Manjaro

A short while ago, I decided to jump from Ubuntu to Manjaro. Ubuntu kept showing me textboxes like “an issue has been detected, close or report ?”, was taking a huge amount of resources and most of the system updates did not solve these. Time for a change !

What is Manjaro ?

It is a distribution of Linux based on the Arch Linux distribution. Manjaro Linux has a focus on user friendliness and accessibility and the system itself is designed to work fully ‘straight out of the box’ with its variety of pre-installed software.

If you are a big fan of comparisons, which I will not detail here, you can find some on slant.co or in french, on citizenz or a top 7 reasons why….

## Time for a system update on Manjaro

What could possibly go wrong on a system based on user-friendliness ? Well, the system update can be a pain. As here or here or if you installed VLC/

[user@user-pc ~]$sudo pacman -Syu [sudo] password for user: :: Synchronizing package databases... core extra community multilib [...] error: unresolvable package conflicts detected error: failed to prepare transaction (conflicting dependencies) :: python-nautilus and python2-nautilus are in conflict  Removing packages To remove a single package, leaving all of its dependencies installed: # pacman -R package_name To remove a package and its dependencies which are not required by any other installed package: # pacman -Rs package_name Let’s try getting rid of python2-nautilus. Just in case you wonder what it does. [user@user-pc ~]$ sudo pacman -Rs python2-nautilus
checking dependencies...
error: failed to prepare transaction (could not satisfy dependencies)
:: nautilus-admin: removing python2-nautilus breaks dependency 'python-nautilus'


Not exactly what I needed… It was actually called nautilus-admin.

[user@user-pc ~]$sudo pacman -Rs nautilus-admin checking dependencies... Packages (3) python2-gobject-3.26.1-1 python2-nautilus-1.1-4 nautilus-admin-1.1.1-1 Total Removed Size: 1.27 MiB :: Do you want to remove these packages? [Y/n] Y :: Processing package changes... (1/3) removing nautilus-admin (2/3) removing python2-nautilus (3/3) removing python2-gobject :: Running post-transaction hooks... (1/1) Arming ConditionNeedsUpdate...  Let’s try the update once again ! Pay attention not to answer yes to every question… [user@user-pc ~]$ sudo pacman -Syu

[...]

:: Replace compositeproto with extra/xorgproto? [Y/n] Y
:: Replace damageproto with extra/xorgproto? [Y/n] y
:: Replace fixesproto with extra/xorgproto? [Y/n] y
:: Replace fontsproto with extra/xorgproto? [Y/n] y
:: Replace gnome-themes-standard with extra/gnome-themes-extra? [Y/n] y
:: Replace gnome-tweak-tool with extra/gnome-tweaks? [Y/n] y
:: Replace inputproto with extra/xorgproto? [Y/n] y
:: Replace kbproto with extra/xorgproto? [Y/n] y
:: Replace manjaro-gnome-extension-settings with community/manjaro-gnome-extension-settings-17.0? [Y/n] n
:: Replace manjaro-gnome-extension-settings with community/manjaro-gnome-extension-settings-18.0? [Y/n] y
:: Replace manjaro-gnome-settings with community/manjaro-gnome-settings-17.0? [Y/n] n
:: Replace manjaro-gnome-settings with community/manjaro-gnome-settings-18.0? [Y/n] y
:: Replace pkg-config with core/pkgconf? [Y/n] y
:: Replace randrproto with extra/xorgproto? [Y/n] y
:: Replace recordproto with extra/xorgproto? [Y/n] y
:: Replace renderproto with extra/xorgproto? [Y/n] y
:: Replace scrnsaverproto with extra/xorgproto? [Y/n] y
:: Replace videoproto with extra/xorgproto? [Y/n] y
:: Replace xextproto with extra/xorgproto? [Y/n] y
:: Replace xf86vidmodeproto with extra/xorgproto? [Y/n] y
:: Replace xineramaproto with extra/xorgproto? [Y/n] y
:: Replace xproto with extra/xorgproto? [Y/n] y


The following can take a while:

zenity-3.28.1-1-x86_64     3.8 MiB   586K/s 00:07 [######################] 100%
pipewire-0.1.9-3-x86_64 1143.8 KiB   397K/s 00:03 [######################] 100%
mutter-3.28.2-1-x86_64     2.2 MiB   342K/s 00:07 [######################] 100%


You thought it was done ? No. Too bad.

(729/729) checking keys in keyring                                                                                                                             [##################################################################################################] 100%
(729/729) checking package integrity                                                                                                                           [##################################################################################################] 100%
(729/729) checking for file conflicts                                                                                                                          [##################################################################################################] 100%
error: failed to commit transaction (conflicting files)
python-pip: /usr/lib/python3.6/site-packages/pip/_internal/__init__.py exists in filesystem

[...]

python-pip: /usr/lib/python3.6/site-packages/pip/_internal/vcs/mercurial.py exists in filesystem
python-pip: /usr/lib/python3.6/site-packages/pip/_internal/vcs/subversion.py exists in filesystem
python-pip: /usr/lib/python3.6/site-packages/pip/_internal/wheel.py exists in filesystem
Errors occurred, no packages were upgraded.


There is an issue with pip now… Using :

[user@user-pc ~]$sudo pacman -S python-pip --force  Enables to update Python. And now, the following should work! [user@user-pc ~]$ sudo pacman -Syu


Hope this helped :)

# Packages for machine learning

I hope to provide more packages and more informations to this list from times to times. If you have some specific questions regarding a package or have some recommendations, feel free to leave a comment, I will have a look!

Machine learning means so many possible tasks, comes with so many packages and tools that it is hard to have an idea of which one to use. I am just listing the one I find really useful. They are not better than the packages I do not use and I cannot guarantee they are absolutely bug free, but they are robust enough to work with!

# Linux tools

A good terminal will be your best friend.

i="1"
for filename in ./pdfs/*.pdf; do
i="$((i+1))" if [ "$i" -gt 20 ]; then
break
fi
echo "Processing $filename file..." pdf2txt.py -m 2 "$filename" >> "txts/$(basename "$filename" .pdf).txt"
done

How amazing is that ?

## tabview

Probably the best tool to navigate through a CSV file, in the terminal. It is really light, fast, supports many VIM commands. Here is the repo.

## csvkit

Install it from pip. It comes with a lot of handy tools:

• csvstat

• csvlook though I prefer tabview, csvlook my_data.csv > my_data.md allows to display a csv file in markdown.

Combined with head you can navigate through various files really fast. There actually is whole website dedicated to this.

## glances

This allows you to see how busy your machine is when running an algorithm.

## PDF to text files

### pdf2txt.py

Useful to extract text from pdf files. There is no perfect solution (as far as I know) for this task, but this one is a good starting point.

### Tesseract (and ImageMagick)

Another approach to extracting text from pdf files is using OCR (Optical Character Recognition). Tesseract does a great job but importing pdf directly can lead to errors. However, ImageMagick does a great job at turning pdfs to pngs.

echo "Processing $filename file..." convert -density 300 "$filename[0-1]" -quality 90 "output.png"
tesseract -l fra "output-0.png" "output-0"
tesseract -l fra "output-1.png" "output-1"
cat "output-0.txt" "output-1.txt" > "ocr$(basename "$filename" .pdf).txt"
rm "output-0.txt" "output-1.txt" "output-0.png" "output-1.png"


# R

When installing R, and it happened to me many times, I love running the following script. It feels like coming home. I will not go through all the details of each package, it is just that it will be useful for me to have this code around :)


{
lib.loc <- l
print(lib.loc)

if (length(which(installed.packages(lib.loc=lib.loc)[,1]==libT))==0)
{
install.packages(libT, lib=lib.loc,repos='http://cran.us.r-project.org')
}
}

)

machine_learning_libraries <- c(
"xgboost",
"glmnet",
"randomForest",
"Rtsne",
"e1071"
)

data_libraries <- c(
"data.table",
"FeatureHashing",
"dplyr",
"Matrix"
)

string_libraries <- c(
"stringdist",
"tm"
)

plot_libraries <- c(
"ggplot2",
"RColorBrewer",
"fields",
"akima"
)

machine_learning_libraries,
data_libraries,
string_libraries,
plot_libraries)



## General stuff

If you have been using the default csv reader in R read.csv, you must be familiar with its drawbacks : slow, many parameters, a parser which sometimes fails… readr on the other hand is super fast, robust and comes with read_csv and read_csv2 depending on the csv standard your file relies on. (The good thing with standard being that there always are many versions of them…)

### XML

It allows to read XML files (obviously) but also HTML tables (yes, some people actually use this to transfer data, though it makes the whole file much bigger because of so many HTML tags…)

## Machine learning libraries

### glmnet

A library that enables to perform elastic net regressions. Has a cross validation method which enjoys nice properties of the path of optimization, which allows to evaluate a path of solutions as fast as a single model.

### randomForest

The standard if you want to use random forests with R. Link to the cran page

### e1071

I tried its “competitor” (kernlab), but prefered this one.

### Rtsne

Wrapper for the C++ implementation of Barnes-Hut t-Distributed Stochastic Neighbor Embedding. Was the fastest tSNE implementation when I tried them.

## Data viz

### coefplot

Visualizing linear regressions is now simple.

require(coefplot)

N <- 10
P <- 3

X <- matrix(rnorm(n = N*P), nrow = N)

w <- rnorm(P)

Y <- X %*% w + rnorm(P)

my_data <- cbind.data.frame(Y,X)
colnames(my_data) <- c("Y",paste0("Var",1:3))
model <- lm(Y ~ ., data = my_data)

coefplot(model)


### corplot

A matrix of correlation can be quite ugly. This one just makes it easier to read, with colors…

### forestFloor

Wouldn’t it be great to have something that tells you a little bit more about your random forests models ? This package can.

# Python

## General stuff

### tqdm

tqdm is one of the most useful package I discovered. Though it actually does not perform any operation or handles your dataframes smartly, it shows a progress bar for the loops you want it to. Still not convinced ? With it, you can keep track on every feature engineering job you launch, see which ones are never going to end without the pain of writing all these bars yourself.

### pandas

The industry standard for dataframes.

### numpy

The industry standard for numeric operations

### csv

Easy manipulation of csv files. The method DictReader is particularly useful when one needs to stream from a csv file.

### unicodecsv

import unicodecsv as csv


Solves so many issues.

## Machine learning libraries

### sk-learn

A collection of robust and well optimized methods. A must have.

### xgboost, catboost, gbm light

Libraries dedicated to gradient boosting. Amazing performances, amazingly robust.

# A little bit of context

After seeing plenty of “Python VS Java for data science”, questions that seemed ways to broad, I decided to focus on various benchmarks for different tasks. Today will be about Support Vector Machines, in R.

There are two main packages for SVMs in R : kernlab and e1071.

While kernlab implements kernel-based machine learning methods for classification, regression, clustering, e1071 seems to tackle various problems like support vector machines, shortest path computation, bagged clustering, naive Bayes classifier.

# Difference between the SVM implementations

## Proposed kernels

As kernlab focuses on kernel methods, many of them are implemented:

• rbfdot Radial Basis kernel function “Gaussian”
• polydot Polynomial kernel function
• tanhdot Hyperbolic tangent kernel function
• laplacedot Laplacian kernel function
• besseldot Bessel kernel function
• anovadot ANOVA RBF kernel function
• splinedot Spline kernel
• stringdot String kernel

While e1071 proposes the following:

• linear
• polynomial
• sigmoid

## Solver

e1071 relies on libsvm, which last update was released on December 22, 2016.

On the other hand, ksvm uses John Platt’s SMO algorithm for solving the SVM QP problem an most SVM formulations.

These may have an impact on the training time of these models (hopefully, the solutions should be the same).

# Testing it

Unfortunately, the names of the parameters are quite different between the two libaries are not exactly the same.

The radial basis kernel in e1071 is defined as $k(u,v) = \exp(-\gamma \Vert u-v \Vert ^2)$ and as $k(x,x") = \exp(-\sigma \Vert x-x" \Vert ^2)$. This is good. However, note that the $C$ (cost) parameters are called C and cost.

Besides, there are many models which are available (epsilon regressions, nu regressions…) and the default behavior is not always obvious.

At last, there have been many heuristics developed to chose the best “bandwith” (referred to as $\gamma$ and $\sigma$ depending on the package), and the proposed heuristics are not always the same. The code below makes sure the methods match when enough parameters are provided.

require("kernlab")
require("e1071")

N <- 1000
P <- 20
noise <- 3

X <- as.matrix(matrix(rnorm(N * P), nrow = N))
Y <- as.vector(X[, 1] + X[, 2] * X[, 2] + noise * rnorm(P))

model_kernlab <-
kernlab::ksvm(
x = X,
y = Y,
scaled = TRUE,
C = 5,
kernel = "rbfdot",
kpar = list(sigma = 1),
type = "eps-svr",
epsilon = 0.1
)

model_e1071 <- e1071::svm(x = X,
y = Y,
cost = 5,
scale = TRUE,
gamma = 1,
type = "eps-regression",
epsilon = 0.1)


Let”s make sure the model match.

> mean(abs(
+   predict(object = model_e1071, newdata = X) - predict(object = model_kernlab, newdata = X)
+ ))
[1] 1.254188e-14
>
> sum(abs(predict(object = model_e1071, newdata = X) - Y))
[1] 380.0338
> sum(abs(predict(object = model_kernlab, newdata = X) - Y))
[1] 380.0338


# Benchmarking

## Results

Now that we know the algorithms propose the same results, we can (safely) compare the time of execution.

e1071 is in red

Given the success of libsvm, I expected e1071 to be faster than kernlab. The heuristics implementend to optimize the quadratic form with its constraints are not the same, (see [1] and [2]) and they may actually lead to different results on other data sets.

## Learning more

[1] C.-C. Chang and C.-J. Lin, “LIBSVM: A library for support vector machines,” ACM Transactions on Intelligent Systems and Technology, vol. 2, no. 3, pp. 1–27, Apr. 2011.

[2] J. C. Platt, “Sequential Minimal Optimization: A Fast Algorithm for Training Support Vector Machines,” p. 21.

Applied predictive modelling is also good introduction to predictive modelling, with R.

## Code

If you want to reproduce the results, the whole code is below:


require("kernlab")
require("e1071")

fit_e1071 <- function(X, Y) {
e1071::svm(
x = X,
y = Y,
cost = 5,
scale = TRUE,
gamma = 1,
type = "eps-regression",
epsilon = 0.1
)
}

fit_kernlab <- function(X, Y) {
kernlab::ksvm(
x = X,
y = Y,
scaled = TRUE,
C = 5,
kernel = "rbfdot",
kpar = list(sigma = 1),
type = "eps-svr",
epsilon = 0.1
)
}

time_e1071 <- c()
time_kernlab <- c()

steps <- c(10, 20, 50, 100, 200, 500, 1000, 2000)

for (n in steps)
{
noise <- 3
P <- 20

X <- as.matrix(matrix(rnorm(n * P), nrow = n))
Y <- as.vector(X[, 1] + X[, 2] * X[, 2] + noise * rnorm(n))

time_e1071 <- c(time_e1071, system.time(fit_e1071(X, Y))[1])
time_kernlab <- c(time_kernlab, system.time(fit_kernlab(X, Y))[1])
}

plot(
steps,
time_e1071,
type = "l",
col = "red",
xlab = "n",
ylab = "Time",
main = paste0("Execution time for ", P, " features"))
lines(steps, time_kernlab)


# Introduction

Following the article about machine learning and ocaml I present another learning algorithm in OCaml and its comparison to a Python (compiled with pypy) equivalent.

First of all, PyPy is a fast, compliant alternative implementation of the Python language (2.7.13 and 3.5.3). As fast, it means orders of magnitude faster than a simple Python execution. As many libraries are not (directly) compatible with it, it remains quite unused. However, when using the default libraries, PyPy works like a charm.

# Online logistic regression

A common algorithm, often met on Kaggle, is the online logistic regression. Note that the data used will as well come from the Avazu CTR competition. To make the experience shorter, I will only work with the first 1 000 000 lines of the train.csv file (later referred to as train_small.csv).

This algorithm allows to train data in streaming which means that one does not need to load all the data in memory (which is sometimes infeasible). These methods are usually quite fast, and being simple to implement, this allows a lot of tuning and feature engineering on the fly.

On top of that, it automatically “one-hot encodes” the data. Which means that even if the number of categories per variable is important (which results in an underlying high dimensional space), this will not be an issue for this method (and the memory used by this program will remain constant, randomly projecting some components).

## The Python code

I do not take any credit for the awesomeness of this code. I simply paste it for the experiment to be easier to reproduce. Some modifications have been performed to make it more comparable to the ocaml implementation (most of them are commented).

'''
DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
Version 2, December 2004

Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>

Everyone is permitted to copy and distribute verbatim or modified
copies of this license document, and changing it is allowed as long
as the name is changed.

DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

0. You just DO WHAT THE FUCK YOU WANT TO.
'''

from datetime import datetime
from math import exp, log, sqrt

##############################################################################
# parameters #################################################################
##############################################################################

# A, paths
train = 'train_small.csv'               # path to training file
# B, model
alpha = .01  # learning rate
# C, feature/hash trick
D = 2 ** 20              # number of weights to use
do_interactions = False  # whether to enable poly2 feature interactions

# D, training/validation
epoch = 1      # learn training data for N passes
holdout = 100  # use every N training instance for holdout validation

##############################################################################
# class, function, generator definitions #####################################
##############################################################################

class logistic_regression(object):
''' Classical logistic regression

This class (algorithm) is not used in this code, it is putted here
for a quick reference in hope to make the following (more complex)
algorithm more understandable.
'''

def __init__(self, alpha, D, interaction=False):
# parameters
self.alpha = alpha

# model
self.w = [0.] * D

def predict(self, x):
# parameters
alpha = self.alpha

# model
w = self.w

# wTx is the inner product of w and x
wTx = sum(w[i] for i in x)

# bounded sigmoid function, this is the probability of being clicked
return 1. / (1. + exp(-max(min(wTx, 35.), -35.)))

def update(self, x, p, y):
# parameter
alpha = self.alpha

# model
w = self.w

g = p - y

# update w
for i in x:
w[i] -= g * alpha

def logloss(p, y):
''' FUNCTION: Bounded logloss

INPUT:
p: our prediction

OUTPUT:
logarithmic loss of p given y
'''

# p = max(min(p, 1. - 10e-15), 10e-15)
return -log(p) if y == 1. else -log(1. - p)

def data(path, D):
''' GENERATOR: Apply hash-trick to the original csv row
and for simplicity, we one-hot-encode everything

INPUT:
path: path to training or testing file
D: the max index that we can hash to

YIELDS:
ID: id of the instance, mainly useless
x: a list of hashed and one-hot-encoded 'indices'
we only need the index since all values are either 0 or 1
y: y = 1 if we have a click, else we have y = 0
'''

# process id
# ID = row['id'] -> not needed
del row['id']

# process clicks
y = 0.
#if 'click' in row: -> always true in the train set
if row['click'] == '1':
y = 1.
del row['click']

# turn hour really into hour, it was originally YYMMDDHH
#row['hour'] = row['hour'][6:]

# build x
x = [0]  # 0 is the index of the bias term
#for key in sorted(row):  # sort is for preserving feature ordering
for key in row:
value = row[key]

# one-hot encode everything with hash trick
index = abs(hash(key + '_' + value)) % D
x.append(index)

yield t, x, y

##############################################################################
# start training #############################################################
##############################################################################

start = datetime.now()

# initialize ourselves a learner
learner = logistic_regression(alpha, D)

# start training
for e in xrange(epoch):
loss = 0.
count = 0

for t, x, y in data(train, D):  # data is a generator
#  t: just a instance counter
# ID: id provided in original data
#  x: features
#  y: label (click)

# step 1, get prediction from learner
p = learner.predict(x)

if t % holdout == 0:
# step 2-1, calculate holdout validation loss
#           we do not train with the holdout data so that our
#           validation loss is an accurate estimation of
#           the out-of-sample error
loss += logloss(p, y)
count += 1
else:
# step 2-2, update learner with label (click) information
learner.update(x, p, y)

if t % 100000 == 0 and t > 1:
print('encountered: %d\tcurrent logloss: %f' % (
t, loss/count))



## OCaml implementation

open Maths

let get_indices dict n = Hashtbl.fold (fun k v acc -> ((Hashtbl.hash (k^" "^v)) mod n)  :: acc) dict []

let predict indices weights = sigmoid (dot_product indices weights)

let rec update indices weights p y alpha =  match indices with
| [] -> ()
| h::tail -> weights.(h) <- (weights.(h) -. (p -. y) *. alpha) ; update tail weights p y alpha

let n = pow 2 20
let weights = Array.make n 0.
let updater indices weights p y = update indices weights p y 0.01
let refresh_loss = 100000

let train weights updater dict_stream =
let rec aux weights updater dict_stream t loss n = match (try Some( Stream.next dict_stream)
with _ -> None) with
| Some dict -> Hashtbl.remove dict "id";
let y = float_of_string (Hashtbl.find dict "click") in
Hashtbl.remove dict "click";
let indices = get_indices dict n in
let p = predict indices weights in
updater indices weights p y;

if ((t mod refresh_loss) == 0) && t > 0 then begin
print_string "encountered: ";
print_int t;
print_string "\t logloss:";
print_float (loss /. float_of_int(t));
print_endline " ";
end;

aux weights updater dict_stream (t + 1) (loss +. (log_loss p y)) n

| None -> () in aux weights updater dict_stream 0 0. (Array.length weights) ;;

train weights updater dict_stream;


Where the maths.ml contains few math functions.

let dot_product indices weights =
let rec aux indices weights acc =
match indices with
| [] -> acc
| h::tail -> aux tail weights (acc +. weights.(h)) in
aux indices weights 0.

let sigmoid x = 1. /. (1. +. exp(0. -. (max (min x 35.) (-35.))))

let log_loss p y = match y with 1. -> -. log(p) | _ -> -. log(1. -. p)

let rec pow a = function
| 0 -> 1
| 1 -> a
| n ->
let b = pow a (n / 2) in
b * b * (if n mod 2 == 0 then 1 else a)



And read_tools.ml implements various tools to stream from a csv file.

open Str

let csv_separator = ","

let err_lists_sizes = "Incompatible lists size"

let line_stream_of_channel channel =
Stream.from (fun _ -> try Some (input_line channel) with End_of_file -> None)

let read_lines file_path = line_stream_of_channel (open_in file_path)

let split_line line = Str.split (Str.regexp csv_separator) line

let concat_elements list1 list2 =
let rec aux list1 list2 acc = match list1,list2 with
| [],[] -> acc
| a,[] -> failwith err_lists_sizes
| [],a -> failwith err_lists_sizes
| h1::t1,h2::t2 -> aux t1 t2 ((h1^h2)::acc) in List.rev (aux list1 list2 [])

let to_dict list1 list2 =
let rec aux list1 list2 my_hash = match list1,list2 with
| [],[] -> my_hash
| a,[] -> failwith err_lists_sizes
| [],a -> failwith err_lists_sizes
| h1::t1,h2::t2 -> Hashtbl.add my_hash h1 h2; aux t1 t2 my_hash in aux list1 list2 (Hashtbl.create 15)

let line_stream = read_lines file_path in
let header = split_line (Stream.next line_stream) in
Stream.from
(fun _ ->
try Some (to_dict header (split_line (Stream.next line_stream))) with End_of_file -> None)


# Results

$time pypy main.py encountered: 100000 current logloss: 0.435212 encountered: 200000 current logloss: 0.433022 encountered: 300000 current logloss: 0.416148 encountered: 400000 current logloss: 0.411722 encountered: 500000 current logloss: 0.403127 encountered: 600000 current logloss: 0.405477 encountered: 700000 current logloss: 0.405665 encountered: 800000 current logloss: 0.400225 encountered: 900000 current logloss: 0.397522 real 0m24.649s user 0m23.964s sys 0m0.540s  $ ocamlfind opt -linkpkg str.cmxa maths.ml read_tools.ml main.ml -o main.byte
$time ./main.byte encountered: 100000 logloss:0.422601941149 encountered: 200000 logloss:0.418270062183 encountered: 300000 logloss:0.409809392923 encountered: 400000 logloss:0.40026898568 encountered: 500000 logloss:0.396667944914 encountered: 600000 logloss:0.398242961764 encountered: 700000 logloss:0.397423028349 encountered: 800000 logloss:0.394274547682 encountered: 900000 logloss:0.391874034523 real 0m23.187s user 0m22.980s sys 0m0.176s  The logloss seems lower with the OCaml code. Don’t be fooled by this. This stems from the fact that Python and OCaml have different hashing functions, therefore, the collisions happening between the features (with one hot encoding) are not the same from one source to the other. As for the training time, there is no sensible difference ! I guess that concludes the story… For this problem, just pick the language you feel most comfortable with :) # Improvements ## In terms of code Actually, OCaml as well has a csv library, available with opam. ## In terms of accuracy There are many variations of this algorithm. The “most famous” being the FTRL # Learning more Foundations of Machine Learning by Mehryar Mohri, Afshin Rostamizadeh, Ameet Talwalkar and Francis Bach provides a theoretical framework to various machine learning algorithms and a detailed implementation of some of them. The section about streaming algorithms is particularly useful in the context of this article. Real World OCaml: Functional programming for the masses by Yaron Minsky, Anil Madhavapeddy and Jason Hickey is a good introduction to OCaml. # Implementing k Nearest Neighbours in OCaml # Introduction Here and there, people wonder about the possibility to use functionnal programming to approach machine learning. I decided to give it a try with some learning algorithms and noted that there are actually various options to use external libraries (unfortunately, nothing getting close to scikit learn’s maturity) A quick reminder about the k-nearest neighbours. It was first described in the early 1950s and is often referred to as a “lazy learner”, as it merely stores the data, waiting to be provided with points to classify. Then, in a metric space $(X,d)$ given a point $y \in X$, and $n$ labelled points $S = (x_i,l_i) \in (\mathbb{R} \times \{0,1\}) ^ n$ it will return the most common labels among the $k$ closest point to $y$. Simple, isn’t it ? Actually, one does not need more information to implement it. So let’s get started. # The expressivity of ocaml For fun, let’s see how easy it is to implement a k-nearest neighbours in ocaml. Note that we only need to retrieve the closest points from one point in an array of points. The method find_nearest_neighbours does this. Note how generic it is : the point can have any type (float array, string list…) as long as the distance operates on this type. Think about all the templates that should be written in other languages. And the compiler will tell me if types are incompatible (when Python would wait until an error appears). (* Returns the k smallest elements of an array *) let get_smallest_elements_i input_array k = let n = Array.length input_array in let indices = Array.init n (fun x -> x) in for i = 0 to (k-1) do for j = (n-1) downto 1 do if input_array.(indices.(j-1)) > input_array.(indices.(j)) then begin let b = indices.(j-1) in indices.(j-1) <- indices.(j); indices.(j) <- b; end done; done; Array.sub indices 0 k (* Returns the k closest points from current_point in all_points *) let find_nearest_neighbours current_point all_points k distance = let distances = Array.map (fun x -> distance x current_point) all_points in get_smallest_elements_i distances k (* Returns the most common labels among the neihbours *) let predict nearest_neighbours labels = let sum a b = a +. b in let k = Array.length nearest_neighbours in if Array.fold_left sum 0. (Array.init k (fun i -> labels.(nearest_neighbours.(i)))) > 0. then 1. else ~-.1.  Now we need a dataset to try the algorithm. Nothing really funny there. (* Toy data *) let max_length = 1. let chessboard_boundary x y = if ((mod_float x 0.5) -. 0.25) *. ((mod_float y 0.5) -. 0.25) > 0. then 1. else ~-.1. let circle_boundary x y = if (x**2. +. y**2.) > 0.5 then 1. else ~-.1. let unlabelled_boundary x y = 2. ;; (* Given a decision boundary, returns a data set and the associated labels *) let make_data n_points decision_boundary = let output_data = Array.init n_points (fun _ -> (Array.make 2 0.)) in let output_label = Array.make n_points 0. in for i = 0 to (n_points-1) do output_data.(i).(0) <- Random.float max_length; output_data.(i).(1) <- Random.float max_length; output_label.(i) <- decision_boundary output_data.(i).(0) output_data.(i).(1) done; output_data, output_label  Now that we defined the points as arrays of floats, we need to implement distances on it. let sum a b = a +. b in (* Usual Euclide Distance *) let euclide_distance x y = let squares_diff = Array.init (Array.length x) (fun i -> (x.(i) -. y.(i))**2.) in Array.fold_left sum 0. squares_diff let manhattan_distance x y = let squares_diff = Array.init (Array.length x) (fun i -> abs (x.(i) -. y.(i)) ) in Array.fold_left sum 0. squares_diff  Gluing up all the pieces together : open Knn open Distances open ToyDataset (* Number of points in the training set*) let n_points = int_of_string Sys.argv.(1) ;; (* Parameter k of the kNN algorithm *) let k = int_of_string(Sys.argv.(2)) ;; (* Number of points in the training set *) let n_test_points = 50 ;; (* Train and test data*) let train_data, labels = make_data n_points circle_boundary;; let test_data, pseudo_labels = make_data n_test_points unlabelled_boundary ;; (* For each point in the test set, stores the indices of the nearest neighbours *) let nearest_neighbours = Array.map (fun x -> find_nearest_neighbours x train_data k euclide_distance) test_data;; (* Evaluates and prints the accuracy of the model *) let mismatches = ref 0. ;; for l = 0 to (n_test_points-1) do pseudo_labels.(l) <- predict nearest_neighbours.(l) labels ; if pseudo_labels.(l) <> (circle_boundary test_data.(l).(0) test_data.(l).(1)) then (mismatches := !mismatches +. 1.) else (); done; print_string ("Error rate : "^string_of_float(100. *. !mismatches /. (float_of_int n_test_points))^"%\n");  Now I recommend using ocamlbuild. It will save you loads of time. Especially with large projects. Assuming the latest part is called main.ml simply enter this in the terminal: me$ ls
distances.ml  knn.ml  main.ml  toyDataset.ml

me$ocamlbuild main.byte Finished, 9 targets (1 cached) in 00:00:00.  Now, you just have to call the produced byte file with the first argument being the number of points to generate and the second one, the parameter $k$. me$ ./main.byte 100 5
Error rate : 4.%
me$./main.byte 1000 5 Error rate : 2.% me$ ./main.byte 3000 5
Error rate : 0.%


I leave this to another post : pypy vs ocaml for streaming learning, coming soon :)

If you are interested in this method and further developments, you may find the following articles interesting:

[1]S. Cost and S. Salzberg, “A weighted nearest neighbor algorithm for learning with symbolic features,” Machine Learning, vol. 10, no. 1, pp. 57–78, Jan. 1993.

[2]J. Wang, P. Neskovic, and L. N. Cooper, “Improving nearest neighbor rule with a simple adaptive distance measure,” Pattern Recognition Letters, vol. 28, no. 2, pp. 207–213, Jan. 2007.

[3]K. Yu, L. Ji, and X. Zhang, “Kernel Nearest-Neighbor Algorithm,” Neural Processing Letters, vol. 15, no. 2, pp. 147–156, Apr. 2002.

# Generic cross-validation

## Definitions

### k-fold cross-validation

Cross-validation is a process that enables to estimate the out-of-sample performance of a model. There exist many types of cross-validation, but the most common method consists in splitting the training-set in $k$ “folds” ($k$ samples of approximately $n/k$ lines) and train the model $k$-times, each time over samples of $n-n/k$ points. The prediction error is then measured on the predictions of the remaining $n/k$ points.

Illustration of the cross-validation. From Wikipedia.

### Leave one out cross-validation (LOOCV)

The leave one out cross-validation is a specialization of the $k$-fold cross-validation, with $k=n$. For each point, you train the model over the $n-1$ other points, predict the label (or value, in the case of a regression problem) and average the errors.

### Hyperparameters tuning

The reason to perform cross-validation is to enable the tuning of hyperparameters (or doing feature selection, but I will focus on hyperparameters tuning). They are parameters that are not directly infered from the data (this definition is quite lose). Per example, in the case of a linear regression, the coefficients of the model are directly infered. In the case of a penalized regression, the penalty parameter is not infered during the training procedure (if there is a way to select it, please let me know in the comments), and the usual way to chose the best penalty parameter is by cross validating many models, with different penalty parameters and chosing the one which achieves the best score (the highest accuracy, the lowest error…).

This is where cross-validation becomes costly : suppose you want to try $10$ values of your hyper-parameter (this can be much higher), and evaluate the performance of each hyperparameter with a $5$ fold cross-validation. This will be $10 \cdot 5 = 50$ times longer than training a single model !

Usually, there is not one single hyper parameter. In the case of the Support Vector Machines with Radial Basis Functions, there are usually two of them which are tuned $C$ and $\gamma$. Trying $10$ values for each hyperparameter now leads to $100$ models to train (which is in turn multiplied by the number of folds).

This explains the need for smarter approaches to cross-validations.

## Generic implementation

Cross-validation is a long process. And it needs to be repeated. Many times. Maybe even more when the number of parameters is large. The leave-one-out cross-validation is the longest one, as you have to train the model as many times as you have data points.

You have two options. Find the best implementation of your algorithm given your problem. Buy more computation power.

Assuming you have already achieved the first step and that the second one is not really satisfactory, there is another option. Change your cross-validation method! Though it needs some efforts (the usual cross-validation pipelines/loops have to be specialized), it will be fun!

Following the article about time complexity and enjoying the fact that, when you train a model on a specific fold during a cross-validation, you may reuse part of your calculations, I will present some tips to make this cross-validation faster.

As always, this improvement has a price : genericity. When using scikit learn, the models have similar signatures. The cross-validation procedure has to be written only once and works for every model. See per example the code below.

import pandas as pd
import numpy as np

from time import time
from sklearn import cross_validation

class Stacker:

def __init__(self, penalty, n_folds, verbose=True, random_state=1):
self._penalty = penalty
self._n_folds = n_folds
self._verbose = verbose
self._random_state = random_state

def Run(self, X, y, model, predict_method):
kf = cross_validation.KFold(
y.shape[0], n_folds=self._n_folds, shuffle=True, random_state=self._random_state)
trscores, cvscores, times = [], [], []
i = 0
stack_train = np.zeros(len(y))  # stacked predictions
for i, (train_fold, validation_fold) in enumerate(kf):
i = i + 1
t = time()
model.fit(X.iloc[train_fold], y.iloc[train_fold])

tr_pred = predict_method(model, X.iloc[train_fold])

trscore = self._penalty(y.iloc[train_fold], tr_pred)

validation_prediction = predict_method(
model, X.iloc[validation_fold])
cvscore = self._penalty(
y.iloc[validation_fold], validation_prediction)

trscores.append(trscore)
cvscores.append(cvscore)
times.append(time() - t)

stack_train[validation_fold] = validation_prediction

if self._verbose:
print("TRAIN %.5f | TEST %.5f | TEST-STD %5f | TIME %.2fm (1-fold)" %
(np.mean(trscores), np.mean(cvscores), np.std(cvscores), np.mean(times) / 60))
print(model.get_params(deep=True))
print("\n")

return np.mean(cvscores), stack_train


Not only it performs a cross-validation, but keeps the out-of-sample predictions for each fold. This allows to do model stacking, another topic I will probably discuss in antoher post.

As you see in this code, there is no information regarding the model needed. It will just take a model, that has a fit method, and predict it (the predict method must be passed as a function, it allows post processing of the predictions, per example).

## Linear regression

Here, the specialization works so well that one can even use the following closed formula for a leave one out cross-validation

Following the equation of a linear model : $y = X\beta + \mathbf{e}.$ it is well known that (for an OLS estimate) $\hat{\beta} = \underset{\beta}{\operatorname{argmin}} \| y-X \beta \|^2$ we have $\hat{\beta} = (X'X)^{-1}Xy$.

So we can write :

Where $\mathbf{H} = X(X'X)^{-1}X'$

If the diagonal values of $\mathbf{H}$ are denoted by $h_{1},\dots,h_{n}$, then the cross-validation statistic can be computed using:

Where $e_{i}$ is the residual obtained from fitting the model to all $n$ observations. See [4] for more details.

## Elastic-net

The famous library glmnet [3] solves the following problem, over a whole “path” (i.e. having $\lambda$ varying) while being as fast as one would normally compute the solution for a single value of $\lambda$.

The least angle regression (LARS) algorithm, on the other hand, is unique in that it solves the minimzation problem for all $\lambda$ ∈ [0,∞] […] This is possible because the lasso solution is piecewise linear with respect to $\lambda$.

The library comes with a cross-validation method supporting parallelization:

cv.glmnet(x, y, weights, offset, lambda, type.measure, nfolds, foldid, grouped, keep,
parallel, ...)


## SVMs

The same authors proposed a similar method for calculating solutions to SVMs calibrations, where a path of solution depending on $C$, the cost parameter is proposed.

An R package svmpath is available. Refering to the article:

It exploits the fact that the “hinge” loss-function is piecewise linear, and the penalty term is quadratic. This means that in the dual space, the lagrange multipliers will be pieceise linear (c.f. lars).

require("svmpath")

N <- 500
P <- 2
sigma <- 0.1

X <- matrix(rnorm(N * P), nrow = N)
Y <- 2 * (X[, 1] + X[, 2] * X[, 2] + sigma * rnorm(P) > 0) - 1

svm_model <-
svmpath(
x = X,
y = Y,
plot = F
)
plot(svm_model)

Xtest <- matrix(rnorm(N * P), nrow = N)
Ytest <-
2 * (Xtest[, 1] + Xtest[, 2] * Xtest[, 2] + sigma * rnorm(P)  > 0) - 1

pred <-
svmpath::predict.svmpath(svm_model, newx = Xtest, type = "class")

eval_error <- function(predicted) {
return(mean(abs(Ytest - predicted)))
}

errors <- apply(X = pred, MARGIN = 2, FUN = eval_error)
plot(
svm_model\$lambda,
errors,
main = "Out Of Sample error rate",
xlab = expression(lambda),
ylab = "Error rate"
)


Unfortunately, it has a very large memory consumption event for small data sets.

With gradient boosting, when cross validating over the number of trees, a simple observation is to note that models are trained sequentially. If $k$ models are trained over $k$ folds, each model will predict a new point based on the following equation:

Now, by simply truncating the sum, one can create the sequence:

For each fold, this step can be performed, so that the performance at each step can be evaluated. XGBoost implements something along these lines (with callbacks), the method can be found on their repository [6].

cv(params, dtrain, num_boost_round=10, nfold=3, stratified=False, folds=None,
metrics=(), obj=None, feval=None, maximize=False, early_stopping_rounds=None,
fpreproc=None, as_pandas=True, verbose_eval=None, show_stdv=True,
seed=0, callbacks=None, shuffle=True)


# A generic framework

All this is nice, but it means that each method requires a specific cross-validation routine, depending on the parameter one is focusing on. It makes it quite complex, forces to write more code (and make mistakes). It would be amazing if there were something that is generic, wouldn’t it ?

There is. All the ideas summarized here come from the paper [1] of M. Izbicki. I really recommand going through it (especially if you have a taste for algebra).

The idea is to consider :

• the data, being a monoid with a concatenation operation : $A \clubsuit B$ is just the bindings of the rows of $A$ with the rows of $B$ (the neutral element being an empty set).

• the learner $m$ which, given some input data, returns a model $T : A \ \rightarrow (f:x\rightarrow \text{label})$

• a morphism $\diamondsuit$, so that $m(A \clubsuit B) = m(A) \diamondsuit m(B)$

Now, if $\diamondsuit$ can be evaluated in a constant time (independant of the length of $A$ and $B$), one can have cross-validations in $O(n+k)$ instead of $O(kn)$. This works for Naive Bayes, nearest centroids, and other methods.

Now the algorithm presented is the Monoid Cross Validation. Keeping $n$ the number of points and $k$ the number of folds for the notations, and $G_i$ the i-th fold for the k-fold cross-validation, $k$ models are trained on each fold. Now the models are merged in $k-1$ operations (using the morphism relationship) and the prediction is performed over the last fold. If the prefixes and suffixes are evaluated beforehand (i.e. building the sequences of models trained on the various folds in the two orders) a method enables to obtain the cross-validation in $O(n+k)$ operations.

This topic is really interesting and I probably will dedicate it a full article. What about a toy ocaml implementation ?

# References

[1] M. Izbicki, “Algebraic classiﬁers: a generic approach to fast cross-validation, online training, and parallel training,” p. 9.

[2] T. Hastie, S. Rosset, R. Tibshirani, and J. Zhu, “The Entire Regularization Path for the Support Vector Machine,” p. 25.

[3] R. J. Tibshirani and J. Taylor, “The solution path of the generalized lasso,” The Annals of Statistics, vol. 39, no. 3, pp. 1335–1371, Jun. 2011.

[4] “Plane Answers to Complex Questions: The theory of linear models” Ronald Christensen

# Learning more

For those interested about ideas in statistics stemming from algebra (and not only matrix operations) and geometry, I am only aware of two books covering this topic : Algebraic and Geometric Methods in Statistics and Lectures on Algebraic Statistics