INSTITUTO TECNOLOGICO DE TEHUACAN

ASIGNATURA:
ADMINISTRACION DE DATOS MASIVOS

TEMA:
“ACTIVIDAD 3.1 PROYECTO ALMACEN DE DATOS”

ALUMNOS:
NICOLAS CASTILLO ANA PAOLA
RIVERA ORTAÑEZ VICTOR
HERNANDEZ TRUJILLO JUAN CARLOS

CARRERA:
ING. SISTEMAS COMPUTACIONES

7mo. SEMESTRE

DOCENTE:
PROF. EDUARDO VAZQUEZ ZAYAS

NOVIEMBRE 2023
 DETECCION DE COMUNIDADES EN GRAFOS Y
REDES
La identificación de comunidades y la partición de grafos son técnicas de análisis
de redes que permiten dividir un grafo en grupos o comunidades de nodos que
están altamente conectados entre sí, y que tienen una conexión más débil con el
resto de los nodos del grafo.
La identificación de comunidades se basa en la detección de estructuras
modulares en grafos, lo que puede ser útil para clasificar redes de distintos tipos,
como redes sociales, financieras, de transporte, biológicas, etc. Una comunidad
puede ser considerada como un subconjunto importante de nodos que
representan un grupo de individuos o entidades que están estrechamente
relacionados en la red. Una partición puede dividir el grafo en varios módulos o
comunidades, donde cada nodo pertenece a uno y sólo uno de ellos.
Uno de los algoritmos más populares para lograr esta tarea es el algoritmo de
Louvain, que se usa para maximizar el coeficiente de modularidad (modularity
coefficient) que mide la medida en que una red se divide en comunidades. Este
algoritmo se basa en dos pasos: (1) asignar todos los nodos a su propia
comunidad, y (2) en cada iteración, mover nodos a otras comunidades si eso
aumenta la modularidad. El algoritmo se detiene cuando se alcanza un máximo
local, es decir, cuando no se pueden realizar más cambios que mejoren la
modularidad, y se devuelve el conjunto de comunidades resultantes.
Python cuenta con varios paquetes que implementan este tipo de análisis de
comunidades y particiones, como NetworkX, igraph, Louvain, etc. Con NetworkX,
por ejemplo, podemos usar la función community.modularity() para obtener la
modularidad de una partición de comunidades, y la
función community.greedy_modularity_communities() para aplicar el algoritmo de
Louvain y obtener las comunidades en un grafo.
..
 Practica

Procedimiento:
Una red de grafos es una estructura matemática que consiste en nodos (también
llamados vértices) y conexiones entre esos nodos (también llamadas aristas). Los
grafos son utilizados para representar y modelar relaciones entre entidades. Cada
nodo en un grafo puede representar una entidad (como una persona, una ciudad,
una página web, etc.), y cada arista representa una relación o conexión entre esas
entidades.

Componentes Básicos de un Grafo:

Nodos (Vértices): Representan entidades individuales en la red.

Aristas (Conexiones): Representan relaciones entre pares de nodos.
Tipos de Grafos:

Grafo No Dirigido: Las aristas no tienen dirección. La conexión entre dos nodos
es bidireccional.
Grafo Dirigido: Las aristas tienen dirección. La conexión entre dos nodos puede
ser unidireccional.
Aplicaciones y Usos de las Redes de Grafos:

Redes Sociales: Modelan conexiones entre individuos o usuarios en plataformas

como Facebook, LinkedIn o Twitter.
Internet y World Wide Web: Representan la estructura de enlaces entre páginas
web.

Sistemas de Recomendación: Modelan la relación entre usuarios y elementos

(productos, películas) para hacer recomendaciones personalizadas.

Logística y Transporte: Modelan conexiones entre ubicaciones y puntos de

entrega para optimizar rutas y logística.

Biología y Química: Modelan interacciones entre moléculas, proteínas o especies

en ecología de redes.

Análisis de Citas Académicas: Representan relaciones de citación entre

documentos académicos.

Sistemas de Telecomunicaciones: Modelan conexiones entre dispositivos y

componentes en una red de comunicación.

Gestión de Proyectos: Modelan dependencias y relaciones entre tareas en un

proyecto.

Las redes de grafos son herramientas poderosas para visualizar, analizar y

comprender relaciones complejas en una variedad de campos. Los algoritmos y
técnicas de análisis de grafos permiten descubrir patrones, identificar nodos clave
y entender la estructura subyacente de las interacciones en diversos sistemas.
import networkx as nx
import matplotlib.pyplot as plt

# Crear un grafo de ejemplo

G = nx.karate_club_graph()

# Detección de comunidades utilizando el algoritmo de Louvain

communities =
nx.community.label_propagation.label_propagation_communities(G)

# Elegir la paleta de colores

cmap_name = 'Blues_r'
cmap = plt.cm.get_cmap(cmap_name)

# Dibujar el grafo con colores según las comunidades y la paleta de colores

plasma
pos = nx.spring_layout(G)
colors = [cmap(i / len(G.nodes())) for i in range(len(G.nodes()))]
nx.draw(G, pos, node_color=colors, with_labels=True, node_size=700)

# Mostrar el gráfico
plt.show()

# Imprimir las comunidades detectadas

print("Comunidades detectadas:")
for i, community in enumerate(communities):
print(f"Comunidad {i + 1}: {list(community)}")
 Red de Coordinador:

Definición: Estructura en la que un nodo central (coordinador) se conecta con

todos los demás nodos en la red.
Ejemplo Práctico: Una red de comunicación en una organización donde un líder
central coordina y se comunica directamente con todos los miembros del equipo.
import networkx as nx
import matplotlib.pyplot as plt

# Crear un grafo dirigido

G = nx.DiGraph()

