Techniques de transformation d'axe avec Matplotlib

Introduction

Matplotlib est une bibliothèque Python utilisée pour la visualisation de données. Elle permet aux utilisateurs de créer une grande variété de graphiques, de tracés et de diagrammes. L'une des principales fonctionnalités de Matplotlib est sa capacité à appliquer des transformations d'échelle aux axes. Cela permet une plus grande flexibilité dans la présentation des données, en particulier lorsqu'il s'agit de très grands ou de très petits nombres. Dans ce laboratoire, nous allons apprendre à appliquer diverses transformations d'échelle aux axes à l'aide de Matplotlib.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet de notes pour accéder au carnet Jupyter Notebook pour pratiquer.

Parfois, vous devrez peut-être attendre quelques secondes pour que le carnet Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limites du carnet Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez des commentaires après la session, et nous résoudrons rapidement le problème pour vous.

Importation des bibliothèques et génération de données

Tout d'abord, nous devons importer les bibliothèques nécessaires et générer des données pour tracer. Dans cet exemple, nous utiliserons une distribution normale pour générer les données de l'axe y.

import matplotlib.pyplot as plt
import numpy as np

## Fixing random state for reproducibility
np.random.seed(19680801)

## make up some data in the interval ]0, 1[
y = np.random.normal(loc=0.5, scale=0.4, size=1000)
y = y[(y > 0) & (y < 1)]
y.sort()
x = np.arange(len(y))

Créer un tracé à échelle linéaire

Le premier type de transformation d'échelle que nous allons explorer est la linéaire. C'est l'échelle par défaut utilisée dans Matplotlib. Pour créer un tracé à échelle linéaire, nous utilisons la méthode set_yscale() et nous passons la chaîne de caractères 'linéaire'. Nous ajoutons également un titre et une grille au tracé.

## linéaire
plt.plot(x, y)
plt.yscale('linéaire')
plt.title('Échelle linéaire')
plt.grid(True)

Créer un tracé à échelle logarithmique

Le prochain type de transformation d'échelle que nous allons explorer est la logarithmique. Pour créer un tracé à échelle logarithmique, nous utilisons la méthode set_yscale() et nous passons la chaîne de caractères 'log'. Nous ajoutons également un titre et une grille au tracé.

## log
plt.plot(x, y)
plt.yscale('log')
plt.title('Échelle logarithmique')
plt.grid(True)

Créer un tracé à échelle logarithmique symétrique

Le troisième type de transformation d'échelle que nous allons explorer est la logarithmique symétrique. Ce type d'échelle est utile lorsqu'il s'agit de traiter des données qui contiennent à la fois des valeurs positives et négatives. Pour créer un tracé à échelle logarithmique symétrique, nous utilisons la méthode set_yscale() et nous passons la chaîne de caractères 'symlog'. Nous définissons également le paramètre linthresh sur 0,02 pour spécifier la plage de valeurs autour de zéro qui seront mises à l'échelle linéairement. Nous ajoutons également un titre et une grille au tracé.

## symlogarithmique symétrique
plt.plot(x, y - y.mean())
plt.yscale('symlog', linthresh=0.02)
plt.title('Échelle logarithmique symétrique')
plt.grid(True)

Créer un tracé à échelle logit

Le quatrième type de transformation d'échelle que nous allons explorer est la logit. Ce type d'échelle est utile lorsqu'il s'agit de traiter des données bornées entre 0 et 1. Pour créer un tracé à échelle logit, nous utilisons la méthode set_yscale() et nous passons la chaîne de caractères 'logit'. Nous ajoutons également un titre et une grille au tracé.

## logit
plt.plot(x, y)
plt.yscale('logit')
plt.title('Échelle logit')
plt.grid(True)

Créer un tracé à échelle personnalisée

Le dernier type de transformation d'échelle que nous allons explorer est la personnalisée. Cela nous permet de définir nos propres fonctions pour la transformation d'échelle, à la fois pour la fonction directe et la fonction inverse. Dans cet exemple, nous allons définir une fonction personnalisée pour prendre la racine carrée des données. Pour créer un tracé à échelle personnalisée, nous utilisons la méthode set_yscale() et nous passons la chaîne de caractères 'function'. Nous définissons également les fonctions forward() et inverse() et nous les passons en tant qu'arguments au paramètre functions. Nous ajoutons également un titre et une grille au tracé.

## Fonction x**(1/2)
def forward(x):
    return x**(1/2)

def inverse(x):
    return x**2

plt.plot(x, y)
plt.yscale('function', functions=(forward, inverse))
plt.title('Échelle personnalisée')
plt.grid(True)

Créer un tracé à l'échelle de la transformation de Mercator

En prime, nous allons également créer un tracé en utilisant la fonction de transformation de Mercator. Ce n'est pas une fonction intégrée dans Matplotlib, mais nous pouvons définir nos propres fonctions pour la fonction directe et la fonction inverse pour créer un tracé à l'échelle de la transformation de Mercator. Dans cet exemple, nous allons définir les fonctions forward() et inverse() pour la transformation de Mercator. Nous ajoutons également un titre et une grille au tracé.

## Fonction de transformation de Mercator
def forward(a):
    a = np.deg2rad(a)
    return np.rad2deg(np.log(np.abs(np.tan(a) + 1.0 / np.cos(a))))

def inverse(a):
    a = np.deg2rad(a)
    return np.rad2deg(np.arctan(np.sinh(a)))

t = np.arange(0, 170.0, 0.1)
s = t / 2.

plt.plot(t, s, '-', lw=2)
plt.yscale('function', functions=(forward, inverse))
plt.title('Échelle de la transformation de Mercator')
plt.grid(True)
plt.xlim([0, 180])

Sommaire

Dans ce laboratoire, nous avons appris à appliquer diverses transformations d'échelle aux axes en utilisant Matplotlib. Nous avons exploré les transformations d'échelle linéaire, logarithmique, logarithmique symétrique, logit, personnalisée et de la transformation de Mercator. En appliquant ces transformations d'échelle, nous pouvons mieux visualiser les données qui contiennent des nombres très grands ou très petits, ainsi que les données qui contiennent à la fois des valeurs positives et négatives.