Article Index

Matplotlib c'est quoi ?

Matplotllib c'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.

Ce billet ne presenteras pas en detail les fonctionnaliter de "base" pour le quel vous trouverez facilement des exemples, mais plutot un ensemble de code et fonction pre-conssue a customiser selon vos besoin 🙂 Neanmoins pour un rapide appercus, 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 & syle

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

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


Extension seaborn

Une des extension les plus importante de matplotlib est seaborn, qui rajoute une variété importante de représentation visuel des données et permet un interfaçage direct avec pandas.

pip3 install seaborn

Par exemple Seaborn offre ces fonctionalitées :

  • 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 les 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 ce trouve sur le site officiel ainsi cette section ne seras pas exhaustive, mais présenteras succinctement la bibliothèque python et sont utilisation basique qui reste de plus très similaire à matplotlib. Pour la suite à vous de trouver !

Tout comme matplotlib, seaborn propose différentes palette de couleur et changement 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 existent évident d'autres et parfois des bibliothèques permettent des méthodes de visualization en plus de leurs outils d'analyses :

  • NetworkX Création, manupulation et visualisation de graph
  • Folium Permet la visualisation de carte raster et vectorielle
  • Geopandas Analyse spatiale et visualisation
  • ArviZ Visualisation des distributions, diagnostics et vérification des modèles bayésien
  • TensorBoard Suivi et visualisation des mesures (web)
  • Wandb Suivi et visualisation des mesures (web)
  • Datashader Visualisation optimisé (cuda)
  • HoloViews Analyse et la visualisation des données

Exmple de 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)
    #for j in range(Merged.shape[0]):
     #   ax.annotate(Merged[j,0], (Merged[j,i+1], Merged[j,i+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.0), 
            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()

 Rendue de déformation géométrique

  • preview

    correction radial

  • preview

    correction tangential

  • preview

    correction prismatique

  • preview

    correction complete

 

#!/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])
    #title('scale = ' + str(scale))
    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
    

#k1,k2,k3,p1,p2,k4,k5,k6,s1,s2,s3,s4 = np.load('lens.npy')[0]
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)
#dx, dy = rdx+tdx+pdx, rdy+tdy+tdx
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')