Pandas : la bibliothèque

Python dédiée à la Data

Science
Pandas est une bibliothèque du langage de programmation Python, entièrement dédiée à
la Data Science. Découvrez à quoi sert cet outil, et pourquoi il est incontournable pour les
Data Scientists.
Créé en 1991, Python est le langage de programmation le plus populaire pour l’analyse de
données et le Machine Learning. Plusieurs avantages expliquent ce succès auprès des Data
Scientists.

Il s’agit tout d’abord d’un langage très simple d’utilisation. Même un débutant peut rapidement
produire des programmes grâce à une syntaxe simple et intuitive.

Ce langage fédère une vaste communauté, ayant créé de nombreux outils pour la Data Science.
Il existe par exemple des outils pour la Data Visualisation tels que Seaborn et Matplotlib, et
des bibliothèques logicielles comme Numpy. L’une de ces bibliothèques est Pandas, conçue
pour la manipulation et l’analyse de données.

Qu'est-ce que Pandas ?

La bibliothèque logicielle open-source Pandas est spécifiquement conçue pour la
manipulation et l’analyse de données en langage Python. Elle est à la fois performante,
flexible et simple d’utilisation.

Grâce à Pandas, le langage Python permet enfin de charger, d’aligner, de manipuler ou

encore de fusionner des données. Les performances sont particulièrement impressionnantes
quand le code source back-end est écrit en C ou en Python.

Le nom « Pandas » est en fait la contraction du terme » Panel Data « , désignant les ensembles
de données incluant des observations sur de multiples périodes temporelles. Cette bibliothèque
a été créée comme un outil de haut niveau pour l’analyse en Python.

Les créateurs de Pandas comptent faire évoluer cette bibliothèque pour qu’elle devienne l’outil
d’analyse et de manipulation de données open-source le plus puissant et flexible dans
n’importe quel langage de programmation.

Outre l’analyse de données, Pandas est très utilisé pour le « Data Wrangling ». Ce terme
englobe les méthodes permettant de transformer les données non structurées afin de les rendre
exploitables.

De manière générale, Pandas excelle aussi pour traiter les données structurées sous forme de
tableaux, de matrices ou de séries temporelles. Il est également compatible avec d’autres
bibliothèques Python.
Comment fonctionne Pandas ?
Le fonctionnement de Pandas repose sur les « DataFrames » : des tableaux de données en
deux dimensions, dont chaque colonne contient les valeurs d’une variable et chaque ligne
contient un ensemble de valeurs de chaque colonne. Les données stockées dans un DataFrame
peuvent être des nombres ou des caractères.

Les Data Scientists et programmeurs initiés au langage de programmation R pour le calcul

statistique utilisent les DataFrames pour stocker les données sous forme de grilles très
simples à passer en revue. C’est la raison pour laquelle Panda est très utilisé pour le Machine
Learning.

Cet outil permet d’importer et d’exporter les données dans différents formats
comme CSV ou JSON. Par ailleurs, Pandas offre aussi des fonctionnalités de Data Cleaning.

Cette bibliothèque est très utile pour travailler avec des données statistiques, des données
tabulaires comme des tableaux SQL ou Excel, avec des données de séries temporelles, et
avec des données de matrices arbitraires avec étiquettes de lignes et de colonnes.

Quels sont les avantages de Pandas ?

Pour les Data Scientists et les développeurs, Pandas apporte plusieurs avantages. Cette
bibliothèque permet de facilement compenser les données manquantes.

Il s’agit d’un outil flexible, car les colonnes peuvent être facilement insérées ou supprimées au
sein des DataFrames. L’alignement des données avec les étiquettes peut être automatisé.

Autre atout : un puissant outil de regroupement des données permettant d’effectuer des
opérations de type « split-apply-combine » sur les ensembles de données, pour les agréger ou
les transformer.
Il est très facile de convertir des données indexées différemment dans d’autres structures
Python et Numpy sous forme d’objets DataFrame. De même, les données peuvent être
indexées ou trier grâce à un système intelligent basé sur les étiquettes.

