Tabla de Contenidos

Instalación e importación
Introducción
Organizar Axes
Figura
Dibujando en 2D
Dibujando en 3D
Dibujando en 4D
Dibujando en 5D
Histogramas
Dibujando imágenes
Personalización
Ejercicios
Mini-proyecto

¡Esta es una revisión vieja del documento!

4. Gráficos

En este tema vamos a ver como crear gráficos en Python.

Para hacer gráficas hay varias librerías:

Matplotlib: Es la librería mas antigua pero la mas utilizada.
Seaborn: Es una capa por encima de Matplotlib y hace que sea mas sencillo hacer gráficas
Yellowbrick: También es una capa encima de Matplotlib pero es una librería especializa en gráficas para Machine Learning
Plotnine: Esta librería sigue una filosofía totalmente distinta a las anteriores. La forma de especificar una gráfica se basa en los descrito en el libro The Grammar of Graphics que es una forma mas moderna que la usada por Matplotlib. Esta forma de especificar una gráfica se usa principalmente en el lenguaje R con su librería ggplot2. Por lo que Plotnine imita a ggplot2

Mas información:

Antes de empezar mira estas 2 gráficas (Shelly y Tuya) y dime si se parecen:

Obviamente no se parecen

Y ahora mira esta otra gráfica y dime si ahora se parecen (Shelly y Tuya):

En esta se parecen más.

Realmente la primera gráfica es el final de la segunda gráfica pero ambas gráficas están en una escala distinta.

El ejemplo está puesto para que se vea como se interpreta de una forma u otra una gráfica según la escala a la que esté. La primera gráfica está en la escala [ 650 W - 1050 W ] mientras que la segunda gráfica su escala es [0 W - 2500 W]

Por lo tanto, intenta que siempre las gráficas empiecen los ejes en 0.

Otro ejemplo lo tenemos en el siguiente video de Yotube: No te dejes engañar por un gráfico

Instalación e importación

Instalación

Instalación con conda

conda install matplotlib

Matplotlib ya viene instalado por defecto en Anaconda y Google Colab.

Importación

Importar matplotlib

  import matplotlib.pyplot as plt

Introducción

La base de los gráficos en Python es Matplotlib. Con esta librería hay una serie de conceptos que debemos conocer. Los nombres de los conceptos los vamos a decir en inglés para que se parezcan mas a los métodos, clases o argumentos de las librerías.

figure: Es como el "lugar" donde se van a colocar cada una de las gráficas. Siempre va a haber una figure. Un problema con figure es que en muchos ejemplos no se crea específicamente.
axes: Es como cada una de las gráficas que vamos a crea dentro de una figure.
axis: Son cada uno de los ejes de una gráfica.

No confundir axes con axis.

Crear la primera figura con su gráfica

import matplotlib.pyplot as plt

figure=plt.figure()
axes = figure.add_subplot()

Hemos creado una figura con figure=plt.figure(). Le hemos añadido un axes que es como la gráfica mediante axes = figure.add_subplot() y vemos que esa gráfica tiene por defecto unos axis o ejes en X e Y que van de 0 a 1.

¿Porqué se llama el método add_subplot si realmente retorna un objeto Axes. Porque realmente el objeto que retorna es del tipo AxesSubplot. Lo podemos ver con el sigiente código:

print(type(axes))

<class 'matplotlib.axes._subplots.AxesSubplot'>

Organizar Axes

Veamos ahora como podemos organizar varias axes o gráficas en la misma figura.

El método add_subplot permite que le pasemos tres parámetros numéricos que indica el número de filas ,de columnas y la posición del gráfico.

Crea una rejilla de 2 filas , 2 columnas y añadir 3 gráficos en la posición ,en la posición 2 y en la posición 4 (la posición 3 se deja vacía)

import matplotlib.pyplot as plt

figure=plt.figure()
axes = figure.add_subplot(2,2,1)
axes = figure.add_subplot(2,2,2)
axes = figure.add_subplot(2,2,4)

Crea una rejilla de 2 filas , 1 columna y añadir 2 gráficos en la posición 1 y la posición 2.

import matplotlib.pyplot as plt

figure=plt.figure()
axes1 = figure.add_subplot(2,1,1)
axes2 = figure.add_subplot(2,1,2)

Crea una rejilla de 1 fila , 2 columnas y añadir 2 gráficos en la posición 1 y la posición 2.

import matplotlib.pyplot as plt

