Création de graphiques radar | Tutoriel Matplotlib pour Python

Introduction

Dans ce laboratoire, vous allez apprendre à créer un graphique radar à l'aide de la bibliothèque Matplotlib de Python. Un graphique radar, également connu sous le nom de graphique araignée ou graphique étoile, est une méthode graphique de présentation de données multivariées sous forme d'un graphique bidimensionnel de trois variables quantitatives ou plus représentées sur des axes partant du même point. Il est souvent utilisé pour comparer différents produits ou solutions sur plusieurs facteurs.

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 limitations du carnet Jupyter Notebook.

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

Importation des bibliothèques

Tout d'abord, nous devons importer les bibliothèques nécessaires. Matplotlib et numpy sont requises pour ce tutoriel.

import matplotlib.pyplot as plt
import numpy as np

Définir la fonction de graphique radar

Ensuite, nous allons définir une fonction pour créer un graphique radar. Cette fonction prendra deux arguments : num_vars et frame. num_vars est le nombre de variables pour le graphique radar, et frame spécifie la forme du cadre entourant les axes.

from matplotlib.patches import Circle, RegularPolygon
from matplotlib.path import Path
from matplotlib.projections import register_projection
from matplotlib.projections.polar import PolarAxes
from matplotlib.spines import Spine
from matplotlib.transforms import Affine2D

def radar_factory(num_vars, frame='circle'):
    ## code for the function goes here

Définir les classes RadarTransform et RadarAxes

Dans la fonction radar_factory, nous allons définir les classes RadarTransform et RadarAxes. Ces classes seront utilisées pour créer le graphique radar.

class RadarTransform(PolarAxes.PolarTransform):
    ## code for the RadarTransform class goes here

class RadarAxes(PolarAxes):
    ## code for the RadarAxes class goes here

Définir les méthodes `fill` et `plot`

Dans la classe RadarAxes, nous allons définir les méthodes fill et plot. Ces méthodes seront utilisées respectivement pour remplir la zone à l'intérieur du graphique et tracer les points de données.

class RadarAxes(PolarAxes):
    ## code for the RadarAxes class goes here

    def fill(self, *args, closed=True, **kwargs):
        ## override the fill method
        return super().fill(closed=closed, *args, **kwargs)

    def plot(self, *args, **kwargs):
        ## override the plot method
        lines = super().plot(*args, **kwargs)
        for line in lines:
            self._close_line(line)

    def _close_line(self, line):
        ## helper method to close the line
        x, y = line.get_data()
        if x[0]!= x[-1]:
            x = np.append(x, x[0])
            y = np.append(y, y[0])
            line.set_data(x, y)

Définir les méthodes `set_varlabels`, `_gen_axes_patch` et `_gen_axes_spines`

Dans la classe RadarAxes, nous allons également définir les méthodes set_varlabels, _gen_axes_patch et _gen_axes_spines. Ces méthodes définiront respectivement les étiquettes des variables, généreront le patch des axes et généreront les épines des axes.

class RadarAxes(PolarAxes):
    ## code for the RadarAxes class goes here

    def set_varlabels(self, labels):
        self.set_thetagrids(np.degrees(theta), labels)

    def _gen_axes_patch(self):
        if frame == 'circle':
            return Circle((0.5, 0.5), 0.5)
        elif frame == 'polygon':
            return RegularPolygon((0.5, 0.5), num_vars,
                                  radius=.5, edgecolor="k")
        else:
            raise ValueError("Unknown value for 'frame': %s" % frame)

    def _gen_axes_spines(self):
        if frame == 'circle':
            return super()._gen_axes_spines()
        elif frame == 'polygon':
            spine = Spine(axes=self,
                          spine_type='circle',
                          path=Path.unit_regular_polygon(num_vars))
            spine.set_transform(Affine2D().scale(.5).translate(.5,.5)
                                + self.transAxes)
            return {'polar': spine}
        else:
            raise ValueError("Unknown value for 'frame': %s" % frame)

Définir les données d'exemple

Maintenant, nous allons définir les données d'exemple que nous utiliserons pour créer le graphique radar. Ces données sont issues d'une étude sur les estimations du profil des sources de pollution.