Les ensembles de données peuvent être fusionnés intuitivement, restructurés de manière

flexible. Des outils I/O simplifient le chargement de données en provenance de fichiers
CSV, Excel, de bases de données, ou le chargement de données au format HDF5.

Les fonctionnalités dédiées aux séries temporelles complètent le tableau, avec notamment
la génération de rang de date, la conversion de fréquence, ou le déplacement de fenêtres
statistiques.

Ces nombreux points forts font de Pandas une bibliothèque incontournable pour la Data
Science en langage Python. Il s’agit d’un outil très utile pour les Data Scientists.

Comment les Data Scientists utilisent-ils Pandas ?

Certains langages de programmation sont traditionnellement utilisés dans les environnements
scientifiques ou par les équipes de recherche et développement en entreprise. Toutefois, ces
langages posent souvent des problèmes aux Data Scientists.

Or, Python permet de surmonter la plupart de ces limites. Il s’agit d’un langage idéal pour les
différentes étapes de la science des données : le nettoyage, la transformation, l’analyse, la
modélisation, la visualisation et le reporting.

Son interface est agréable, la documentation est complète, l’utilisation est relativement
intuitive. La popularité de Pandas est aussi liée à son ancienneté. Il s’agit de la première
bibliothèque de ce type à avoir vu le jour, ou du moins l’une des premières.

De plus, c’est un outil open-source et de nombreuses personnes ont contribué au projet. C’est
que qui lui a permis d’atteindre un tel succès.

Pandas, NumPy et scikit-learn : 3 bibliothèques Python pour

la Data Science
Outre Pandas, il existe d’autres bibliothèques logicielles Python dédiées à la Data Science.
NumPy est une bibliothèque mathématique permettant d’implémenter de façon très efficace
de l’algèbre linéaire et des calculs standards.

Précisons que Pandas est basé sur NumPy. De nombreuses structures de données et
fonctionnalités de Pandas proviennent de NumPy. Ces deux bibliothèques sont étroitement
liées entre elles, et souvent utilisées conjointement.

De son côté, Scikit-learn est la référence pour la plupart des applications de Machine
Learning en Python. Pour créer un modèle prédictif, on utilise généralement Pandas et NumPy
pour charger, analyser et formater les données à utiliser. Ces données sont ensuite utilisées pour
nourrir le modèle à partir de scikit-learn. Ce modèle est ensuite utilisé pour établir des
prédictions. Ainsi, Pandas, Numpy et Scikit-learn sont trois outils couramment utilisés en
Data Science.
 NumPy : la bibliothèque
Python la plus utilisée en
Data Science
NumPy est une bibliothèque Python couramment utilisée pour la Data Science. Découvrez
tout ce que vous devez connaître pour la maitrîser.
La Data Science repose sur des calculs scientifiques d’une haute complexité. Pour effectuer
ces calculs, les Data Scientists ont besoin d’outils puissants. La bibliothèque NumPy pour
Python compte parmi ces précieuses ressources.

Qu'est-ce que NumPy ?

Le terme NumPy est en fait l’abréviation de » Numerical Python « . Il s’agit d’une
bibliothèque Open Source en langage Python. On utilise cet outil pour la programmation
scientifique en Python, et notamment pour la programmation en Data Science, pour l’ingénierie,
les mathématiques ou la science.

Cette bibliothèque est très utile pour effectuer des opérations mathématiques et statistiques
en Python. Elle fonctionne à merveille pour la multiplication de matrices ou de tableaux
multidimensionnels. L’intégration avec C/C++ et Fortran est très facile.

Comment fonctionne NumPy ?

Cette plateforme comprend des objets multidimensionnels dans des » arrays « , et un
package regroupant des outils d’intégration pour l’implémentation Python. Pour faire simple,
NumPy est un mélange entre C et Python qu’on utilise en alternative à la programmation
MATLAB traditionnelle.