figure=plt.figure()
axes1 = figure.add_subplot(1,2,1)
axes2 = figure.add_subplot(1,2,2)

Mezclar 2 organizaciones para figuras que no sean iguales.

import matplotlib.pyplot as plt

figure=plt.figure()
axes = figure.add_subplot(2,2,1)
axes = figure.add_subplot(2,2,3)
axes = figure.add_subplot(1,2,2)

Mezclar 2 organizaciones para figuras que no sean iguales.

import matplotlib.pyplot as plt

figure=plt.figure()
axes1 = figure.add_subplot(2,2,1)
axes2 = figure.add_subplot(2,2,2)
axes3 = figure.add_subplot(2,1,2)

Mezclar 2 organizaciones para figuras que no sean iguales.

import matplotlib.pyplot as plt

figure=plt.figure()
axes1 = figure.add_subplot(3,2,1)
axes2 = figure.add_subplot(3,2,3)
axes3 = figure.add_subplot(3,2,5)
axes4 = figure.add_subplot(2,2,2)
axes5 = figure.add_subplot(2,2,4)

Mas información:

Customizing Multiple Subplots in Matplotlib

Figura

Acabamos de ver como colocar cada gráfica dentro de la figura. Ahora veremos unas cosas mas sobre ella.

* Para hacer la figura mas grande solo hay que indicar el tamaño con el argumento figsize

figure=plt.figure(figsize=(15, 5))

El tamaño es el ancho y el alto en pulgadas.

* Para indicar el título , el color y el tamaño de letra se usa el método suptitle

figure.suptitle("Título de Figure", fontsize=14, color='red')

* Por último podemos grabar la figura entera con savefig

figure.savefig("nombre_fichero.png",facecolor="#FFFFFF",bbox_inches='tight')

El argumento bbox_inches='tight' se usa para que no deje espacio alrededor de la imagen al guardarla.

Subfiguras

Además de figure y axes, a partir de matplolib 3.4 existe las subfigure. Éstas se pueden usar para poder poner un título común a varios axes.

Para ello se usa el método subfigures , indicando el número de filas y columnas. Este método retornará un array con todas las subfiguras. Cada subfigura será como una nueva figura.

subfigure_a,subfigure_b = figure.subfigures(nrows=2, ncols=1)

Veamos un ejemplo:

import matplotlib.pyplot as plt

figure=plt.figure(figsize=(8, 6),layout='constrained')
figure.suptitle("Título de la figura")

subfigures = figure.subfigures(nrows=2, ncols=1).reshape(-1)
subfigure_a=subfigures[0]
subfigure_b=subfigures[1]

subfigure_a.suptitle("Titulo de la SubFigura A")
axes_1 = subfigure_a.add_subplot(1,2,1)
axes_1.set_title("axes_1")
axes_2 = subfigure_a.add_subplot(1,2,2)
axes_2.set_title("axes_2")

subfigure_b.suptitle("Titulo de la SubFigura B")
axes_3 = subfigure_b.add_subplot(1,2,1)
axes_3.set_title("axes_3")
axes_4 = subfigure_b.add_subplot(1,2,2)
axes_4.set_title("axes_4")

Proyecciones

Indicar como es la proyección de los ejes.

import matplotlib.pyplot as plt

figure=plt.figure(figsize=(15, 5))
figure.suptitle("Ejemplos de Proyecciones", fontsize=20)



axes1 = figure.add_subplot(1,3,1,projection='rectilinear')
axes1.set_title("Proyección 'rectilinear'")

axes2 = figure.add_subplot(1,3,2,projection='3d')
axes2.set_title("Proyección '3d'")

axes3 = figure.add_subplot(1,3,3,projection='polar')
axes3.set_title("Proyección 'polar'")

Clase Figura

La siguiente clase permite simplificar la creación de Axes cuando queremos mostrar muchos en forma de matriz con varias columnas y muchas filas.

class Figura:
  def __init__(self,ncols,naxes,axes_width_inches=6, axes_height_inches=None):
    self.ncols=ncols
    self.num_axes=naxes
    self.nrows=math.ceil(naxes/ncols)
    if axes_height_inches==None:
      axes_height_inches=axes_width_inches*0.86
 
    self.figure, self.arr_axes = plt.subplots(ncols=self.ncols, nrows=self.nrows, figsize=(self.ncols*axes_width_inches,self.nrows*axes_height_inches),
                        layout="constrained")
 
    if isinstance(self.arr_axes, (list, tuple, np.ndarray))==False:
      self.arr_axes=np.array([[self.arr_axes]])

  def get_axes(self):
        return np.array(self.arr_axes).reshape(-1)

