Gaël Varoquaux

μ · eg

>>> from skrub.datasets import fetch_employee_salaries
>>> dataset = fetch_employee_salaries()
>>> employees_df, y = dataset.X, dataset.y

>>> from skrub import TableVectorizer
>>> X = TableVectorizer().fit_transform(employees_df)

>>> from skrub import TextEncoder
>>> text_encoder = TextEncoder(
        "sentence-transformers/paraphrase-albert-small-v2",
        device="cpu",
    )
>>> tab_vec = TableVectorizer(high_cardinality=text_encoder)
>>> X = tab_vec.fit_transform(employees_df)

>>> # First retrieve data
>>> from skrub.datasets import fetch_employee_salaries
>>> dataset = fetch_employee_salaries()
>>> df = dataset.X
>>> y = dataset.y
>>> # The dataframe is a quite rich and complex dataframe, with various columns
>>> df

>>> from skrub import tabular_learner
>>> learner = tabular_learner('regressor')
>>> # The resulting learner can apply all the machine-learning conveniences (eg cross-validation) directly on the dataframe
>>> from sklearn.model_selection import cross_val_score
>>> cross_val_score(learner, df, y)
array([0.89370447, 0.89279068, 0.92282557, 0.92319094, 0.92162666])

sudo apt install qemu-system-arm qemu-efi libguestfs-tools

wget -O installer-vmlinuz http://http.us.debian.org/debian/dists/jessie/main/installer-armhf/current/images/netboot/vmlinuz
wget -O installer-initrd.gz http://http.us.debian.org/debian/dists/jessie/main/installer-armhf/current/images/netboot/initrd.gz

# Create a drive
qemu-img create -f qcow2 hda.qcow2 5G

qemu-system-arm -M virt -m 1024 \
-kernel installer-vmlinuz \
-initrd installer-initrd.gz \
-drive if=none,file=hda.qcow2,format=qcow2,id=hd \
-device virtio-blk-device,drive=hd \
-netdev user,id=mynet \
-device virtio-net-device,netdev=mynet \
-nographic -no-reboot

sudo chmod 644 /boot/vmlinuz*

virt-ls -a hda.qcow2 /boot/

virt-copy-out -a hda.qcow2 /boot/vmlinuz-3.16.0-6-armmp-lpae /boot/initrd.img-3.16.0-6-armmp-lpae .

ln -s initrd.img-3.16.0-6-armmp-lpae initrd.img
ln -s vmlinuz-3.16.0-6-armmp-lpae vmlinuz

qemu-system-arm -M virt -m 1024 \
-kernel vmlinuz \
-initrd initrd.img \
-drive if=none,file=hda.qcow2,format=qcow2,id=hd \
-device virtio-blk-device,drive=hd \
-netdev user,id=mynet \
-device virtio-net-device,netdev=mynet \
-nographic -no-reboot -append "root=/dev/vda2"

apt-get update
apt-get upgrade
apt-get build-dep unison
wget https://github.com/bcpierce00/unison/archive/v2.48.15v4.tar.gz
tar -xvzf v2.48.15v4.tar.gz
cd unison-2.48.15v4
make UISTYLE=text NATIVE=true STATIC=true

dump
load
.npy
>>> import numpy as np
>>> import joblib # joblib version: 0.9.4
>>> obj = [np.ones((5000, 5000)), np.random.random((5000, 5000))]

