Matplotlib c'est quoi ?

Matplotlib est la bibliothèque Python la plus populaire pour la visualisation et l'exploration de données ! Elle offre à la fois un moyen très rapide de visualiser des données et des figures de qualité pour les publications dans de nombreux formats.

Matplotlib

Ce billet ne présentera pas en détail les fonctionnalités de "base" pour lesquelles vous trouverez facilement des exemples, mais plutôt un ensemble de codes et de fonctions préconçus à personnaliser selon vos besoins 😊. Néanmoins, pour un rapide aperçu, Matplotlib offre les types de graphiques suivants :

Bar Graph Pie Chart Box Plot Histogram
Line Chart and Subplots Scatter Plot Polar plots Arrow
Filled curves Tables Ellipses Streamplot
Three-dimensional plotting Paths Contouring and pseudocolor Images

Utilisation & style

pip3 install matplotlib
import matplotlib.pyplot as plt
# changement de thème
plt.style.use('seaborn')

Il existe différentes feuilles de style que vous pouvez retrouver dans la documentation style sheets reference, mais vous pouvez tout aussi bien créer votre propre style. Personnellement, j'utilise seaborn comme montré dans le code ci-dessus. Et voici quelques exemples de graphiques utilisant ce style :

Style Sheets

Extension seaborn

Une des extensions les plus importantes de Matplotlib est seaborn, qui ajoute une variété importante de représentations visuelles des données et permet un interfaçage direct avec pandas.

pip3 install seaborn

Par exemple, Seaborn offre ces fonctionnalités :

  • Une API pour examiner les relations entre plusieurs variables
  • Utilisation de variables catégorielles pour montrer des observations ou des statistiques agrégées
  • Options pour visualiser les distributions univariées ou bivariées et pour comparer des sous-ensembles de données
  • Estimation automatique et tracé de modèles de régression linéaire pour différents types de variables dépendantes
  • Des vues pratiques sur la structure globale des ensembles de données complexes
  • Des abstractions de haut niveau pour structurer des grilles qui permettent de construire facilement des visualisations complexes
  • Contrôle concis du style des figurines de Matplotlib avec plusieurs thèmes intégrés
  • Des outils pour choisir des palettes de couleurs qui révèlent fidèlement les motifs de vos données

Seaborn vise à faire de la visualisation un élément central de l'exploration et de la compréhension des données. Ses fonctions de traçage orientées vers les ensembles de données fonctionnent sur des cadres et des tableaux de données contenant des ensembles de données entiers et effectuent en interne la cartographie sémantique et l'agrégation statistique nécessaires pour produire des tracés informatifs.

import seaborn as sns
# enregistrement vers matplotlib
sns.set()

Un guide complet de seaborn se trouve sur le site officiel. Ainsi, cette section ne sera pas exhaustive, mais présentera succinctement la bibliothèque Python et son utilisation basique qui reste très similaire à Matplotlib. Pour la suite, à vous de trouver !

Seaborn

Tout comme Matplotlib, seaborn propose différentes palettes de couleur et changements de style pour vos graphiques ...

Autres bibliothèques de visualisation de données

Outre Matplotlib et Seaborn, il existe plusieurs autres bibliothèques de visualisation de données disponibles en Python, chacune ayant ses propres caractéristiques et capacités. Voici quelques-unes de ces bibliothèques :

  • Plotly : Visualisations interactives et basées sur le web.
  • Bokeh : Création de graphiques interactifs web, avec un accent particulier sur le contrôle de l'aspect et de la convivialité.
  • ggplot : Grammaire graphique, qui fournit une approche déclarative pour créer des visualisations.
  • Altair : Visualisation déclarative de données, en spécifiant les données, les transformations et les encodages visuels.
  • Dash :: Un cadre d'application web pour la construction d'applications web analytiques, qui peut être utilisé pour créer des visualisations interactives.

Il en existe évidemment d'autres et parfois des bibliothèques permettent des méthodes de visualisation en plus de leurs outils d'analyse :

  • NetworkX : Création, manipulation et visualisation de graphes
  • Folium : Permet la visualisation de cartes raster et vectorielles
  • Geopandas : Analyse spatiale et visualisation
  • ArviZ : Visualisation des distributions, diagnostics et vérification des modèles bayésiens
  • TensorBoard : Suivi et visualisation des mesures (web)
  • Wandb : Suivi et visualisation des mesures (web)
  • Datashader : Visualisation optimisée (cuda)
  • HoloViews : Analyse et la visualisation des données

Exemple de scatter plot

Scatter Plot

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from matplotlib.patches import Ellipse
import matplotlib.transforms as transforms

def draw_ellipse(x, y, sx, sy, rot, facecolor='none', **kwargs):
    ellipse = Ellipse((x, y),
        width=sx, height=sy,
        angle=rot, facecolor=facecolor,
        **kwargs)
    return ax.add_patch(ellipse)