El uso de la clase es la siguiente.

Imagina que quieres mostrar 12 Axes en 3 columnas y luego obtener cada uno de los axes.

figura=Figura(ncols=3,naxes=12)

for axes in figura.get_axes():
  axes.plot()

La ventaja de esta clase es que no te tienes que preocupar del número de filas que va a haber. Que en este caso serán 4

Dibujando en 2D

Ahora veamos una serie de métodos para dibujar en un Axes o gráfica en 2 dimensiones

Para dibujar una serie de puntos se usa el método scatter

import matplotlib.pyplot as plt
import numpy as np
 
figure=plt.figure()
axes = figure.add_subplot()

x=np.array([0,1,2,3,4,5,6])
y=np.array([0,1,4,9,16,25,36])

axes.scatter(x,y)

Para dibujar una línea siguiendo una serie de puntos se usa el método plot

import matplotlib.pyplot as plt
import numpy as np
 
figure=plt.figure()
axes = figure.add_subplot()

x=np.array([0,1,2,3,4,5,6])
y=np.array([0,1,4,9,16,25,36])

axes.plot(x,y)

Para dibujar una diagrama de barras en base a una serie de puntos se usa el método bar

import matplotlib.pyplot as plt
import numpy as np
 
figure=plt.figure()
axes = figure.add_subplot()

x=np.array([0,1,2,3,4,5,6])
y=np.array([0,1,4,9,16,25,36])

axes.bar(x,y)

En un mismo Axes se pueden dibujar varias cosas a la vez

import matplotlib.pyplot as plt
import numpy as np
 
figure=plt.figure()
axes = figure.add_subplot()

x1=np.array([0,1,2,3,4,5,6])
y1=np.array([0,1,4,9,16,25,36])

x2=np.array([0,1,2,3,4,5,6])
y2=np.array([-1,2,4,7,18,23,39])

axes.plot(x1,y1)
axes.scatter(x2,y2)

Dibujando en 3D

Ahora veamos una serie de métodos para dibujar en un Axes o gráfica en 3 dimensiones

Para dibujar una serie de puntos se usa el método scatter, la diferencia es que se pasa la z y la proyección es 3d.

import matplotlib.pyplot as plt
import numpy as np

 
figure=plt.figure()
axes = figure.add_subplot(projection='3d')

x=np.array([0,1,2,6,4,5,6])
y=np.array([0,1,4,9,16,25,36])
z=np.array([0,4,7,3,9,12,18])

axes.scatter(x,y,z)

Para dibujar una línea siguiendo una serie de puntos se usa el método plot, la diferencia es que se pasa la z y la proyección es 3d.

import matplotlib.pyplot as plt
import numpy as np
 
figure=plt.figure()
axes = figure.add_subplot(projection='3d')

x=np.array([0,1,2,6,4,5,6])
y=np.array([0,1,4,9,16,25,36])
z=np.array([0,4,7,3,9,12,18])

axes.plot(x,y,z)

Para dibujar una superficie en 3D se usa plot_surface.

import matplotlib.pyplot as plt
import numpy as np
 
figure=plt.figure(figsize=(8,8))
axes = figure.add_subplot(projection='3d')

x=np.linspace(-3,3,100)
y=np.linspace(-3,3,100)
x,y=np.meshgrid(x,y)
z =  3*(1 - x)**2 * np.exp(-x**2 - (y + 1)**2)  - 10*(x/5 - x**3 - y**5)*np.exp(-x**2 - y**2) - 1./3*np.exp(-(x + 1)**2 - y**2) 

axes.plot_surface(x,y,z)

$$z=3(1-x)^2e^{-x^2-(y+1)^2}-10(\frac{x}{5}-x^3-y^5)e^{-x^2-y^2}-\frac{1}{3}e^{-(x+1)^2-y^2}$$

Si queremos interaccionar con el gráfico en 3D para poder rotarlo y así verlo mejor , debemos hacer lo siguiente:

Añadir lo siguiente antes de los imports

%matplotlib widget

o

%matplotlib ipympl

y previamente haber instalado ipympl

conda install -c conda-forge ipympl

Si queremos variar la posición de la cámara lo podemos hacer con:

axes.view_init(45, -45)

Tambien podemos dibujar la superficie si solo tenemos unos pocos puntos y que interpole el resto. Para interpolar los puntos usamos griddata en la función get_points_surface.

