Stellargraph Python (Cómo Funciona para Desarrolladores)

¿Qué es StellarGraph?

StellarGraph es una biblioteca de Python diseñada para el aprendizaje automático con datos estructurados en gráficos. Proporciona un conjunto completo de herramientas para crear, manipular y visualizar gráficos. Además, StellarGraph ofrece algoritmos avanzados de aprendizaje automático basados en gráficos adaptados para aprender y analizar datos de gráficos complejos, lo que incluye la finalización de gráficos de conocimiento.

StellarGraph admite tareas como la clasificación de nodos, la predicción de enlaces y la clasificación de gráficos a través de su implementación de modelos como Graph Convolutional Networks y Graph Attention Networks.

También está integrado con varios flujos de trabajo populares de aprendizaje automático de gráficos, como TensorFlow y Keras, lo que lo convierte en una buena solución para el análisis y la obtención de conocimientos de redes complejas en la mayoría de los campos como redes sociales, bioinformática y sistemas de recomendación.

Cómo empezar con StellarGraph

Para generar un gráfico utilizando StellarGraph, se le guiará a través de la instalación de las bibliotecas, la creación del gráfico, la definición de características de nodos y aristas, y finalmente la configuración de un modelo de aprendizaje automático. Aquí hay una guía paso a paso para comenzar:

pip install stellargraph 
pip install tensorflow 
pip install pandas 
pip install numpy

pip install stellargraph 
pip install tensorflow 
pip install pandas 
pip install numpy

Uso de StellarGraph en Python

Un ejemplo simple de definir un gráfico, agregar características de aristas y nodos con la ayuda de los numerosos algoritmos que se incluyen en StellarGraph:

import pandas as pd
import numpy as np
from stellargraph import StellarGraph
import matplotlib.pyplot as plt
import networkx as nx

# Step 1: Create Sample Graph Data
# Generating random feature values for 5 nodes
nodes = pd.DataFrame({
    "feature1": np.random.randn(5),
    "feature2": np.random.randn(5)
}, index=[f"node{i}" for i in range(5)])

# Defining edges in the graph
edges = pd.DataFrame({
    "source": ["node0", "node1", "node2", "node3"],
    "target": ["node1", "node2", "node3", "node4"]
})

# Step 2: Create StellarGraph Object
G = StellarGraph(nodes=nodes, edges=edges)

# Step 3: Define and Visualize the Graph
# Plot the graph
fig, ax = plt.subplots(figsize=(8, 6))

# Compute positions for each node in a circular layout
pos = {node: (np.cos(2 * np.pi * i / len(G.nodes())), np.sin(2 * np.pi * i / len(G.nodes())))
       for i, node in enumerate(G.nodes())}

# Draw the graph using NetworkX
nx.draw(G.to_networkx(), pos, with_labels=True, node_color='lightblue', edge_color='grey', node_size=500, font_size=10, ax=ax)

# Add a title for the graph
plt.title('StellarGraph Visualization')

# Save the visualization as an image
plt.savefig('graph.png')
plt.close()

import pandas as pd
import numpy as np
from stellargraph import StellarGraph
import matplotlib.pyplot as plt
import networkx as nx

# Step 1: Create Sample Graph Data
# Generating random feature values for 5 nodes
nodes = pd.DataFrame({
    "feature1": np.random.randn(5),
    "feature2": np.random.randn(5)
}, index=[f"node{i}" for i in range(5)])

# Defining edges in the graph
edges = pd.DataFrame({
    "source": ["node0", "node1", "node2", "node3"],
    "target": ["node1", "node2", "node3", "node4"]
})

# Step 2: Create StellarGraph Object
G = StellarGraph(nodes=nodes, edges=edges)

# Step 3: Define and Visualize the Graph
# Plot the graph
fig, ax = plt.subplots(figsize=(8, 6))