def example_data():
    data = [
        ['Sulfate', 'Nitrate', 'EC', 'OC1', 'OC2', 'OC3', 'OP', 'CO', 'O3'],
        ('Basecase', [
            [0.88, 0.01, 0.03, 0.03, 0.00, 0.06, 0.01, 0.00, 0.00],
            [0.07, 0.95, 0.04, 0.05, 0.00, 0.02, 0.01, 0.00, 0.00],
            [0.01, 0.02, 0.85, 0.19, 0.05, 0.10, 0.00, 0.00, 0.00],
            [0.02, 0.01, 0.07, 0.01, 0.21, 0.12, 0.98, 0.00, 0.00],
            [0.01, 0.01, 0.02, 0.71, 0.74, 0.70, 0.00, 0.00, 0.00]]),
        ('Avec CO', [
            [0.88, 0.02, 0.02, 0.02, 0.00, 0.05, 0.00, 0.05, 0.00],
            [0.08, 0.94, 0.04, 0.02, 0.00, 0.01, 0.12, 0.04, 0.00],
            [0.01, 0.01, 0.79, 0.10, 0.00, 0.05, 0.00, 0.31, 0.00],
            [0.00, 0.02, 0.03, 0.38, 0.31, 0.31, 0.00, 0.59, 0.00],
            [0.02, 0.02, 0.11, 0.47, 0.69, 0.58, 0.88, 0.00, 0.00]]),
        ('Avec O3', [
            [0.89, 0.01, 0.07, 0.00, 0.00, 0.05, 0.00, 0.00, 0.03],
            [0.07, 0.95, 0.05, 0.04, 0.00, 0.02, 0.12, 0.00, 0.00],
            [0.01, 0.02, 0.86, 0.27, 0.16, 0.19, 0.00, 0.00, 0.00],
            [0.01, 0.03, 0.00, 0.32, 0.29, 0.27, 0.00, 0.00, 0.95],
            [0.02, 0.00, 0.03, 0.37, 0.56, 0.47, 0.87, 0.00, 0.00]]),
        ('CO & O3', [
            [0.87, 0.01, 0.08, 0.00, 0.00, 0.04, 0.00, 0.00, 0.01],
            [0.09, 0.95, 0.02, 0.03, 0.00, 0.01, 0.13, 0.06, 0.00],
            [0.01, 0.02, 0.71, 0.24, 0.13, 0.16, 0.00, 0.50, 0.00],
            [0.01, 0.03, 0.00, 0.28, 0.24, 0.23, 0.00, 0.44, 0.88],
            [0.02, 0.00, 0.18, 0.45, 0.64, 0.55, 0.86, 0.00, 0.16]])
    ]
    return data

Définir le nombre de variables et calculer les angles des axes

Nous allons maintenant définir le nombre de variables et calculer les angles des axes régulièrement espacés en utilisant numpy.

N = 9
theta = radar_factory(N, frame='polygon')

Créer le graphique radar

Enfin, nous pouvons créer le graphique radar en utilisant les données d'exemple et la classe RadarAxes.

data = example_data()
spoke_labels = data.pop(0)

fig, axs = plt.subplots(figsize=(9, 9), nrows=2, ncols=2,
                        subplot_kw=dict(projection='radar'))
fig.subplots_adjust(wspace=0.25, hspace=0.20, top=0.85, bottom=0.05)

colors = ['b', 'r', 'g','m', 'y']
for ax, (title, case_data) in zip(axs.flat, data):
    ax.set_rgrids([0.2, 0.4, 0.6, 0.8])
    ax.set_title(title, weight='bold', size='medium', position=(0.5, 1.1),
                 horizontalalignment='center', verticalalignment='center')
    for d, color in zip(case_data, colors):
        ax.plot(theta, d, color=color)
        ax.fill(theta, d, facecolor=color, alpha=0.25, label='_nolegend_')
    ax.set_varlabels(spoke_labels)

labels = ('Factor 1', 'Factor 2', 'Factor 3', 'Factor 4', 'Factor 5')
legend = axs[0, 0].legend(labels, loc=(0.9,.95),
                          labelspacing=0.1, fontsize='small')

fig.text(0.5, 0.965, '5-Factor Solution Profiles Across Four Scenarios',
         horizontalalignment='center', color='black', weight='bold',
         size='large')

plt.show()

Sommaire

Dans ce laboratoire, vous avez appris à créer un graphique radar à l'aide de la bibliothèque Matplotlib de Python. Un graphique radar est une méthode graphique pour afficher des données multivariées sous forme d'un graphique bidimensionnel de trois variables quantitatives ou plus, représentées sur des axes partant du même point. Il est souvent utilisé pour comparer différents produits ou solutions en fonction de plusieurs facteurs.