import numpy as np
import matplotlib.pyplot as plt
from scipy.interpolate import griddata

def get_points_surface(x,y,z):
    xi = np.linspace(min(x), max(x), 100)
    yi = np.linspace(min(y), max(y), 100)
    meshgrid_x, meshgrid_y = np.meshgrid(xi, yi)

    # Interpola los valores z en la malla
    meshgrid_z= griddata((x, y), z, (meshgrid_x, meshgrid_y), method='cubic')

    return meshgrid_x,meshgrid_y,meshgrid_z

# Tenemos solo 50 puntos
x = np.array([ 0.30478742,  1.24888694, -1.25457157,  0.06496563,  2.35768173,
        2.37775853, -2.24648814, -1.75654273, -2.69119678, -0.35514094,
       -2.82074273, -0.25900065,  0.89486429, -1.3290763 ,  1.05752941,
        0.5451769 , -2.85610871,  0.35312453, -1.44448532, -0.50939282,
       -1.29884951,  1.15882751, -0.35727769, -2.05879357,  0.26789411,
        1.68188859, -1.16181881, -1.6682527 , -0.67217245,  2.6183019 ,
        2.85597253,  1.03430206,  2.41700465,  2.07450523, -0.73203575,
       -2.44669795,  0.92046542,  0.34704457, -0.83061142, -1.64967297,
       -0.5608805 , -0.18635851, -1.38458653, -1.24924335, -0.2538816 ,
        2.16320348,  0.51751743, -1.29907283, -1.33213496, -0.27226755])
y = np.array([-1.76753793, -1.79172773,  0.08421036, -2.47662379, -0.09848681,
       -0.82694273,  1.24611973,  1.48047734,  1.14655753,  1.13508248,
       -0.75839926,  1.00880883, -0.96090802,  0.43676322, -1.04515705,
       -0.3291297 , -2.63082642, -1.54394747,  2.82961564, -1.61649477,
        1.14886507,  0.90286115,  1.34363484, -0.14946834,  0.57998265,
       -2.59818346, -2.56462717, -1.80614384, -2.08883402, -2.39937393,
       -2.22423681,  0.31966639, -1.87311105,  2.71260746,  1.08967067,
        0.24611804,  1.2430836 , -1.41667997,  2.56035411,  2.03515835,
        1.35791699, -0.11856026,  2.05261912,  1.46851394,  0.96195544,
        2.4838516 ,  0.80199338, -0.80435649,  0.31706744, -1.82171654])
z = 3*(1 - x)**2 * np.exp(-x**2 - (y + 1)**2)  - 10*(x/5 - x**3 - y**5)*np.exp(-x**2 - y**2) - 1./3*np.exp(-(x + 1)**2 - y**2) 


meshgrid_x,meshgrid_y,meshgrid_z=get_points_surface(x,y,z)


figure = plt.figure(figsize=(10, 7))
axes = figure.add_subplot(projection='3d')
axes.plot_surface(meshgrid_x,meshgrid_y,meshgrid_z)

# Añadimos los puntos originales
axes.scatter(x, y, z, color='red')

Otra forma de dibujar superficies en 3D es mostrar el eje Z como colores similar a las curvas de nivel en los mapas topográficos, se usa el método contourf. El parámetro levels indica el número de regiones distintas o curvas de nivel a mostrar.

import matplotlib.pyplot as plt
import numpy as np
 
figure=plt.figure(figsize=(8,8))
axes = figure.add_subplot()

x=np.linspace(-3,3,100)
y=np.linspace(-3,3,100)
x,y=np.meshgrid(x,y)
z =  3*(1 - x)**2 * np.exp(-x**2 - (y + 1)**2)  - 10*(x/5 - x**3 - y**5)*np.exp(-x**2 - y**2) - 1./3*np.exp(-(x + 1)**2 - y**2) 

axes.contourf(x,y,z,levels=30)

Dibujando en 4D

Dibujar en 4D no es posible pero si lo que queremos es representar 2 variables en función de otras 2 variables , si que es posible mediante las siguientes técnicas:

Variar el tamaño del punto en función de una variable
Variar el color del punto en función de otra variable

Las 4 variables se mostrarían como:

Eje X
Eje Y
Color
Tamaño

import matplotlib.pyplot as plt
import numpy as np
  
figure=plt.figure(figsize = (10, 7))
axes = figure.add_subplot()
 