# Agregar nodos
G.add_nodes_from(range(1, 6))

# Conectar el coordinador (nodo 1)

con todos los demás nodos
coordinator = 1
nodes_except_coordinator =
list(range(2, 6))

G.add_edges_from((coordinator, node) for node in nodes_except_coordinator)

# Dibujar el grafo
pos = nx.spring_layout(G)
nx.draw(G, pos, with_labels=True, node_size=800, node_color='lightblue',
font_weight='bold', font_size=10, font_color='black', edge_color='gray')

# Resaltar el coordinador
nx.draw_networkx_nodes(G, pos, nodelist=[coordinator], node_color='red',
node_size=800)

# Mostrar el gráfico
plt.show()

Red de Gatekeeper:

Definición: Estructura en la que un nodo específico (gatekeeper) conecta

diferentes partes de la red.
Ejemplo Práctico: En una red de contactos profesionales, un individuo clave puede
actuar como un "gatekeeper", facilitando conexiones entre personas de diferentes
sectores.

import networkx as nx
import matplotlib.pyplot as plt

# Crear un grafo no dirigido

G = nx.Graph()

# Definir nodos y conexiones

nodes_and_edges = [(1, 2), (1, 3), (1, 4),
(1, 5), (2, 3), (3, 4), (4, 5)]

# Agregar nodos y conexiones al grafo

G.add_edges_from(nodes_and_edges)

# Definir el gatekeeper (nodo 1)

gatekeeper = 1

# Dibujar el grafo
pos = nx.spring_layout(G)
nx.draw(G, pos, with_labels=True, node_size=800, node_color='lightblue',
font_weight='bold', font_size=10, font_color='black', edge_color='gray')

# Resaltar el gatekeeper
nx.draw_networkx_nodes(G, pos, nodelist=[gatekeeper], node_color='red',
node_size=800)
# Mostrar el gráfico
plt.show()

Red de Team Player:

Definición: Estructura en la que todos los nodos están conectados entre sí,
promoviendo la colaboración y la interconexión.
Ejemplo Práctico: Una red social en la que todos los usuarios pueden interactuar
directamente entre sí, fomentando la colaboración y el intercambio de información.

import networkx as nx
import matplotlib.pyplot as plt

# Crear un grafo no dirigido

G = nx.Graph()

# Definir nodos
nodes = range(1, 6)

# Agregar nodos al grafo

G.add_nodes_from(nodes)

# Conectar todos los nodos entre sí (team player)

edges = [(i, j) for i in nodes for j in nodes if i != j]
G.add_edges_from(edges)

# Dibujar el grafo
pos = nx.spring_layout(G)
nx.draw(G, pos, with_labels=True, node_size=800, node_color='lightblue',
font_weight='bold', font_size=10, font_color='black', edge_color='gray')

# Mostrar el gráfico
plt.show()
Red de Dual Group Member:

Definición: Estructura en la que los nodos están divididos en dos grupos y cada
nodo pertenece a ambos grupos.
Ejemplo Práctico: En una red de investigación, donde algunos científicos trabajan
tanto en la teoría (Group_A) como en la aplicación práctica (Group_B) de un
proyecto.

import networkx as nx
import matplotlib.pyplot as plt

# Crear un grafo no dirigido

G = nx.Graph()

# Definir nodos y sus respectivos

grupos
nodes_and_groups = {
1: 'Group_A',
2: 'Group_A',
3: 'Group_A',
4: 'Common_Node',
5: 'Group_B',
6: 'Group_B',
7: 'Group_B',
}

# Agregar nodos y atributos al grafo

for node, group in nodes_and_groups.items():
G.add_node(node, group=group)

# Conectar nodos según la estructura deseada

edges = [(1, 2), (2, 3), (3, 1), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4,
7), (7, 6), (6, 5), (5, 7)]
G.add_edges_from(edges)

# Dibujar el grafo
pos = nx.spring_layout(G)
nx.draw(G, pos, with_labels=True, node_size=800, font_weight='bold',
font_size=10, font_color='black', edge_color='gray')

# Mostrar el gráfico
plt.show()
Red de Superconector:

Definición: Estructura en la que un nodo (superconector) tiene un número

significativamente mayor de conexiones en comparación con otros nodos en la
red.
Ejemplo Práctico: En una red de internet, un servidor central que maneja y
distribuye datos a muchos usuarios puede actuar como un "superconector".

import networkx as nx
import matplotlib.pyplot as plt

# Crear un grafo no dirigido

G = nx.Graph()

# Definir nodos
nodes = range(1, 11)

# Agregar nodos al grafo

G.add_nodes_from(nodes)

# Conectar nodos formando una

estructura de estrella con el nodo 1 como superconector
edges = [(1, i) for i in range(2, 11)]
G.add_edges_from(edges)

# Dibujar el grafo
pos = nx.spring_layout(G)
nx.draw(G, pos, with_labels=True, node_size=800, font_weight='bold',
font_size=10, font_color='black', edge_color='gray')

# Resaltar el superconector (nodo 1)

nx.draw_networkx_nodes(G, pos, nodelist=[1], node_color='red',
node_size=800)

# Mostrar el gráfico
plt.show()
 CONCLUSIÓN
N.C.A.P.
R.O.V.
H.T.J.C
En conclusión, la detección de comunidades en redes y grafos es una disciplina
valiosa que proporciona herramientas para analizar la estructura interna de redes
complejas. Al identificar grupos densamente interconectados de nodos, esta área
de estudio permite revelar patrones organizativos y relaciones específicas dentro
de una red.
En resumen, la detección de comunidades no solo brinda una comprensión
profunda de la topología de las redes, sino que también tiene aplicaciones
prácticas en diversos campos, contribuyendo significativamente a la toma de
decisiones informada y la optimización de recursos.