Búsqueda de sitios web

Python: visualiza gráficos generados en NetworkX usando Matplotlib


<h2>Introducción <p>Python representa un lenguaje de codificación flexible reconocido por su facilidad y claridad. Esto ofrece muchas bibliotecas y componentes para optimizar diferentes tareas, incluida la creación de gráficos y visualizaciones. NetworkX representa un conjunto de herramientas Python eficiente para construir, cambiar e investigar la disposición, el movimiento y las operaciones de redes sofisticadas. Matplotlib, sin embargo, es un conjunto de herramientas popular para crear visualizaciones estáticas, animadas e interactivas en Python.

Definición

NetworkX sirve como una biblioteca de Python para construir, modificar e investigar la disposición, el movimiento y las capacidades de redes elaboradas. Esto ofrece múltiples funciones y fórmulas matemáticas para producir una variedad de representaciones gráficas. Esto incluye redes orientadas y no orientadas, multidígrafos y diagramas de dos partes.

Matplotlib proporciona una amplia funcionalidad para generar gráficos estáticos, dinámicos e interactivos con Python. Esto proporciona numerosos recursos para visualizar datos, como diagramas de líneas, diagramas de dispersión, diagramas de barras, histogramas y más.

Sintaxis

import networkx as nx
import matplotlib.pyplot as plt
G = nx.Graph()
G.add_edge(1, 2)
G.add_edge(2, 3)
nx.draw(G)
plt.show()
plt.savefig("filename.png")        

La etapa inicial del programa implica importar los módulos esenciales, `networkx` y `matplotlib.pyplot`. Luego, se crea una variable gráfica en blanco `G` usando la subrutina `Graph()` dentro de la biblioteca `networkx`.

Para definir el diseño del diagrama, se colocan dos líneas de conexión a través de la función `add_edge()`.

Una vez que se completa la definición, la estructura del gráfico es, el programa continúa visualizando el gráfico empleando la función `draw()` del marco `networkx`. El método `draw()` recibe el gráfico `G` como variable y genera una salida visual de la red. Por defecto, la función `draw()` emplea un algoritmo de colocación de resortes para colocar los elementos. Muestra la trama con características visuales preestablecidas.

La llamada a la función 'show()' de la biblioteca 'matplotlib.pyplot' se utiliza para mostrar el gráfico construido. Según las condiciones donde se ejecuta el script.

En última instancia, el programa almacena el gráfico como un archivo de imagen llamado "nombredearchivo.png". Emplea el procedimiento `savefig()` del marco `matplotlib.pyplot`. Esta función permite al usuario definir un nombre de archivo y un formato (como PNG, JPEG, PDF) para almacenar el trazado. En este escenario, el gráfico se conserva como una imagen en formato PNG con el título "filetitle.png". El documento se guardará en la misma carpeta que el script o el cuaderno de Python.

Algoritmo

  • Paso 1: importe las bibliotecas necesarias: networkx y matplotlib.pyplot.

  • Paso 2: genere un gráfico usando NetworkX.

  • Paso 3: dibuja el gráfico usando Matplotlib.

  • Paso 4: guarde el dibujo del gráfico en un archivo.

  • Paso 5: Muestre el dibujo del gráfico.

Acercarse

  • Método 1: visualización de gráficos con etiquetas de nodo y pesos de borde

  • Enfoque 2: visualización de gráficos grandes con subtramas

Método 1: visualización de gráficos con etiquetas de nodo y pesos de borde

Ejemplo

import networkx as nx
import matplotlib.pyplot as plt

# Create graph
G = nx.Graph()

# Add nodes
G.add_node(1, label='A')
G.add_node(2, label='B')
G.add_node(3, label='C')
G.add_node(4, label='D')

# Add edges
G.add_edge(1, 2, weight=4)
G.add_edge(2, 3, weight=7)
G.add_edge(3, 1, weight=2)
G.add_edge(1, 4, weight=5)

# Set node positions
pos = nx.spring_layout(G)

# Draw nodes and labels
nx.draw_networkx_nodes(G, pos)
nx.draw_networkx_labels(G, pos, labels=nx.get_node_attributes(G, 'label'))

# Draw edges with weights
edge_labels = nx.get_edge_attributes(G, 'weight')
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
nx.draw_networkx_edges(G, pos)

# Show graph
plt.axis('off')
plt.show()

Producción