random_state = np.random.RandomState(0)
x = random_state.randn(100)
y = random_state.randn(100)
color = random_state.randn(100)
size = 500 * random_state.randn(100)
 
 
scatter=axes.scatter(x,y,c=color,s=size,cmap='hsv', alpha=0.4)
figure.colorbar(scatter,ax=axes)

Usamos el parámetro c que significa el color para mostrar el valor de z1, mientras que el parámetro s que significa el tamaño (size en inglés)) para mostrar el valor de z2. Es decir que en función de x e y, mostramos las 2 variables z1 y z2. Por último el parámetro de alpha es para hacer que los puntos sean un poco transparentes.

Dibujando en 5D

La técnica anterior se puede aplicar a una gráfica en 3D con lo que conseguimos representar hasta 5 variables distintas.

Las 5 variables se mostrarían como:

Eje X
Eje Y
Eje Z
Color
Tamaño

import matplotlib.pyplot as plt
import numpy as np
 
figure=plt.figure(figsize = (16, 9))
axes = figure.add_subplot(projection ="3d")

random_state = np.random.RandomState(0)
x = random_state.randn(100)
y = random_state.randn(100)
z = random_state.randn(100)
color = random_state.randn(100)
size = 500 * random_state.randn(100)


scatter=axes.scatter(x,y,z,c=color,s=size,cmap='hsv', alpha=0.4)
figure.colorbar(scatter,ax=axes, shrink = 0.5)

Histogramas

Los histogramas consisten el mostrar la frecuencia con la que aparecen los valores en una secuencia unidimensional de datos. Podríamos pensar que son como diagramas de barras pero la información que muestran es de naturaleza distinta. En un diagrama de barras el origen de los datos es pares de números (x , y) , mientras que en un histograma solo existe la x.

Para hacer histogramas no vamos a usar la librería matplotlib sino una mas avanzada que está sobre ella llamada seaborn. Seaborn permite hacer cosas como matplotlib pero de una forma más sencilla.

Para dibujar un histograma se usa el método histplot sobre el objeto sns

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
 
figure=plt.figure(figsize = (6, 6))
axes = figure.add_subplot()

x=[0,1,4,3,4,5,6,7,6,5,4,3,2,1,2,3,2,3,4,5,6,5,6,7,8,7,6,5,4,4,5,6,7,8,9,8,7,6,5,6,7,6,5,4,3,2,3]

sns.histplot(x=x,ax=axes)

Es necesaior importar la librería de seaborn con:

import seaborn as sns

El método histplot para dibujar el histograma ya no se aplica sobre el Axes sino sobre sns pero hay que pasarle el axes con ax=axes

sns.histplot(x=x,ax=axes)

Para dibujar el Kernel density estimation o KDE se usa el método kdeplot sobre el objeto sns

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

figure=plt.figure(figsize = (6, 6))
axes = figure.add_subplot()

x=[0,1,4,3,4,5,6,7,6,5,4,3,2,1,2,3,2,3,4,5,6,5,6,7,8,7,6,5,4,4,5,6,7,8,9,8,7,6,5,6,7,6,5,4,3,2,3]

sns.kdeplot(x=x,fill=True,ax=axes)

Si nos fijamos la escala del eje Y ya no es la frecuencia absoluta sino relativa

Si queremos mostrar tanto el histograma como el KDE se usa el método histplot pero sobre el objeto sns pero con el parámetro kde=True

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

figure=plt.figure(figsize = (6, 6))
axes = figure.add_subplot()

x=[0,1,4,3,4,5,6,7,6,5,4,3,2,1,2,3,2,3,4,5,6,5,6,7,8,7,6,5,4,4,5,6,7,8,9,8,7,6,5,6,7,6,5,4,3,2,3]

sns.histplot(x=x,kde=True,ax=axes)

Vemos que las curvas KDE de histplot y kdeplot no son iguales. Si dibujamos ambos en una mismo Axes e indicamos stat="density" en histplot vemos que son iguales. El motivo es que histplot puede mostrar los datos de distintas formas según el parámetro stat cuyas valores son count, frequency, probability o density. seaborn.histplot

sns.histplot(x=x,kde=True,ax=axes,label="histplot",stat="density", color="blue")
sns.kdeplot(x=x,fill=True,ax=axes,label="kdeplot", color="green")

Para dibujar el KDE pero para comparar 2 distribuciones, se usa el método kdeplot sobre el objeto sns

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

figure=plt.figure(figsize = (6, 6))
axes = figure.add_subplot()