Les données, sous forme de nombres, sont traitées en tant qu’arrays (tableaux) pour des
fonctions multidimensionnelles et des opérations de réarrangement. Il s’agit d’un outil très
utilisé dans le domaine de la Data Science.

Parmi les nombreuses bibliothèques en Python, Numpy fait partie des plus utilisées. Pour cause,
de nombreuses techniques de Data Science requièrent des tableaux et matrices de vaste
envergure et des calculs complexes afin d’extraire de précieuses informations à partir des
données. Ce processus est simplifié par NumPy grâce à des fonctions mathématiques diverses
et variées.

Bien que basique, c’est l’une des bibliothèques Python les plus importantes pour le calcul
scientifique. En outre, d’autres bibliothèques dépendent fortement des arrays NumPy qu’elles
utilisent comme inputs et outputs (entrée et sortie de données). Ainsi, TensorFlow et Scikit
apprennent à utiliser les arrays NumPy pour calculer les multiplications de matrices.

Au-delà, NumPy offre aussi des fonctions permettant aux développeurs d’effectuer des
fonctions mathématiques et statistiques basiques ou avancées sur des arrays et des matrices
multidimensionnelles avec peu de lignes de code.
La structure de données » ndarray « ou » n-dimensional array » est la principale
fonctionnalité de NumPy. Ces tableaux ont la particularité d’être homogènes, et tous les
éléments doivent donc être du même type.

De manière générale, les arrays NumPy sont plus rapides que les listes Python. Toutefois,
sachant qu’il n’est possible de stocker que les données du même type dans chaque colonne, les
listes Python sont plus flexibles.

Pour utiliser NumPy il faut tout d’abord importer la librairie, le plus souvent celle-ci est
utilisée sous son alias « np » qui facilite son utilisation.

import numpy as np

a = np.arange(4)
a

Out[1]:
array([0, 1, 2, 3])

Ici on peut voir un exemple de tableau (arrays). Les crochets servent à délimiter les listes
d’éléments dans le tableau, comme l’on peut voir ici ou on a d’abord [0,1,2,3] qui représente
notre première dimension.

Il est aussi possible de créer son tableau en utilisant la fonction np.array() de Numpy.

l = [5,12,16]

np.array(l)
Out[10]: array([ 5, 12, 16])
A partir de notre liste L que nous avons créé nous pouvons la transformer en un array numpy.
Il ne faut pas oublier que les arrays NumPy ne peuvent prendre qu’un type de donnée à la fois,
contrairement aux listes qui elles peuvent mélanger valeurs numériques et caractères.

b = np.arange(16).reshape(4, 4)
b
Out[3]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])

Cette fois-ci notre tableau est multidimensionnel, c’est-à-dire que celui-ci sera composé de
plusieurs listes délimitées par une virgule. En utilisant l’attribut shape de notre tableau, on voit
qu’on a un tableau de 4×4. Les tableaux sont comparables à des matrices (2d), et un tableau
d’une seule dimension à un vecteur (1d). Il est possible aussi de faire des listes de matrices (3d),
ce format est notamment utilisé pour le traitement d’image, la troisième dimension étant la
couleur (RGB pour Red,Green,Blue).

M = np.random.randint(5, size=(2, 2))

print(M)
Out[5]:
[[1 1]
[1 2]]

N = np.random.randint(5, size=(2, 2))

print(N)
Out[6]:
[[4 2]
[0 3]]

M @ N
Out[7]:
array([[4, 5],
[4, 8]])

On peut utiliser l’attribut Dot des tableaux Numpy pour faire une multiplication matricielle,
cependant l’opérateur @ est la façon recommandée par numpy pour faire celle-ci malgré que
l’attribut Dot donne le même résultat.
De manière générale, les arrays NumPy sont plus rapides que les listes Python. Toutefois,
sachant qu’il n’est possible de stocker que les données du même type dans chaque colonne, les
listes Python sont plus flexibles.

from numpy import arange

from timeit import Timer

Nombre_elements = 100000
Nombre_iteration = 1000

tableau = arange(Nombre_elements)
listes_py = range(Nombre_elements)

