page de blog - 1/6¶

2017-09-19

Voici quelques questions abordées durant la première séance. L’instruction pandas.read_csv n’a pas toujours fonctionné. Deux principales raisons à cela, la première à cause du chemin. Un chemin peut être absolu, il commence par c:\ ou \ sous Windows ou / sous Linux, ou relatif, il commence par un nom. Le chemin absolu ne pose pas de difficulté en Python sauf dans quelques cas où le chemin est un chemin réseau (commençant par \\). Par défaut, Python cherche les données à partir de l’emplacement du programme si le chemin est relatif. Cet emplacement est aussi l’emplacement courant pour le programme. Il suffit de placer les fichiers dans ce répetoire pour n’utiliser que le nom du fichier. On l’obtient en exécutant :

>>>

import os
print(os.getcwd())

Sortie

    c:\jenkins\pymy\ensae_teaching_cs\ensae_teaching_cs_UT_36_std\_doc\sphinxdoc

Il est possivble de vérifier le contenu d’un répertoire, en particulier du répertoire courent avec :

>>>

import os
for name in os.listdir("."):
    print(name)

Sortie

    build
    build3
    source

La seconde raison est l”encoding. Les caractères chinois nécessitent un encodage particulier car il faut plusieurs octets pour coder un des nombreux caractères. Il n’existe pas une seule façon d’associer un caractère chinois mais la façon commune est utf-8 qui est le standard du web. Il faut s’assurer que le code utilisée pour créer le fichier de données est le même que celui utilisé pour relire :

import pandas
df = pandas.read_csv("...", encoding="...")

Autre question, pourquoi numpy alors que pandas fait déjà tout. La réponse tient dans l’image qui suit :

pandas sert à préparer les données, à transformer tout ce qui n’est pas numérique en nombres réelles, à enrichir les données en fusionnant avec d’autres bases. Une fois que cela est fait, on peut convertir toutes les données au format numérique, en matrice pour simplfiier car les algorihmes numériques utilisant principalement cela. Des nombres réels sous forme de matrices, c’est ce que manipulent tous les algorithmes de machine learning. matplotlib conclue le processus en donnant les moyens de représenter le résultat de l’expérience.

Pour ceux qui ont commencé la compétition, les liens vers les données sont cassés et seront réparés dès la publication de cet article. Un data leakage ou expérience surprenante avec la dernière variable de la base qui contient le nombre de valeurs non nulles parmi les colonnes dont le nom se termine pas 100g. La prise en compte de cette variable semble influencer beaucoup la prédiction.

2017-09-19

On veut écrire une fonction qui calcule la somme des nombres sur chaque ligne d’un carré magique pour s’assurer qu’on a bien la même somme à chaque fois.

1 2 3  --> 6
4 5 6  --> 15
7 8 9  --> 24

La première idée est d’écrire quelque chose comme :

>>>

def est_magique(a, b, c, d, e, f, g, h, i):
    l1 = a + b + c
    l2 = d + e + f
    l3 = g + h + i
    if l1 == l2 == l3:
        return True
    else:
        return False


print(est_magique(1, 2, 3, 4, 5, 6, 7, 8, 9))

Sortie

    False

Plus un code est long, plus la probabilité de faire une erreur est grande. C’est pourquoi, on préfère toujours un code court. La dernière partie de la fonction retourne un booléen qui en fait identique à la condition du test dont il dépend. On réduit donc les quatre dernières lignes à une seule.

>>>

def est_magique(a, b, c, d, e, f, g, h, i):
    l1 = a + b + c
    l2 = d + e + f
    l3 = g + h + i
    return l1 == l2 == l3


print(est_magique(1, 2, 3, 4, 5, 6, 7, 8, 9))

Sortie

    False

Avoir neuf lettres pour désigner les coefficients est l’assurance de se tromper. Une lettre pour désigner l’ensemble, une liste sera tout de suite plus lisible.

>>>

def est_magique(coefs):
    l1 = coefs[0] + coefs[1] + coefs[2]
    l2 = coefs[3] + coefs[4] + coefs[5]
    l3 = coefs[6] + coefs[7] + coefs[8]
    return l1 == l2 == l3


print(est_magique([1, 2, 3, 4, 5, 6, 7, 8, 9]))

Sortie

    False

Cela reste quand même fastidieux d’écrire les positions des coefficients. Réduisons encore cela avec la fonction python.sum.

>>>

def est_magique(coefs):
    l1 = sum(coefs[0:3])
    l2 = sum(coefs[3:6])
    l3 = sum(coefs[6:9])
    return l1 == l2 == l3


print(est_magique([1, 2, 3, 4, 5, 6, 7, 8, 9]))

Sortie

    False

C’est mieux mais il reste toujours le problème du copier/coller pour chaque ligne. Une boucle devrait résoudre le tout. Il faut également adapter la condition finale.

>>>

def est_magique(coefs):
    l123 = [sum(coefs[3 * i: 3 * i + 3]) for i in range(0, 3)]
    return l123[0] == l123[1] == l123[2]


print(est_magique([1, 2, 3, 4, 5, 6, 7, 8, 9]))

Sortie

    False

La dernière condition est toujours longue, on peut la simplifier en disant que si le plus petit et le plus grand montant de chaque ligne sont égaux, alors ils sont tous égaux.

>>>

def est_magique(coefs):
    l123 = [sum(coefs[3 * i: 3 * i + 3]) for i in range(0, 3)]
    return min(l123) == max(l123)


print(est_magique([1, 2, 3, 4, 5, 6, 7, 8, 9]))

Sortie

    False