x   =[0,1,4,3,4,5,6,7,6,5,4,3,2,1,2,3,2,3,4,5,6,5,6,7,8,7,6,5,4,4,5,6,7,8,9,8,7,6,5,6,7,6,5,4,3,2,3,    1,2,3,7,8,5,3,7,8,9,9,6,8,0,9,8,6,3,2,7,6,5,3,6,7,4,8,9,7,2,1,6,5,3,2,3,5,6,7,8,7,8,7,5,6,9,8]
tipo=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]

sns.kdeplot(x=x,hue=tipo,fill=True,ax=axes)

Dibujando imágenes

Vamos ahora a tratar imágenes

Se pueden dibujar imágenes, simplemente indicando los colores de cada pixel como un tensor de colores.

import matplotlib.pyplot as plt
import numpy as np
 
figure=plt.figure()
axes = figure.add_subplot()

imagen=np.array([[[255,0,0],[0,255,0],[255,255,0]],[[0,0,255],[0,0,0],[0,255,255]]])

axes.xaxis.set_ticks([0,1,2])
axes.yaxis.set_ticks([0,1])
axes.imshow(imagen)

Personalización

Veamos ahora una serie de métodos y parámetros para personalizar los Axes o gráficos.

Datos

Leyendas de los datos. En los métodos de plot o scatter hay que indicar el label y luego indicar que se muestre la leyenda con legend

axes.plot(x1,y1,label="Previsión")
axes.scatter(x2,y2,label="Medido")
axes.legend(fontsize=15,facecolor='#CDCDCD',labelcolor="#000000")

También es posible mostrar la leyenda poniendo los nombres directamente en el módulo legend en vez de en los métodos que dibujan como plot, scatter, etc.

axes.plot(x1,y1)
axes.scatter(x2,y2)
axes.legend(fontsize=15,facecolor='#CDCDCD',labelcolor="#000000",labels=["Previsión","Medido"])

Leyendas para colores: Podemos usar leyendas para cada tipo de color si mostramos los puntos con colores distintos. Para ello en el método legends usaremos handles=scatter.legend_elements()[0]

import matplotlib.pyplot as plt
import numpy as np
   
figure=plt.figure(figsize = (10, 7))
axes = figure.add_subplot()
  
random_state = np.random.RandomState(0)
x = random_state.randn(100)
y = random_state.randn(100)
tipo = random_state.randint(5, size=100)
labels_tipos=["A","B","C","D","E"]
  
  
scatter=axes.scatter(x,y,c=tipo)
legends=axes.legend(handles=scatter.legend_elements()[0],labels=labels_tipos)

Si queremos saber el color que ha usado en cada tipo para poder reusar ese color para otra cosa, lo podemos hacer con:

index=0
color=legends.get_lines()[index].get_color()

Siendo index un valor entre 0 y len(labels_tipos)-1 ya que obviamente va a haber el mismo número de colores que elementos en el array de leyendas que es labels_tipos

Colores de los datos. Solo hay que indicar el argumento de color.

axes.plot(x1,y1,color="#FF0000")
axes.scatter(x2,y2,color="blue")

También podemos obtener el siguiente color que vamos a usar con:

#Versiones nuevas
color=axes._get_lines.get_next_color()
#Versiones antiguas
color=next(axes._get_lines.prop_cycler)['color']

Destacar que al obtener el siguiente color ya no se usará ya que ese color se ha "gastado". Eso es porque al obtener el color se ha avanzado en el ciclo de colores y ese ya no se usaría. Aunque obviamente se podría usar el color ya que tenemos el color en la variable color

Con el método annotate podemos anotar los datos.

import matplotlib.pyplot as plt
import numpy as np
 
figure=plt.figure()
axes = figure.add_subplot()

x=np.array([0,1,2,3,4,5,6])
y=np.array([0,1,4,9,16,25,36])
labels=["A","B","C","D","E","F","G"]

axes.scatter(x,y)

for index,label in enumerate(labels):
    axes.annotate(label,xy=(x[index],y[index]),ha='right', va='bottom',fontsize=13)

Al usar plot podemos hacer que junto a la línea también salgan los puntos o incluso solo los puntos. Para ello se añade un tercer parámetro con el estilo del marker. Puedes ver todos los posibles estilos de markers en matplotlib.markers

axes.plot(x1,y1,"*-")

Títulos

Establecer el título de cada eje Axis y del propio gráfico Axes.