t_numpy = Timer("tableau.sum()", "from __main__ import tableau")

t_list = Timer("sum(listes_py)", "from __main__ import listes_py")
print("numpy temps moyen en secondes: %.3e" % (t_numpy.timeit(Nombre_iteration)/Nombre_iteration,))
 print("listes temps moyen en secondes: %.3e" % (t_list.timeit(Nombre_iteration)/Nombre_iteration,))

Out[8]:
numpy temps moyen en secondes: 5.734e-05
listes temps moyen en secondes: 1.663e-03

Ici nous pouvons constater que numpy est approximativement 35 fois plus rapide en moyenne que les
listes pythons pour des opérations de sommes.

A quoi sert Numpy ?

Pour résumer NumPy, voici ses caractéristiques principales. Il s’agit d’une combinaison entre
C et Python, reposant sur des tableaux de données multidimensionnels et homogènes :
les Ndarrays (ndimensional arrays).

Comme sur MATLAB, le type de base est un tableau multidimensionnel, ce qui permet
d’accélérer la vitesse de calcul sur les matrices. Même s’il existe des différences de syntaxe, le
comportement reste similaire entre NumPy et MATLAB. A l’aide des autres librairies Python,
notamment Scikit-Learn, Numpy permet à Python d’être le langage de prédilection en Data
Science.

NumPy est l’un des packages les plus utilisés pour le calcul scientifique en Python. Il fournit
un objet de tableau multidimensionnel, et des variations telles que les masques et les matrices
pouvant être utilisés pour diverses opérations mathématiques.

Cet outil est compatible avec de nombreux autres packages Python populaires, dont pandas et
matplotlib. Sa popularité est due au fait que sa vitesse est supérieure aux tableaux Python
classiques, grâce au code C pré-compilé et optimisé.

En outre, les tableaux et opérations sont vectorisés ce qui signifie qu’il n’y a pas de looping
explicite ou d’indexing dans le code. Ainsi, le code est plus lisible et similaire à la notation
mathématique standard.

On peut utiliser NumPy pour créer une matrice identité à l’aide de la fonction NumPy Identity.
Cet outil permet de créer des tableaux de dimensions en tout genre.

Au sein d’un array NumPy, le premier axe est l’axis 0. Il est possible d’ajouter des éléments
dans les tableaux, permettant d’assembler des vecteurs et des matrices.

Une large variété de types de données est prise en charge par les tableaux NumPy, et toutes
sortes de calculs numériques peuvent être effectués.

En outre, il est possible de convertir un array NumPy en liste de strings, en liste de tuples ou en
liste de listes. À l’inverse, les listes peuvent être converties en array, en matrice, en ndarray, en
string ou en CSV.

De manière générale, NumPy permet d’effectuer facilement de nombreuses opérations

mathématiques très utilisées dans le calcul scientifique comme la multiplication vecteur-
vecteur, matrice-matrice ou matrice-vecteur.
Ce package permet aussi les opérations sur les vecteurs et matrices comme l’addition, la
soustraction, la multiplication ou la division par un nombre. On peut aussi effectuer des
comparaisons, appliquer des fonctions aux vecteurs et matrices, ou encore des opérations de
réduction et de statistiques.
 Scikit-Learn : Découvrez la
librairie Python dédié au
Machine Learning
Qu’est ce que Sckikit-Learn ?
C’est une librairie Python qui donne accès à des versions efficaces d’un grand nombre
d’algorithmes courants. Elle offre également une API propre et uniformisée. Par conséquent,
un des gros avantages de Scikit-Learn est qu’une fois que vous avez compris l’utilisation et la
syntaxe de base de Scikit-Learn pour un type de modèle, le passage à un nouveau modèle ou
algorithme est très simple. La librairie ne permet pas seulement de faire de la modélisation,
elle peut assurer également des étapes de preprocessing ce que nous verrons dans la suite de
l’article.

Les bases de Scikit-Learn