# 3 files are generated:
>>> joblib.dump(obj, '/tmp/test.pkl', compress=True)
['/tmp/test.pkl', '/tmp/test.pkl_01.npy.z', '/tmp/test.pkl_02.npy.z']
>>> joblib.load('/tmp/test.pkl')
[array([[ 1.,  1., ...,  1.,  1.]],
 array([[ 0.47006195,  0.5436392 , ...,  0.1218267 ,  0.48592789]])]

>>> import numpy as np
>>> import joblib # joblib version: 0.10.0 (dev)
>>> obj = [np.ones((5000, 5000)), np.random.random((5000, 5000))]

# only 1 file is generated:
>>> joblib.dump(obj, '/tmp/test.pkl', compress=True)
['/tmp/test.pkl']
>>> joblib.load('/tmp/test.pkl')
[array([[ 1.,  1., ...,  1.,  1.]],
 array([[ 0.47006195,  0.5436392 , ...,  0.1218267 ,  0.48592789]])]

>>> joblib.dump(obj, '/tmp/test.pkl.z')   # zlib
['/tmp/test.pkl.z']
>>> joblib.dump(obj, '/tmp/test.pkl.gz')  # gzip
['/tmp/test.pkl.gz']
>>> joblib.dump(obj, '/tmp/test.pkl.bz2')  # bz2
['/tmp/test.pkl.bz2']
>>> joblib.dump(obj, '/tmp/test.pkl.lzma')  # lzma
['/tmp/test.pkl.lzma']
>>> joblib.dump(obj, '/tmp/test.pkl.xz')  # xz
['/tmp/test.pkl.xz']

>>> joblib.dump(obj, '/tmp/test.pkl.compressed', compress=('zlib', 6))
['/tmp/test.pkl.compressed']
>>> joblib.dump(obj, '/tmp/test.compressed', compress=('lzma', 6))
['/tmp/test.pkl.compressed']

>>> joblib.load('/tmp/test.compressed')
[array([[ 1.,  1., ...,  1.,  1.]],
 array([[ 0.47006195,  0.5436392 , ...,  0.1218267 ,  0.48592789]])]

>>> with open('/tmp/test.pkl', 'wb') as f:
>>>    joblib.dump(obj, f)
['/tmp/test.pkl']
>>> with open('/tmp/test.pkl', 'rb') as f:
>>>    print(joblib.load(f))
[array([[ 1.,  1., ...,  1.,  1.]],
 array([[ 0.47006195,  0.5436392 , ...,  0.1218267 ,  0.48592789]])]

gzip.GzipFile
bz2.Bz2File
lzma.LzmaFile
>>> import gzip
>>> with gzip.GzipFile('/tmp/test.pkl.gz', 'wb') as f:
>>>    joblib.dump(data, f)
['/tmp/test.pkl.gz']
>>> with gzip.GzipFile('/tmp/test.pkl.gz', 'rb') as f:
>>>    print(joblib.load(f))
[array([[ 1.,  1., ...,  1.,  1.]],
 array([[ 0.47006195,  0.5436392 , ...,  0.1218267 ,  0.48592789]])]

open
>>> with open('/tmp/test.pkl.gz', 'rb') as f:
>>>     print(joblib.load(f))
[array([[ 1.,  1., ...,  1.,  1.]],
 array([[ 0.47006195,  0.5436392 , ...,  0.1218267 ,  0.48592789]])]

np.ndarray
open
gzip.GzipFile
bz2.Bz2file
lzma.LzmaFile
BinaryZlibFile
GzipFile
io.BytesIO
cPickle
In [1]: from scikits.learn import datasets
In [2]: digits = datasets.load_digits()
In [3]: X = digits.data
In [4]: y = digits.target
In [5]: from scikits.learn.svm import LinearSVC
In [6]: svc = LinearSVC()
In [7]: from scikits.learn.rfe import RFE
In [8]: %timeit RFE(estimator=svc, n_features=1, percentage=0.1).fit(X, y)
1 loops, best of 3: 21.5 s per loop
In [9]: from scikits.learn.glm import ElasticNet
In [10]: %timeit ElasticNet(alpha=.1, rho=0.7).fit(X, y)
10 loops, best of 3: 26.7 ms per loop

class BaseEstimator(object):
    @classmethod
    def _get_param_names(cls):
        args, varargs, kw, default = inspect.getargspec(cls.__init__)
        assert varargs is None, (
            'scikit learn estimators should always specify their '
            'parameters in the signature of their init (no varargs).'
            )
        # Remove 'self'
        args.pop(0)
        return args

    def _get_params(self):
        out = dict()
        for key in self._get_param_names():
            out[key] = getattr(self, key)
        return out

    def _set_params(self, **params):
        valid_params = self._get_param_names()
        for key, value in params.iteritems():
            assert key in valid_params, ('Invalid parameter %s '
                'for estimator %s' %
                (key, self.__class__.__name__))
            setattr(self, key, value)

@cv_params(l1=np.logspace(1e-4, 1, 10))
def __init__(self, l1=.5, fit_intercept=True)
# ...

# Create some data
import numpy as np
x, y = np.mgrid[0:10:100j, 0:10:100j]
z = x**2 + y**2
w = np.arctan(x/y)

# Visualize it
from enthought.mayavi import mlab
mlab.mesh(x, y, .05*z, scalars=w)

# Finally, add a few decorations.
mlab.axes()
mlab.outline()
mlab.view(-177, 82, 32)
mlab.show()

###############################################################
# Create some data
import numpy as np
x, y = np.mgrid[0:10:100j, 0:10:100j]
z = x**2 + y**2
w = np.arctan(x/y)

###############################################################
# Visualize the data
from enthought.mayavi import mlab

# Create the data source
src = mlab.pipeline.array2d_source(z)

# Add the additional scalar information 'w', this is where we need to be a bit careful,
# see
# http://code.enthought.com/projects/mayavi/docs/development/html/mayavi/auto/example_atomic_orbital.html
# and
# http://code.enthought.com/projects/mayavi/docs/development/html/mayavi/data.html
dataset = src.mlab_source.dataset
array_id = dataset.point_data.add_array(w.T.ravel())
dataset.point_data.get_array(array_id).name = 'color'
dataset.point_data.update()

# Here, we build the very exact pipeline of surf, but add a
# set_active_attribute filter to switch the color, this is code very
# similar to the code introduced in:
# http://code.enthought.com/projects/mayavi/docs/development/html/mayavi/mlab.html#assembling-pipelines-with-mlab
warp = mlab.pipeline.warp_scalar(src, warp_scale=.5)
normals = mlab.pipeline.poly_data_normals(warp)
active_attr = mlab.pipeline.set_active_attribute(normals,
                                            point_scalars='color')
surf = mlab.pipeline.surface(active_attr)

# Finally, add a few decorations.
mlab.axes()
mlab.outline()
mlab.view(-177, 82)
mlab.show()

72	68	174	1
64	79	181	1
56	59	166	0
81	62	161	1

Age	Weight	Height	Commorbidity	Cardiovascular event
72	68	174	Diabetes	1
64	79	181	Cardiac arrhythmia	1
56	59	166	NA	0
81	62	161	Asthma	1

Sex	Employee Position Title	Years of experience
Male	Master Police Officer	23
Female	Social Worker IV	17
Male	Police Officer III	12
Female	Police Aide	9
Male	Electrician I	4
Male	Bus Operator	15
Male	Bus Operator	22
Female	Social Worker III	13
Female	Library Assistant I	3
Male	Library Assistant I	5

Dataset	time with 0.13	time with 0.14
“lfw”: 13233 samples, 5 features	6.57 seconds	3.59 seconds
“make_blobs”: 30000, with 10 features	33.50 seconds	12.87 seconds

Forest implementation	train time	test time	prediction accuracy
Sklearn ExtraTrees	2.641s	0.082s	0.986
Sklearn RandomForest	5.074s	0.088s	0.981
WiseRF	5.665s	0.108s	0.979

Gaël Varoquaux

Stepping up as probabl’s CSO to supercharge scikit-learn and its ecosystem

Scikit-learn, a central tool

A new opportunity to boost scikit-learn and its ecosystem

My obsession as Probabl CSO: serving the data scientists

2025 highlights: AI research and code

Maïc, you lived 100 years, what changed?

A national recognition; but science and open source are bitter victories

TabICL: Pretraining the best tabular learner

Row-wise encoding

Column-specific embeddings

AI agents that use tools

AIs that break down questions reason better

Science must drive the narratives that shape society

AI super-intelligent to play Go, and math?

Imitation is not creation

When AIs invent

AI for health: the impossible necessity of unbiased data

2024 highlights: of computer science and society

When AIs must overcome the data

Aligning on which values?

Do AIs reason or recite?

Something new?

CARTE: toward table foundation models

Skrub 0.2.0: tabular learning made easy

model = tabular_learner(‘classifier’)

transformer = TableVectorizer()

Increasing support of polars

Promoting open-source, from inria to :probabl.

People underestimate how impactful Scikit-learn continues to be

Comité de l’intelligence artificielle: vision et stratégie nationale

2022, a new scientific adventure: machine learning for health and social sciences

Representation learning for relational data

Mathematical aspects of statistical learning for data science

Machine learning for health and social sciences

High-quality data-science software

My Mayavi story: discovering open source communities

The start of my adventure with Mayavi

What is Mayavi?

Working on Mayavi taught me code and communities

2021 highlight: Decoding brain activity to new cognitive paradigms

Context: Infering cognition from brain-imaging

Contribution: Informing specialized decoding questions from broad data accumulation

A research agenda that does not win all hearts

Hiring an engineer and post-doc to simplify data science on dirty data

Dirty data research

Reinventing data science

Join us in this adventure

A data-science engineer: new software with new ideas

A post-doc researcher: science joining data engineering to deep learning

Hiring someone to develop scikit-learn community and industry partners

Context: Scikit-learn @ Inria foundation

The growth of Scikit-learn

Scikit-learn @ Inria foundation

Mandate

Growing our open-source community

Increasing our corporate visibility

A good fit

2020: my scientific year in review

Technical discussions are hard; a few tips

Open source can be anxiety-generating for the maintainers

The danger abusive gatekeeping

Hear the other: exchange

Convey ideas well: pedagogy

Cater for emotions: tone

Jean Dechoux, June 13rd 1923 – Feb 9th 2020

Survey of machine-learning experimental methods at NeurIPS2019 and ICLR2020

2019: my scientific year in review

Comparing distributions: Kernels estimate good representations, l1 distances give good tests

Getting a big scientific prize for open-source software

2018: my scientific year in review

Atlases of cognition with large-scale human brain mapping

Predictive models avoid excessive reductionism in cognitive neuroimaging

Individual Brain Charting, a high-resolution fMRI dataset for cognitive mapping

A new personal research agenda: DirtyData

Similarity encoding: analysis with non-normalized string categories

A foundation for scikit-learn at Inria