# Compute positions for each node in a circular layout
pos = {node: (np.cos(2 * np.pi * i / len(G.nodes())), np.sin(2 * np.pi * i / len(G.nodes())))
       for i, node in enumerate(G.nodes())}

# Draw the graph using NetworkX
nx.draw(G.to_networkx(), pos, with_labels=True, node_color='lightblue', edge_color='grey', node_size=500, font_size=10, ax=ax)

# Add a title for the graph
plt.title('StellarGraph Visualization')

# Save the visualization as an image
plt.savefig('graph.png')
plt.close()

El ejemplo mostrado ilustra cómo construir un gráfico y su visualización simple utilizando la biblioteca StellarGraph en conjunto con las bibliotecas Matplotlib y NetworkX. El ejemplo comienza importando las bibliotecas necesarias: pandas y Numpy para el manejo de datos; StellarGraph para crear la estructura del gráfico en sí; y Matplotlib y NetworkX para la visualización.

Primero, los datos de muestra del gráfico se generan. En este ejemplo, tenemos el DataFrame de nodos con valores de características aleatorios para cinco nodos con identificadores node0 a node4. El DataFrame de aristas describe aristas; contiene pares de fuente-objetivo que describen los nodos que están conectados.

Luego, se crea una instancia de la clase StellarGraph con los datos de nodos y aristas, que almacena esta estructura de datos almacenada en el gráfico.

Finalmente, visualiza este gráfico. Proporciona una función para calcular un diseño circular para la colocación de nodos, donde cada nodo se coloca de acuerdo a coordenadas polares. La biblioteca NetworkX luego convierte este objeto StellarGraph en un gráfico NetworkX, que luego es graficado por Matplotlib. Los nodos son azul claro, las aristas son grises, el gráfico está etiquetado y finalmente personalizado en términos de tamaño y fuente. Finalmente, la trama se guarda como un archivo de imagen llamado gráfica.png, y se cierra la ventana de trazado.

Presentando IronPDF

El módulo IronPDF para Python permite la creación y edición programática de archivos PDF. Podrá generar PDFs desde HTML, combinar varios archivos PDF en uno solo, e incluso hacer uso de PDFs existentes a los que se les haya añadido texto, fotos y anotaciones. En contraste, IronPDF permite la producción de PDFs de calidad desde cualquier sitio web escrito en HTML u otro contenido generado en Internet al crear informes, facturas u otros documentos previamente estilizados.

Algunas de sus características avanzadas son la edición de diseño de página, el cifrado de documentos, la extracción de contenido de un PDF, y muchas más. Mejorar cómo sus productos manejan PDFs colocará mejor a los desarrolladores para mejorar su utilidad general.

pip install ironpdf

pip install ironpdf

Combine StellarGraph con IronPDF

A continuación se muestra el código para generar un PDF a partir de la imagen de gráfico creada por StellarGraph.

import pandas as pd
import numpy as np
from stellargraph import StellarGraph
import matplotlib.pyplot as plt
import networkx as nx
from ironpdf import ImageToPdfConverter, License

import warnings
warnings.filterwarnings('ignore')

# Replace "YOUR LICENSE KEY GOES HERE" with your IronPDF license key
License.LicenseKey = "YOUR LICENSE KEY GOES HERE"

# Step 1: Create Sample Graph Data
nodes = pd.DataFrame({
    "feature1": np.random.randn(5),
    "feature2": np.random.randn(5)
}, index=[f"node{i}" for i in range(5)])

edges = pd.DataFrame({
    "source": ["node0", "node1", "node2", "node3"],
    "target": ["node1", "node2", "node3", "node4"]
})

# Step 2: Create StellarGraph Object
G = StellarGraph(nodes=nodes, edges=edges)

# Step 3: Define and Visualize the Graph
fig, ax = plt.subplots(figsize=(8, 6))
pos = {node: (np.cos(2 * np.pi * i / len(G.nodes())), np.sin(2 * np.pi * i / len(G.nodes())))
       for i, node in enumerate(G.nodes())}