Comme l’API est uniformisée, Quel que soit le modèle que vous envisagez d’utiliser, les étapes
de modélisation sont souvent les mêmes :

• Choisir un modèle en important la classe appropriée de Scikit-Learn.

• Paramétrer le modèle. Si vous êtes déjà sûrs des paramètres que vous voulez utiliser
vous pouvez les renseigner à la main sinon la librairie offre aussi des techniques
comme GridSeachCV pour trouver les paramètres optimaux.
• Entraîner le modèle sur le jeu d’apprentissage à l’aide de la méthode fit.
• Tester le modèle sur de nouvelles données :
 o Dans le cadre d’apprentissage supervisé, nous utilisons la méthode predict sur
les données test.
o Dans le cadre d’apprentissage non supervisé, nous utilisons les
méthodes transform ou predict.
Ces 4 étapes sont en général communes à l’utilisation d’un grand nombre de modèles
disponibles dans la librairie ce qui permet, une fois que vous avez compris la logique de
construction d’un modèle, de pouvoir très facilement utiliser d’autres modèles.

Scikit-Learn : des possibilités nombreuses

5 étapes cruciales d’un projet data :

• Saisir les tenants et aboutissants

• Récupérer et explorer les données
• Préparer vos bases de travail
• Sélectionner et entraîner un modèle
• Évaluer vos résultats

Dans les 3 dernières étapes Scikit-Learn est une librairie largement utilisée qui vous fournit tous
les outils nécessaires :

• Pour préparer vos données la librairie vous offre un arsenal de méthodes que ce soit
pour :
o Séparer vos données en jeu de test et d’apprentissage à l’aide de
fonction train_test_split.
o Encoder les variables qualitatives avec des méthodes
comme OneHotEncoder.
 o Normaliser les données avant de les modéliser avec des méthodes
comme StandardScaler par exemple.
o Traiter les valeurs manquantes avec des méthodes simples d’imputation
comme SimpleImputer ou bien plus avancées comme IterativeImputer.
o Faire de la sélection de variables avec par exemple SelectKBest.
o Réduire la dimension du jeu de données à l’aide de méthodes comme l’ACP
ou TSNE.
Toutes ces méthodes vous permettent de préparer les données efficacement, étape cruciale d’un
projet et Scikit-Learn vous offre tous les outils nécessaires pour la réussir.

Apprentissage supervisé et non supervisé sur Scikit-Learn

• Pour sélectionner et entraîner un modèle, Scikit-Learn couvre deux grands types
d’apprentissage :
o L’apprentissage supervisé : de nombreux modèles comme
la régression logistique, la régression linéaire, les régressions linéaires
pénalisées comme Ridge, Lasso ou elastic net, les arbres de décisions, les
méthodes d’ensemble comme les forêts aléatoires ou bien encore les méthodes
de boosting sont disponibles et facilement utilisables pour traiter aussi bien des
problématiques de classification et de régression.
o L’apprentissage non supervisé : Là encore l’algorithme des k-moyennes,
la classification ascendante hiérarchique, DBSCAN, les mélanges gaussiens
sont autant de modèles disponibles et facilement utilisables.
Pour la plupart de ces modèles, surtout en apprentissage supervisé, nous ne connaissons pas à
l’avance les meilleurs paramètres à utiliser pour obtenir la meilleure performance possible.
Ainsi Scikit-Learn offre des outils comme GridSearchCV ou RandomizedSearchCV qui
permettent par validation croisée de déterminer les meilleurs paramètres de notre modèle. Ces
deux fonctions sont très largement utilisées par la communauté au moment de modéliser les
données.

La grande variété de modèles proposés dans une seule librairie fait de Scikit-Learn un
incontournable de l’étape de modélisation des données dans un projet data.