standar = pd.read_csv('all_fixed.csv')
dices = pd.read_csv('all_cnn_model-dice.csv')
mIoUs = pd.read_csv('all_cnn_model-mean_iou.csv')

Dices = np.array(dices)
MIoUs = np.array(mIoUs)
Standar = np.array(standar)

Merged = np.hstack([MIoUs, Dices[:,1:]])

fig, ax = plt.subplots()

for i,t in enumerate(['baseline', 'ibf', 'sprb', 'ibf-sprb']):
    ax.scatter(Merged[:-2,i+1], Merged[:-2,i+5], label=t, s=5)

ax.scatter(Standar[:-2,1], Standar[:-2,2], label='standar', s=5, c='black', marker="^")

draw_ellipse(74.0, 84.0, 2, 8, -52, edgecolor='orange')
draw_ellipse(79.6, 88.1, 2, 6, -55, edgecolor='green')

ax.annotate("", xy=(82, 88), xytext=(78, 85), arrowprops=dict(arrowstyle="->"))
ax.annotate("kernel size", xy=(82, 88), xytext=(79, 85), rotation=25)

ax.annotate('no_initial_image_transform and baseline models',
            xy=(72.58, 81.77), xycoords='data',
            xytext=(70.00, 78.00),
            bbox=dict(boxstyle="round", fc="0.8"),
            arrowprops=dict(arrowstyle="->",
            connectionstyle="angle,angleA=0,angleB=90,rad=10"))

ax.annotate('initial_image_transform',
            xy=(78.52, 88.45), xycoords='data',
            xytext=(72.00, 88.45),
            bbox=dict(boxstyle="round", fc="0.8"),
            arrowprops=dict(arrowstyle="->"))

plt.xlabel('mIoU score')
plt.ylabel('dices score')
plt.legend()
plt.tight_layout()
plt.show()

Rendu de déformation géométrique

Correction Radiale

Correction radiale

Correction Tangentielle

Correction tangentielle

Correction Prismatique

Correction prismatique

Correction Complète

Correction complète

#!/usr/bin/python3
import numpy as np
import pickle as pkl
from matplotlib.pyplot import *
import seaborn as sns

sns.set_style("white")

size = (1280//2, 960//2, 50)

[x, y] = np.meshgrid(
    np.arange(-size[0],size[0],size[2]),
    np.arange(-size[1],size[1],size[2]),
)

def plotCorrection(dx, dy, f, name):
    figure(figsize=(7,4))
    scale = np.sqrt(dx**2+dy**2)*133
    title(name.split('-')[-1])
    quiver(
        x+size[0], y+size[1],
        dx, dy, scale,
        angles='xy',
        scale_units='inches',
        width=0.002,
        minshaft=0.5
    );
    tight_layout()

    import tikzplotlib
    tikzplotlib.save('lens/'+name+'.tex')

    savefig('lens/'+name+'.jpg')

def radialDistortion(k1, k2, k3):
    r2 = x**2 + y**2;
    k = k1*r2 + k2*r2**2 + k3*r2**3;
    dx = x*k
    dy = y*k
    return dx, dy

def tangentialDistortion (p1, p2):
    r2 = x**2 + y**2;
    dx = 2*p1*x*y + (r2 + 2*x**2)*p2
    dy = 2*p2*x*y + (r2 + 2*y**2)*p1
    return dx, dy

def prismDistortion (s1, s2, s3, s4):
    r2 = x**2 + y**2;
    dx = s1*r2 + s2*r2**2
    dy = s3*r2 + s4*r2**2
    return dx, dy

def lensCorrection(k1, k2, k3, p1, p2, s1, s2, s3, s4):
    r2 = x**2 + y**2;
    k = k1*r2 + k2*r2**2 + k3*r2**3;
    dx = x*k + 2*p1*x*y + p2*(r2 + 2*x**2) + s1*r2 + s2*r2**2
    dy = y*k + 2*p2*x*y + p1*(r2 + 2*y**2) + s3*r2 + s4*r2**2
    return dx, dy

X = pkl.load(open('config.pkl', 'rb'))
k1,k2,k3,p1,p2,k4,k5,k6,s1,s2,s3,s4 = X['len_dist_450'][0]

print('radial', k1, k2, k3)
print('prism', s1, s2, s3, s4)
print('tangential', p1, p2)
print('optional', k4,k5,k6)

rdx, rdy = radialDistortion(k1,k2,k3)
pdx, pdy = prismDistortion(s1,s2,s3,s4)
tdx, tdy = tangentialDistortion(p1,p2)
dx, dy = lensCorrection(k1,k2,k3,p1,p2,s1,s2,s3,s4)
scale = 5

plotCorrection(rdx, rdy, scale, 'lens-correction-radial')
plotCorrection(tdx, tdy, scale, 'lens-correction-tangential')
plotCorrection(pdx, pdy, scale, 'lens-correction-prismatic')
plotCorrection( dx, dy, scale, 'lens-correction-complet')