nx.draw(G.to_networkx(), pos, with_labels=True, node_color='lightblue', edge_color='grey', node_size=500, font_size=10, ax=ax)
plt.title('StellarGraph Visualization')
plt.savefig('graph.png')
plt.close()

# Step 4: Convert the image to PDF using IronPDF
ImageToPdfConverter.ImageToPdf('graph.png').SaveAs("result.pdf")

import pandas as pd
import numpy as np
from stellargraph import StellarGraph
import matplotlib.pyplot as plt
import networkx as nx
from ironpdf import ImageToPdfConverter, License

import warnings
warnings.filterwarnings('ignore')

# Replace "YOUR LICENSE KEY GOES HERE" with your IronPDF license key
License.LicenseKey = "YOUR LICENSE KEY GOES HERE"

# Step 1: Create Sample Graph Data
nodes = pd.DataFrame({
    "feature1": np.random.randn(5),
    "feature2": np.random.randn(5)
}, index=[f"node{i}" for i in range(5)])

edges = pd.DataFrame({
    "source": ["node0", "node1", "node2", "node3"],
    "target": ["node1", "node2", "node3", "node4"]
})

# Step 2: Create StellarGraph Object
G = StellarGraph(nodes=nodes, edges=edges)

# Step 3: Define and Visualize the Graph
fig, ax = plt.subplots(figsize=(8, 6))
pos = {node: (np.cos(2 * np.pi * i / len(G.nodes())), np.sin(2 * np.pi * i / len(G.nodes())))
       for i, node in enumerate(G.nodes())}

nx.draw(G.to_networkx(), pos, with_labels=True, node_color='lightblue', edge_color='grey', node_size=500, font_size=10, ax=ax)
plt.title('StellarGraph Visualization')
plt.savefig('graph.png')
plt.close()

# Step 4: Convert the image to PDF using IronPDF
ImageToPdfConverter.ImageToPdf('graph.png').SaveAs("result.pdf")

Este es un fragmento de código para la creación y visualización de un gráfico a través de la biblioteca StellarGraph, luego convirtiendo la visualización dibujada en un PDF usando IronPDF. Comienza importando las bibliotecas necesarias y estableciendo una clave de licencia de IronPDF. Se generan datos de muestra del gráfico con características aleatorias para los nodos y aristas especificadas. Con estos datos, se crea el objeto StellarGraph. La biblioteca NetworkX visualiza el gráfico en un diseño circular y lo guarda como una imagen PNG. Después, esta imagen PNG se convierte en un documento PDF por el ImageToPdfConverter de IronPDF.

Licencias

Se necesita una clave de licencia para que el código funcione sin una marca de agua. Puede registrarse para una licencia de prueba gratuita en este enlace. Tenga en cuenta que podemos registrarnos sin tener que revelar nuestra identidad. Solo necesitamos introducir su dirección de correo electrónico para poder registrarse y obtener la versión de prueba gratuita.

Conclusión

La integración de StellarGraph con IronPDF abre un camino avanzado y sólido para evaluar datos y procesar documentos. StellarGraph contribuirá potentes técnicas de aprendizaje automático de gráficos para el análisis de datos interconectados, e IronPDF ofrecerá herramientas completas para manejar y manipular documentos PDF. La interacción de estos permitirá extraer conocimientos significativos de estructuras de datos complicadas dentro de un documento PDF.

Su combinación empodera a las empresas para fusionar el poder del análisis basado en gráficos con el manejo sofisticado de documentos, estableciendo así un flujo de trabajo de procesamiento de datos mucho más eficiente e informativo. Esta integración ha dado otro gran paso hacia la explotación completa de los datos encerrados en el formato PDF y ha abierto nuevos caminos de innovación y optimización en dominios bastante distintos. Iron Software también hace posible crear aplicaciones en muchas plataformas y sistemas operativos, como Windows, Android, MAC y Linux, entre otros, mediante el uso de muchas bibliotecas.