Il reste maintenant à changer la fonction pour que celle-ci soit capable de traiter des carrés de n’importe quelle dimension. Les nombres 3 vont disparaître. On précise également la dimension du carré comme argument de la fonction même si on pourrait la dimension comme étant la racine carré de la longueur de la liste en entrée.

>>>

def est_magique(coefs, n):
    # n devrait être égal à len(coefs) ** 0.5
    ln = [sum(coefs[n * i: n * i + n]) for i in range(0, n)]
    return min(ln) == max(ln)


print(est_magique([1, 2, 3, 4, 5, 6, 7, 8, 9], 3))
print(est_magique([1, 2, 3, 4], 2))

Sortie

    False
    False

Le code final est plus concis et plus générique. En supportant plusieurs dimensions pour lesquelles on le teste, il est aussi plus robuste. En revanche, il est plus lent que la version initiale qui ne fait que les calculs nécessaires. La dernière version inclut des opérations implicites mais pourtant bien réelles. A chaque itération de boucle, on incrémente un compteur (i par exemple) et on vérifie qu’il n’est pas plus grand que le nombre d’itérations souhaité. Cela signifie que le code final devrait être deux fois plus lent que le code initial. Ce choix lisibilité / performance revient plus fréquemment qu’on ne le pense. La dernière fonction contient n + 3 boucles. Saurez-vous les identifier ?

2017-09-13

• Two New Approaches to Compressed Sensing Exhibiting Both Robust Sparse Recovery and the Grouping Effect
• On the Consistency of Ordinal Regression Methods
• Lens Depth Function and k-Relative Neighborhood Graph: Versatile Tools for Ordinal Data Analysis
• Joint Label Inference in Networks
• Dense Distributions from Sparse Samples: Improved Gibbs Sampling Parameter Estimators for LDA
• Fundamental Conditions for Low-CP-Rank Tensor Completion
• Averaged Collapsed Variational Bayes Inference
• Communication-efficient Sparse Regression
• Distributed Sequence Memory of Multidimensional Inputs in Recurrent Networks
• Automatic Differentiation Variational Inference
• A Unified Formulation and Fast Accelerated Proximal Gradient Method for Classification
• Breaking the Curse of Dimensionality with Convex Neural Networks
• Preference-based Teaching
• Online Bayesian Passive-Aggressive Learning∗
• Learning Local Dependence In Ordered Data
• Explaining the Success of AdaBoost and Random Forests as Interpolating Classifiers
• Clustering from General Pairwise Observations with Applications to Time-varying Graphs∗

2017-09-12

Le site contient plus de 300 notebooks qu’on peut retrouver compilés sous la forme d’une gallerie Galleries de notebooks et d’une page qui indique la couverture des tests unitaires : Notebooks Coverage. Excepté si les notebooks utilisent un cluster un une autre ressources difficile d’accès, ceux-ci sont exécutées une fois par semaine pour vérifier qu’ils continuent à tourner avec les dernières versions des modules dont ils dépendent. Ce faisant, le titre est maintenant précédé d’un code qui indique le public auquel il s’adresse et le contenu. Il y a trois niveaux, 1A, 2A, 3A pour chaque année du cursus à l’ENSAE. Le contenu et indiqué par un code.

2017-08-20

epkg:theano est un module difficile à installer car il utilise une compilation C++ pour optimiser les calculer que le programmeur demmande. Cela veut dire qu’il fait appel à un compilateur C++ pour convertir des instructions Python en un code qui s’exécute rapidement. Les portables ont peu souvent des processeurs GPU mais rien n’empêche de développer un programme de deep learning en CPU d’abord. C’est plus facile sous Linux (ou sous Windows Subsystem for Linux. Il suffit d’installer g++ :

sudo apt-get install g++

Sous Windows, c’est un peu plus compliqué mais à peine plus long. Il faut lire l’article de blog : Theano and Mingw.

2017-08-03

Les vidéos de la conférence sont en ligne et il y a toujours de bonnes idées à prendre : PyData Seattle 2017. Quelques modules à suivre : Scattertext, pomegranate. Un dernier module qui montre que toutes les grandes boîtes ont leur outil de machine learning. catboost est optimisé pour la construction de forêt d’arbres sur des variables catégorielles tout comme Facebook avait sorti le sien sur le texte fasttext. Enfin, un champ que je connais moins, z3, un outil de preuve systématique, qui pourrait servir un jour à traiter des données.

2017-06-24

Quand quelqu’un s’amuse à regrouper plusieurs cheat sheets au même endroit, il faut absolument garder le lien quelque part, Essential Cheat Sheets for Machine Learning and Deep Learning Engineers, et son répertoire GitHub. C’est une façon très simple d’attirer pas mal de monde au même endroit car cela nous évite pas mal d’aller retour vers un moteur de recherche.

2017-02-25

C’est un article de blog assez concis et clair qui dévoile une partie de ce que cache un langage interprété comme Python : Cost of abstractions.

2017-02-15

C’est une astuce que m’ont fait découvrir deux étudiants dans leur projet associé au cours de troisième année Eléments logiciels pour le traitement des données massives. Ils ont utilisé une propriété rendue possible par l’implémentation des random forest de scikit-learn : il est possible de construire une random forest issue de l’assemblage de deux random forest. De là à paralléliser l’apprentissage d’une random forest, il n’y a qu’un pas. L’article en question : Combining random forest models in scikit learn.

2017-01-08

Je ne l’ai pas essayé mais il a l’air intéressant pour quiconque souhaite coder des algorithmes de trading automatiques : TA-LIB et son interface Python. La plupart des indicateurs financiers y sont implémentés.