Creamos un objeto gráfico vacío llamado G usando la función Graph() de NetworkX.

Ahora es el momento de llenar nuestro gráfico con nodos. Para agregar nodos individuales al gráfico, utilizamos la función add_node(). A cada nodo se le asigna una identidad única y también podemos asignar etiquetas a los nodos utilizando una propiedad personalizada. En este ejemplo, etiquetamos el nodo 1 como 'A', el nodo 2 como 'B', el nodo 3 como 'C' y el nodo 4 como 'D'.

Desarrollaremos bordes para conectar los nodos cuando los hayamos agregado. Para agregar bordes entre nodos, utilizamos la función add_edge(). Por ejemplo, los nodos 1 y 2 están conectados por un borde de cuatro pesos.

Para ver el gráfico, primero debemos posicionar los nodos. Para calcular automáticamente las ubicaciones de los nodos, utilizamos el método spring_layout() de NetworkX. Esta función aplica un algoritmo que intenta organizar los nodos de una manera estéticamente agradable.

Ahora viene la parte emocionante: ¡visualizar el gráfico! Usamos varias funciones de NetworkX y Matplotlib para crear la trama. Comenzamos dibujando los nodos usando draw_networkx_nodes() y las etiquetas usando draw_networkx_labels(). Pasamos el objeto gráfico G y las posiciones pos que calculamos anteriormente. Esto garantiza que los nodos y las etiquetas se muestren en las posiciones correctas.

Para visualizar los bordes, también los dibujamos usando la función draw_networkx_edges(). Además, incluimos los pesos de los bordes usando la función draw_networkx_edge_labels(). Esta función agrega los pesos de los bordes como etiquetas cerca de los bordes correspondientes.

Finalmente, mostramos el gráfico usando plt.show(). Esto abrirá una ventana o mostrará el gráfico en la interfaz de Jupyter Notebook. Para que la gráfica se vea más limpia y enfocada en el gráfico mismo, usamos plt.axis('off') para desactivar la visibilidad de los ejes.

Enfoque 2: visualización de gráficos grandes con subtramas

Ejemplo

import networkx as nx
import matplotlib.pyplot as plt

# Create graph
G = nx.path_graph(5)

# Create subplots
fig, axs = plt.subplots(nrows=1, ncols=2, figsize=(10, 5))

# Plot original graph
axs[0].set_title('Original Graph')
nx.draw(G, ax=axs[0])

# Plot modified graph
axs[1].set_title('Modified Graph')
pos = nx.spring_layout(G)
nx.draw(G, pos=pos, ax=axs[1], node_color='r', node_size=500, with_labels=False)
plt.suptitle('Visualization of Large Graph with Subplots')
plt.show()

Producción

Primero, importamos las bibliotecas necesarias: NetworkX y Matplotlib.pyplot. Estas bibliotecas nos proporcionan funciones y herramientas para crear y visualizar gráficos.

A continuación, creamos un objeto gráfico llamado G usando la función path_graph() de NetworkX. Esta función genera un gráfico de ruta simple con 5 nodos conectados de manera lineal.

Para organizar las visualizaciones, utilizamos el método subplots() de Matplotlib para construir subtramas. Indicamos el número de filas y columnas de la subtrama (en este caso, una fila y dos columnas), así como el tamaño de la figura.

Esto nos ayuda a dividir el área de la gráfica en varias secciones para mostrar diferentes gráficos.

Ahora es el momento de trazar el gráfico original en la primera subtrama. Accedemos a la primera subtrama usando el índice 0 y configuramos su título usando la función set_title(). Luego, usamos la función draw() de NetworkX para visualizar el gráfico original en esta subtrama.

Pasando a la segunda subtrama, repetimos el proceso. Establecemos su título y accedemos a él usando el índice 1. También calculamos las posiciones de los nodos usando la función spring_layout() de NetworkX, que organiza los nodos de una manera estéticamente agradable. Luego, usamos la función draw() nuevamente para visualizar el gráfico modificado en esta subtrama. Aquí podemos personalizar el color, el tamaño y las etiquetas del nodo para diferenciarlo del gráfico original.

Para mejorar la presentación general, agregamos un título común a toda la figura usando la función suptitle() de Matplotlib.

Conclusión

De esta manera llegamos a conocer estos temas correctamente. Creamos con éxito un gráfico, configuramos subtramas y visualizamos el gráfico usando NetworkX y Matplotlib.