Análisis de Social Media con Redes Complejas: Guía Técnica 2025

# 🔧 EJEMPLO PRÁCTICO: Construcción de red desde Twitter API
# Este código toma tweets y los convierte en una red social analizable

import networkx as nx  # Librería para crear y analizar redes
import pandas as pd
from collections import defaultdict

def build_network_from_tweets(tweets_data):
    """
    Convierte tweets en una red social (grafo)
    tweets_data = lista de tweets que sacaste de Twitter API
    """
    G = nx.DiGraph()  # DiGraph = Red DIRIGIDA (las flechas tienen dirección)

    for tweet in tweets_data:
        user_id = tweet['author_id']  # ID del usuario que twitteó

        # PASO 1: Agregar cada usuario como un "nodo" (punto en la red)
        G.add_node(user_id,
                  followers=tweet.get('public_metrics', {}).get('followers_count', 0),
                  verified=tweet.get('verified', False))

        # PASO 2: Agregar conexiones (aristas) entre usuarios
        # Si alguien respondió a otro usuario
        if tweet.get('in_reply_to_user_id'):
            G.add_edge(user_id, tweet['in_reply_to_user_id'],
                      weight=1,      # weight = importancia de la conexión
                      type='reply')  # tipo de interacción

        # PASO 3: Procesar menciones (@usuario) en el texto del tweet
        mentions = extract_mentions(tweet['text'])
        for mention in mentions:
            G.add_edge(user_id, mention,
                      weight=0.5,       # las menciones pesan menos que replies
                      type='mention')

    return G  # Devuelve el grafo completo listo para analizar

# Cálculo de métricas de centralidad
def calculate_centrality_metrics(G):
    """
    Calcula las 4 métricas principales de centralidad
    G = tu red social (grafo de NetworkX)
    """
    metrics = {}

    # 1. Centralidad de grado: ¿Quién conoce más gente?
    metrics['degree'] = nx.degree_centrality(G)

    # 2. Betweenness: ¿Quién conecta grupos diferentes?
    # k=1000 significa "usa solo 1000 nodos para calcular más rápido"
    # (en redes grandes esto ahorra MUCHO tiempo)
    metrics['betweenness'] = nx.betweenness_centrality(G, k=1000)

    # 3. Closeness: ¿Quién puede llegar rápido a todos?
    metrics['closeness'] = nx.closeness_centrality(G)

    # 4. PageRank: ¿Quién tiene conexiones influyentes?
    # alpha=0.85 es el valor estándar que usa Google
    # (85% sigue links, 15% salta random)
    metrics['eigenvector'] = nx.pagerank(G, alpha=0.85)

    return metrics

# Identificar top influencers combinando métricas
def identify_top_influencers(G, metrics, top_n=50):
    """
    Encuentra los 50 usuarios más influyentes
    Combina todas las métricas para una visión completa
    """
    influencers = defaultdict(dict)

    # Para cada métrica, guarda los top 50 usuarios
    for metric_name, metric_values in metrics.items():
        sorted_users = sorted(metric_values.items(),
                            key=lambda x: x[1], reverse=True)[:top_n]

        for user_id, score in sorted_users:
            influencers[user_id][metric_name] = score

    return influencers

# EJEMPLO DE OUTPUT:
# influencers = {
#     'user_12345': {
#         'degree': 0.85,      # Muy conectado
#         'betweenness': 0.12, # Conecta grupos
#         'closeness': 0.67,   # Alcance rápido
#         'eigenvector': 0.92  # Conexiones VIP
#     }
# }

# 🔍 DETECCIÓN DE COMUNIDADES: Encuentra "tribus" en tu red social
# Imagina que quieres saber qué grupos de personas hablan entre ellas

import community as louvain_community
from networkx.algorithms import community as nx_community

