Crear gráficos de radar con Matplotlib de Python

Introducción

En este laboratorio, aprenderá a crear un gráfico de radar utilizando la biblioteca Matplotlib de Python. Un gráfico de radar, también conocido como gráfico de araña o gráfico de estrella, es un método gráfico para mostrar datos multivariados en forma de un gráfico bidimensional de tres o más variables cuantitativas representadas en ejes que parten del mismo punto. A menudo se utiliza para comparar diferentes productos o soluciones en base a varios factores.

Consejos sobre la VM

Una vez que se haya iniciado la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Importar bibliotecas

Primero, necesitamos importar las bibliotecas necesarias. Para este tutorial se requieren Matplotlib y numpy.

import matplotlib.pyplot as plt
import numpy as np

Definir la función del gráfico de radar

A continuación, definiremos una función para crear un gráfico de radar. Esta función tomará dos argumentos: num_vars y frame. num_vars es el número de variables para el gráfico de radar, y frame especifica la forma del marco que rodea los ejes.

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'):
    ## código de la función va aquí

Definir las clases RadarTransform y RadarAxes

Dentro de la función radar_factory, definiremos las clases RadarTransform y RadarAxes. Estas clases se utilizarán para crear el gráfico de radar.

class RadarTransform(PolarAxes.PolarTransform):
    ## código de la clase RadarTransform va aquí

class RadarAxes(PolarAxes):
    ## código de la clase RadarAxes va aquí

Definir los métodos fill y plot

Dentro de la clase RadarAxes, definiremos los métodos fill y plot. Estos métodos se utilizarán para llenar el área dentro del gráfico y trazar los puntos de datos, respectivamente.

class RadarAxes(PolarAxes):
    ## código de la clase RadarAxes va aquí

    def fill(self, *args, closed=True, **kwargs):
        ## sobrescribir el método fill
        return super().fill(closed=closed, *args, **kwargs)

    def plot(self, *args, **kwargs):
        ## sobrescribir el método plot
        lines = super().plot(*args, **kwargs)
        for line in lines:
            self._close_line(line)

    def _close_line(self, line):
        ## método auxiliar para cerrar la línea
        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)

Definir los métodos set_varlabels, _gen_axes_patch y _gen_axes_spines

Dentro de la clase RadarAxes, también definiremos los métodos set_varlabels, _gen_axes_patch y _gen_axes_spines. Estos métodos establecerán las etiquetas de las variables, generarán el recuadro de los ejes y generarán las espinas de los ejes, respectivamente.

class RadarAxes(PolarAxes):
    ## código de la clase RadarAxes va aquí

    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("Valor desconocido para '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("Valor desconocido para 'frame': %s" % frame)

Definir los datos de ejemplo

Ahora, definiremos los datos de ejemplo que usaremos para crear el gráfico de radar. Estos datos se toman de un estudio sobre estimaciones del perfil de fuentes de contaminación.

def example_data():
    data = [
        ['Sulfato', 'Nitrato', '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]]),
        ('Con 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]]),
        ('Con 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

Establecer el número de variables y calcular los ángulos de los ejes

Ahora estableceremos el número de variables y calcularemos los ángulos de los ejes equidistantes utilizando numpy.

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

Crear el gráfico de radar

Finalmente, podemos crear el gráfico de radar utilizando los datos de ejemplo y la clase 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()

Resumen

En este laboratorio, aprendiste cómo crear un gráfico de radar utilizando la biblioteca Matplotlib de Python. Un gráfico de radar es un método gráfico para mostrar datos multivariados en forma de un gráfico bidimensional de tres o más variables cuantitativas representadas en ejes que parten del mismo punto. A menudo se utiliza para comparar diferentes productos o soluciones en base a varios factores.