Pour évaluer vos résultats, Scikit-Learn se révèle encore redoutable. Ce ne sont pas moins
de 40 métriques disponibles et prêtes à l’emploi pour évaluer les résultats de vos modèles.
Certaines comme la RMSE, MAE, MSE, r2_score permettent d’évaluer et de comparer les
résultats de modèles de régression. D’autres comme confusion_matrix, accuracy_score,
classification_report permettent d’évaluer et de comparer les résultats de modèles de
classification. Enfin il en existe aussi comme la silhouette_score pour évaluer la performance
d’algorithmes de partitionnement comme la classification ascendante hiérarchique.

Il est important d’ajouter aussi que Scikit-Learn grâce à une méthode nommée pipeline permet
d’instancier les 3 dernières étapes d’un projet en très peu de lignes de code. Bien sûr, cet outil
s’utilise après avoir testé différents modèles et déterminer le meilleur pour notre problème.

Un peu de pratique
Regardons un exemple concret pour comprendre la capacité de Scikit-Learn à nous offrir des
outils statistiques pour mener à bien un projet data avec un minimum de lignes de code.
Dans cet exemple, nous allons utiliser le jeu de données boston house-prices mis à disposition
par la librairie et nous allons travailler dessus. Ce dernier ne contient pas de valeurs manquantes
et notre objectif sera de tester 3 modèles différents, de trouver pour chacun les paramètres
optimaux puis de comparer les scores obtenus pour déterminer le meilleur.

import
pandas
as pd
from sklearn.datasets import load_boston
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

#import des données

X, y = load_boston(return_X_y=True)

#Séparation des données en jeu d'apprentissage et de test

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 400)

#Scaling des données

scaler = StandardScaler().fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

from sklearn.feature_selection import SelectKBest

from sklearn.feature_selection import f_regression

#Sélection de variables
selector = SelectKBest(f_regression).fit(X_train, y_train)
X_train = selector.transform(X_train)
X_test = selector.transform(X_test)

from sklearn.linear_model import Lasso

from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import GridSearchCV

#Recherche des meilleurs paramètres pour chacun des modèles

estimators = [Lasso(),DecisionTreeRegressor(),RandomForestRegressor()]

best_params = {}
best_score = []
params = {'lasso':{'alpha':[0.01, 0.05, 0.1, 0.3, 0.8, 1]},
'decision_tree':{'max_depth':[3,5,7,10],'max_features':[3,7]},
 'randomforest':{'n_estimators':[50,100,250],'max_depth':[3,5,7,10],
'max_features':[3,7]}}

for i,j in zip(estimators,params.keys()):

grid = GridSearchCV(i, param_grid = params[j], scoring = 'r2', cv = 3)
grid.fit(X_train, y_train)
best_params[j] = grid.best_params_
best_score.append(grid.best_score_)

#Comparaison des modèles

lead_board = pd.DataFrame({'model':list(best_params.keys()),
'params':list(best_params.values()),
'score':best_score})

lead_board

Gist code exemple :

Le code peut se découper en 4 étapes :

• Import et scaling des données à l’aide de la classe StandardScaler.

• Sélection de variables en utilisant la classe SelectKBest.
• Entraînement de 3 modèles différents et recherche des meilleurs paramètres à l’aide de
la classe GridSearchCV.
• Comparaison et choix du modèle optimal.
Une dernière étape consiste à instancier toutes ses étapes en une seule ligne de code avec le
meilleur modèle en utilisant la classe pipeline et prédire et évaluer sur le jeu de test.

best_model = RandomForestRegressor(**best_params['randomforest'])

from sklearn.pipeline import Pipeline

pipe = Pipeline([('scaler', StandardScaler()),

('selector', SelectKBest(f_regression)),
('model', best_model)])

pipe.fit(X_train, y_train)

pred_train = pipe.predict(X_train)
pred_test = pipe.predict(X_test)

from sklearn.metrics import r2_score

 print("r2_score sur le jeu d'apprentissage", r2_score(y_train, pred_train))
print("r2_score sur le jeu de test", r2_score(y_test, pred_test))

La librairie Scikit-Learn aujourd’hui fournit un très grand nombre d’algorithmes avec des
champs d’application dans de nombreux secteurs comme l’industrie, l’assurance, la
compréhension des données clients…