axes.set_xlabel('Mes/Año', fontsize=15,labelpad=20,color="#003B80")  
axes.set_ylabel('Importe (€)', fontsize=15,labelpad=20,color="#003B80")
axes.set_title("Gastos y Beneficios Mensuales", fontsize=20,pad=30,color="#003B80")

No confundir el título del Axes con el del figure.

Cuando ponemos varios Axes con título y label, se suelen solapar los textos entre ello. Para evitarlo, se debe añadir al final la orden:

figure.tight_layout()

Color del Fondo

Establecer el color del fondo con set_facecolor

axes.set_facecolor("#F0F7FF")

Ejes

Datos a mostrar en los ejes junto con el color , tamaño de fuente y el min/max

axes.xaxis.set_ticks([0,2,4,6,8,10])
axes.yaxis.set_ticks([0,10,20,30,40,50,60])

axes.tick_params(axis='x',labelsize=13, colors="#FF00FF")
axes.tick_params(axis='y',labelsize=20, colors="#FF0000") 

axes.set_xlim(xmin=0,xmax=10)
axes.set_ylim(ymin=0,ymax=60)

guías interiores (grid)

axes.grid(visible=True, which='major', axis='both',color="#A0A0A0",linewidth=1)
axes.set_axisbelow(True)

Incluir axes.set_axisbelow(True) para que el grid esté por debajo en el z-orden.

se pueden añadir también las guías interiores con:

axes.minorticks_on()
axes.grid(b=True, which='minor', axis='both',color="#A0A0A0",linewidth=1)

Se puede hacer que automáticamente se creen los "tick" con:

axes.xaxis.set_major_locator(locator)
axes.yaxis.set_major_locator(locator)
axes.xaxis.set_minor_locator(locator)
axes.yaxis.set_minor_locator(locator)

Siendo los locator alguno de los siguientes:

NullLocator
MultipleLocator
FixedLocator
LinearLocator
IndexLocator
AutoLocator
MaxNLocator
LogLocator

Que se importan como:

from matplotlib.ticker import NullLocator
from matplotlib.ticker import MultipleLocator
from matplotlib.ticker import FixedLocator
from matplotlib.ticker import LinearLocator
from matplotlib.ticker import IndexLocator
from matplotlib.ticker import AutoLocator
from matplotlib.ticker import MaxNLocator
from matplotlib.ticker import LogLocator

Mas información:

Hacer que los valores de los ejes siempre sean número enteros y no con decimales

from matplotlib.ticker import MaxNLocator

axes.xaxis.set_major_locator(MaxNLocator(integer=True))

Configurar las líneas de los ejes. Se pueden hacer invisibles o cambiar el color

axes.spines['right'].set_visible(False)
axes.spines['top'].set_visible(False)
axes.spines['left'].set_color("#FF0000")
axes.spines['bottom'].set_color("#FF0000")

Superficies

Al dibujar una superficie en 3D, podemos cambiar los colores en función del valor de z. Para ello usamo el argumento cmap. Los posibles valores de cmap los podemos ver en Choosing Colormaps in Matplotlib

axes.plot_surface(x,y,z,cmap='turbo')

axes.contourf(x,y,z,levels=30,cmap='turbo')

El cmap, además de como un string también se puede especificar como un objeto Python de la siguiente forma plt.cm.turbo

axes.plot_surface(x,y,z,cmap=plt.cm.turbo)

Podemos añadir una barra con los colores con el método colorbar. Notar que el método colorbar se usa sobre la figura y hay que pasarle el Axes. Por último el parámetro shrink es para que la barra no salga tan alta.

surface=axes.plot_surface(x,y,z,cmap='turbo')
figure.colorbar(surface,ax=axes, shrink = 0.5)

Otra forma de hacerlo es la siguiente:

figure.colorbar(plt.cm.ScalarMappable(cmap=plt.cm.turbo),ax=axes, shrink = 0.5)

Se pueden añadir sombreado a la imagen para que quede mas realista.

from matplotlib.colors import LightSource

light_source = LightSource()
facecolors = light_source.shade(z,plt.cm.turbo, blend_mode='soft')

axes.plot_surface(x,y,z,facecolors=facecolors)

Estableciendo el estilo

Es posible establecer el estilo general que usan los gráficos en mathplotlib. Es decir que tengan ya un aspecto predefinido.

Simplemente con la línea plt.style.use('ggplot') tendrá el estilo que se usan en ggplot

Haciendo que los gráficos pasen de tener este estilo por defecto:

a tener este otro estilo:

Para saber los posibles estilos que hay , solo tenemos que ejecutar:

print(plt.style.available)

[
 'Solarize_Light2', '_classic_test_patch', '_mpl-gallery', '_mpl-gallery-nogrid', 'bmh',
 'classic', 'dark_background', 'fast', 'fivethirtyeight', 'ggplot', 'grayscale', 
 'seaborn-v0_8', 'seaborn-v0_8-bright', 'seaborn-v0_8-colorblind', 'seaborn-v0_8-dark',
 'seaborn-v0_8-dark-palette', 'seaborn-v0_8-darkgrid', 'seaborn-v0_8-deep', 'seaborn-v0_8-muted', 
 'seaborn-v0_8-notebook', 'seaborn-v0_8-paper', 'seaborn-v0_8-pastel', 'seaborn-v0_8-poster',
 'seaborn-v0_8-talk', 'seaborn-v0_8-ticks', 'seaborn-v0_8-white', 'seaborn-v0_8-whitegrid', 
 'tableau-colorblind10'
]

Como podemos ver hay muchos estilos relacionados con Seaborn

Mostrar perdida por época

Una gráfica que siempre es necesaria es mostrar el "error" o "loss" a medida que se va entrenando.

Es similar a la siguiente gráfica:

Pero ahora asignado un valor de "loss" a cada época:

Sin embargo no se hace nunca como algo animado sino simplemente se muestra la última gráfica:

Definir el propio estilo

Normalmente queremos que todas nuestras gráficas tengan un mismo estilo , por ello es bueno crear una serie de funciones estándar que siempre usaremos.

La primera función que usamos se llama axes_configure_labels(axes,title,xlabel,ylabel) que configura tanto los labels como los colores y tamaños de fuente.

def axes_configure_labels(axes,title,xlabel,ylabel):
    color="#003B80"
    facecolor="#FAFCFF"
    gridcolor="#BAD4F2"
    tickcolor="#011E32"
    fontsize_label=13

    axes.set_xlabel(xlabel, fontsize=fontsize_label,color=color)
    axes.set_ylabel(ylabel, fontsize=fontsize_label,color=color)
    axes.set_title(title,color=color)

    axes.set_facecolor(facecolor)
    axes.spines['bottom'].set_color(tickcolor)
    axes.spines['top'].set_color(tickcolor)
    axes.spines['right'].set_color(tickcolor)
    axes.spines['left'].set_color(tickcolor)
    axes.tick_params(axis='both', colors=tickcolor)

    axes.grid(visible=True, which='major', axis='both',color=gridcolor,linewidth=1,zorder=-10)
    axes.set_axisbelow(True)

    handles, labels = axes.get_legend_handles_labels()
    if labels:
        axes.legend(fontsize=fontsize_label-2,labelcolor=color)

La siguiente función es axes_configure_for_metrics(axes) que configura las gráficas para mostrar métricas que van de $[0-1]$.

def axes_configure_axis_for_metrics(axes):
    axes.set_xlim(xmin=0,xmax=1)
    axes.set_ylim(ymin=0,ymax=1.1)

    axes.xaxis.set_major_locator(MultipleLocator(0.1))
    axes.yaxis.set_major_locator(MultipleLocator(0.1))

Para mostrar las gráficas de la pérdida en función de las épocas se usarán las funciones axes_configure_axis_for_epochs y plot_history_metric:

def axes_configure_axis_for_epochs(axes,ymax=1):
    axes.xaxis.set_major_locator(MaxNLocator(10,integer=True))
    axes.yaxis.set_major_locator(LinearLocator(10))
    axes.set_ylim(ymin=0,ymax=ymax)

def plot_history_metric(axes,history,metric_name,label=None,color="#003B80",decimales=2):

    if (label==None):
        label=metric_name

    axes.plot(history[metric_name],linestyle="dotted",c=color,label=f"{label}:{history[metric_name][-1]:.{decimales}f}")  
    axes.plot(history['val_'+metric_name],linestyle="solid",c=color,label=f"Valid. {label}:{history['val_'+metric_name][-1]:.{decimales}f}")

Usándose así:

figure=plt.figure(figsize=(6, 3.5))
axes=figure.add_subplot(1,1,1)

plot_history_metric(axes,history.history,"loss",decimales=6)
axes_configure_labels(axes,"loss por épocas","Nº Épocas","Loss")
axes_configure_axis_for_epochs(axes,1.1)