def detect_communities(G):
    """
    Encuentra grupos de usuarios que interactúan mucho entre sí
    G = tu red social (grafo)
    Retorna: las comunidades detectadas
    """

    # PASO 1: Convertir a grafo no dirigido
    # (Louvain no funciona con direcciones, solo conexiones)
    G_undirected = G.to_undirected()

    # PASO 2: Usar algoritmo Louvain
    # Es el más rápido y funciona bien en redes grandes
    louvain_partition = louvain_community.best_partition(G_undirected)

    # OPCIONAL: Algoritmo Leiden (más preciso pero más lento)
    # leiden_partition = leiden_algorithm(G_undirected)

    # PASO 3: Medir qué tan buena es la división en comunidades
    # Modularidad alta (>0.3) = comunidades bien definidas
    modularity = louvain_community.modularity(louvain_partition, G_undirected)

    # PASO 4: Organizar usuarios por comunidad
    communities = defaultdict(list)
    for node, comm_id in louvain_partition.items():
        communities[comm_id].append(node)  # Agrupa usuarios por comunidad

    # Muestra estadísticas útiles
    print(f"📊 Modularidad: {modularity:.3f} (>0.3 es bueno)")
    print(f"👥 Número de comunidades detectadas: {len(communities)}")

    return louvain_partition, communities

# EJEMPLO DE USO:
# partition, communities = detect_communities(mi_red_twitter)
# → Resultado: "Encontré 8 comunidades: gamers, fitness, tech, etc"

# 🚀 SIMULACIÓN DE VIRALIDAD: Predice cómo se propagará tu contenido
# ¿Qué pasa si publicas desde estos 3 influencers? ¿Llegará a 10,000 personas?

import random

def simulate_information_cascade(G, seed_nodes, activation_prob=0.1, steps=10):
    """
    Simula cómo se propaga un mensaje en la red (como un virus)

    Parámetros:
    - G: tu red social
    - seed_nodes: usuarios iniciales que comparten el contenido (ej: influencers)
    - activation_prob: probabilidad base de que alguien comparta (0.1 = 10%)
    - steps: cuántas "rondas" de propagación simular

    Retorna: estadísticas de propagación paso a paso
    """

    # PASO 1: Empezar con los usuarios semilla
    active_nodes = set(seed_nodes)      # Usuarios que ya compartieron
    newly_activated = set(seed_nodes)   # Nuevos en esta ronda
    cascade_steps = []                  # Guardamos estadísticas

    # PASO 2: Simular cada ronda de propagación
    for step in range(steps):
        next_activated = set()  # Quiénes se activarán en esta ronda

        # Por cada usuario que acaba de compartir
        for active_node in newly_activated:
            # Revisar a quién puede influenciar
            for neighbor in G.neighbors(active_node):
                if neighbor not in active_nodes:  # Si aún no ha compartido

                    # CALCULAR probabilidad de que comparta
                    edge_weight = G[active_node][neighbor].get('weight', 1)
                    neighbor_centrality = G.nodes[neighbor].get('centrality_score', 0.1)

                    # Fórmula: prob_base × peso_relación × (1 + influencia_usuario)
                    activation_chance = activation_prob * edge_weight * (1 + neighbor_centrality)

                    # "Lanzar la moneda": ¿compartirá o no?
                    if random.random() < activation_chance:
                        next_activated.add(neighbor)

        # PASO 3: Actualizar usuarios activos
        active_nodes.update(next_activated)
        newly_activated = next_activated

        # PASO 4: Guardar estadísticas de esta ronda
        cascade_steps.append({
            'step': step + 1,
            'new_activations': len(next_activated),      # Nuevos en esta ronda
            'total_active': len(active_nodes),           # Total acumulado
            'reach_percentage': len(active_nodes) / len(G) * 100  # % de la red
        })

        # Si nadie más compartió, terminar la simulación
        if len(next_activated) == 0:
            break

    return cascade_steps, active_nodes

# EJEMPLO DE USO:
# steps, users = simulate_information_cascade(
#     mi_red,
#     seed_nodes=['influencer1', 'influencer2'],
#     activation_prob=0.15
# )
# → Resultado: "Llegó a 12,450 usuarios en 6 pasos (34% de la red)"