Red bipartita de usuarios y palabras

In [1]:

    

# Librerías necesarias para correr el proyecto
import networkx as nx
from networkx.algorithms import bipartite
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
import operator
import community
from scipy.stats import powerlaw
%matplotlib inline
sns.set()


    

In [2]:

    

"""
En el arreglo all_edges se guardan los enlaces de la red con pesos. El arreglo all_edges_aux sirve para contar 
el número de veces que aparece un enlace y así agregarlo como peso del enlace en all_edges
"""
all_edges = []
all_edges_aux = []
# Archivo de texto que contiene los enlaces de la red (se encuenta en la carpeta del proyecto)
with open('edges_file_total_network_weights_undirected.txt', encoding="utf8") as f:
    next(f)
    for line in f:
        edge = line.replace('\n', '').split('\t')
        # Condicional para validar si ya existe un enlace y agregarlo como peso
        if (edge[0], edge[1]) in all_edges_aux:
            edge_index = all_edges_aux.index((edge[0], edge[1]))
            # Se suma 1 al peso anterioir que tenía el enlace
            all_edges[edge_index] = (edge[0], edge[1], all_edges[edge_index][2] + 1)
        else:
            # Se agrega el nuevo enlace al auxiliar y al original. En el arreglo original de enlaces se inicia
            # con un peso de 1
            all_edges.append((edge[0], edge[1],1))
            all_edges_aux.append((edge[0], edge[1]))

# Total de enlaces de la red
total_count_edges = len(all_edges)

# Arreglos para almacenar nodos
all_nodes = set()
users_nodes = set()
words_nodes = set()

# Proceso para obtener los nodos de la red
for x,y,w in all_edges:
    users_nodes.add(x)
    words_nodes.add(y)
    all_nodes.add(x)
    all_nodes.add(y)
 
print("El tamaño de la red está definido por los siguientes valores:")
print("Total de enlaces:", len(all_edges))
print("Total de nodos:", len(all_nodes))
print("Total de nodos usuario:", len(users_nodes))
print("Total de nodos de palabras:", len(words_nodes))


    

    




El tamaño de la red está definido por los siguientes valores:
Total de enlaces: 25713
Total de nodos: 13574
Total de nodos usuario: 2947
Total de nodos de palabras: 10627

In [3]:

    

# Sets para guardar los enlaces de la proyección de usuarios y palabras respectivamente
projection_users = set()
projection_words = set()
# Proyección de usuarios
# Se recorren todos los nodos de palabras para sacar los usuarios que las usan
for word in words_nodes:
    possible_nodes = set()
    # Si la palabra está en un enlace se agrega el usuario que la usó en un set de posibles nodos
    for edge in all_edges:
        if word in edge:
            possible_nodes.add(edge[0])
    # Se recorren los posibles nodos obtenidos anteriormente, se valida que no existan los enlaces y se agregan
    for node1 in possible_nodes:
        for node2 in possible_nodes:
            if (node1, node2) not in projection_users and (node2, node1) not in projection_users:
                projection_users.add((node1, node2)) if (node1 != node2) else 0

# Proyección de palabras
# Se recorren todos los nodos de usuarios para sacar las palabras que usan
for user in users_nodes:
    possible_nodes = set()
    # Si el usuario está en un enlace se agrega la palabra que usó en un set de posibles nodos
    for edge in all_edges:
        if user in edge:
            possible_nodes.add(edge[1])
    # Se recorren las posibles palabras, se valida que no existan los enlaces y se argegan
    for node1 in possible_nodes:
        for node2 in possible_nodes:
            if (node1, node2) not in projection_words and (node2, node1) not in projection_words:
                projection_words.add((node1, node2)) if (node1 != node2) else 0
                
# Resultado de las proyecciones
print("Proyeccion usuarios total enlaces:",len(projection_users))
print("Proyeccion palabras total enlaces:",len(projection_words))


    

    




Proyeccion usuarios total enlaces: 211366
Proyeccion palabras total enlaces: 295277

In [4]:

    

# Se crea el grafo bipartito con NetworkX
tweets_users_words_graph = nx.Graph()
# Se agregan los nodos para ambas particiones, es decir, usuarios y palabras
# Para esto es necesario importar el módulo bipartite de NetworkX
tweets_users_words_graph.add_nodes_from(users_nodes, bipartite=0)
tweets_users_words_graph.add_nodes_from(words_nodes, bipartite=1)
# Se agregan los enlaces obtenidos anteriormente con sus respectivos pesos
tweets_users_words_graph.add_weighted_edges_from(all_edges)

# Función usada para sumar los pesos de la red bipartita en las proyecciones.
# Esta función es enviada en los parametros del metodo generic_weighted_projected_graph del módulo bipartite
# Tomada de la documentación: 
# https://networkx.github.io/documentation/networkx-1.10/reference/generated/networkx.algorithms.bipartite.projection.generic_weighted_projected_graph.html
def my_weight(G, u, v, weight='weight'):
    w = 0
    for nbr in set(G[u]) & set(G[v]):
        w += G.edge[u][nbr].get(weight, 1) + G.edge[v][nbr].get(weight, 1)
    return w

# Se hallan las proyecciones de usuarios y palabras
projected_graph_users = bipartite.generic_weighted_projected_graph(tweets_users_words_graph, users_nodes, weight_function=my_weight)
projected_graph_words = bipartite.generic_weighted_projected_graph(tweets_users_words_graph, words_nodes, weight_function=my_weight)

# Resultados de las proyecciones. Se imprimen los primeros 10 enlaces de cada proyeccion para validar que tengan
# los pesos. Se imprimen también el número de enlaces de cada proyección para validar con el punto anterior. 
print("Proyección grafo usuarios total enlaces:",projected_graph_users.edges(data=True)[0:10])
print()
print("Proyección grafo palabras total enlaces:",projected_graph_words.edges(data=True)[0:10])
print()
print("Proyección grafo usuarios total enlaces:",len(projected_graph_users.edges()))
print()
print("Proyección grafo palabras total enlaces:",len(projected_graph_words.edges()))


    

    




Proyección grafo usuarios total enlaces: [('310242050', '377598815', {'weight': 3}), ('310242050', '201515412', {'weight': 3}), ('310242050', '242943297', {'weight': 2}), ('310242050', '322203077', {'weight': 5}), ('310242050', '297037057', {'weight': 2}), ('310242050', '3797275876', {'weight': 4}), ('310242050', '1398768416', {'weight': 3}), ('310242050', '331365183', {'weight': 3}), ('310242050', '169543344', {'weight': 3}), ('310242050', '1587221360', {'weight': 5})]

Proyección grafo palabras total enlaces: [('roa', 'saludo', {'weight': 2}), ('corrupto', 'niño', {'weight': 2}), ('corrupto', 'animal', {'weight': 3}), ('corrupto', 'país', {'weight': 2}), ('corrupto', 'oración', {'weight': 2}), ('corrupto', 'parábolas', {'weight': 2}), ('corrupto', 'espíritu', {'weight': 5}), ('corrupto', 'aarón', {'weight': 2}), ('corrupto', 'incrédulo', {'weight': 2}), ('corrupto', 'gente', {'weight': 2})]

Proyección grafo usuarios total enlaces: 211366

Proyección grafo palabras total enlaces: 295277

In [5]:

    

# Gráfica de la distribución de grados en python
degrees_tweets_users_words_graph = list(tweets_users_words_graph.degree().values())
sns.distplot(degrees_tweets_users_words_graph)


    

    
Out[5]:





<matplotlib.axes._subplots.AxesSubplot at 0x7fb23cc75ac8>






    

In [6]:

    

degrees_projected_graph_users = list(projected_graph_users.degree().values())
degrees_projected_graph_users = np.array(degrees_projected_graph_users)
degrees_projected_graph_users = degrees_projected_graph_users[np.nonzero(degrees_projected_graph_users)]
sns.distplot(degrees_projected_graph_users)


    

    
Out[6]:





<matplotlib.axes._subplots.AxesSubplot at 0x7fb235ae1eb8>






    

In [7]:

    

degrees_projected_graph_words = list(projected_graph_words.degree().values())
degrees_projected_graph_words = np.array(degrees_projected_graph_words)
degrees_projected_graph_words = degrees_projected_graph_words[np.nonzero(degrees_projected_graph_words)]
sns.distplot(degrees_projected_graph_words)


    

    
Out[7]:





<matplotlib.axes._subplots.AxesSubplot at 0x7fb236ee5080>






    

In [8]:

    

logs_tweets_users_words_graph = np.log(degrees_tweets_users_words_graph)
plt.hist(logs_tweets_users_words_graph, log=True)

e, l, s = powerlaw.fit(degrees_tweets_users_words_graph)
e, l, s


    

    
Out[8]:





(0.21386388445702345, 0.99999999999999989, 334.61121911679282)






    

In [9]:

    

logs_projected_graph_users = np.log(degrees_projected_graph_users)
plt.hist(logs_projected_graph_users, log=True)

e_users, l_users, s_users = powerlaw.fit(degrees_projected_graph_users)
e_users, l_users, s_users


    

    
Out[9]:





(0.27320087878796206, 0.99999999999999978, 1165.5626476640819)






    

In [10]:

    

logs_projected_graph_words = np.log(degrees_projected_graph_words)
plt.hist(logs_projected_graph_words, log=True)

e_words, l_words, s_words = powerlaw.fit(degrees_projected_graph_words)
e_words, l_words, s_words


    

    
Out[10]:





(0.43093627551583291, 0.99999999999999989, 3257.1023645504861)






    

In [11]:

    

# Código para hallar el componente gigante de la red de usuarios y palabras
tweets_users_words_components = sorted(nx.connected_component_subgraphs(tweets_users_words_graph), key = len, reverse=True)
giant_component = tweets_users_words_components[0]
giant_component_edges = giant_component.edges()
print("Nodos del componente gigante de la red de usuarios y palabras:", len(giant_component.nodes()))
print("Enlaces del componente gigante de la red de usuarios y palabras:", len(giant_component_edges))
print()

# Código para hallar el componente gigante de la red de usuarios
projected_graph_users_components = sorted(nx.connected_component_subgraphs(projected_graph_users), key = len, reverse=True)
giant_component_users = projected_graph_users_components[0]
giant_component_users_edges = giant_component_users.edges()
print("Nodos del componente gigante de la red de usuarios:", len(giant_component_users.nodes()))
print("Enlaces del componente gigante de la red de usuarios:", len(giant_component_users_edges))
print()

# Código para hallar el componente gigante de la red de palabras
projected_graph_words_components = sorted(nx.connected_component_subgraphs(projected_graph_words), key = len, reverse=True)
giant_component_words = projected_graph_words_components[0]
giant_component_words_edges = giant_component_words.edges()
print("Nodos del componente gigante de la red de usuarios:", len(giant_component_words.nodes()))
print("Enlaces del componente gigante de la red de palabras:", len(giant_component_words_edges))

# Este fragmento de código comentado fue usado para el proceso de limpieza, ordenando las palabras por grado

# degrees_giant_component_words = sorted(giant_component_words.degree().items(), key=operator.itemgetter(1), reverse=True)
# words_file = open("palabras_ordenadas_por_grado.txt", 'w', encoding="utf8")
# for k in degrees_giant_component_words:
#     print(k, file=words_file)


    

    




Nodos del componente gigante de la red de usuarios y palabras: 13204
Enlaces del componente gigante de la red de usuarios y palabras: 25477

Nodos del componente gigante de la red de usuarios: 2812
Enlaces del componente gigante de la red de usuarios: 211365

Nodos del componente gigante de la red de usuarios: 10392
Enlaces del componente gigante de la red de palabras: 295093

In [12]:

    

avg_clustering_tweets_users_words_graph = nx.average_clustering(tweets_users_words_graph)
print("Promedio del coeficiente de clustering de la red de usuarios y palabras:", avg_clustering_tweets_users_words_graph)

avg_clustering_projected_graph_users = nx.average_clustering(projected_graph_users)
print("Promedio del coeficiente de clustering de la red de usuarios:", avg_clustering_projected_graph_users)
N_users = len(projected_graph_users.nodes())
edges_user = projected_graph_users.edges()
p_users = (2*len(edges_user))/(N_users*(N_users-1))
random_graph_users = nx.gnp_random_graph(N_users,p_users)
avg_clustering_random_graph_users = nx.average_clustering(random_graph_users)
print("Promedio del coeficiente de clustering de la red aleatoria de usuarios:", avg_clustering_random_graph_users)

avg_clustering_projected_graph_words = nx.average_clustering(projected_graph_words)
print("Promedio del coeficiente de clustering de la red de palabras:", avg_clustering_projected_graph_words)
N_words = len(projected_graph_words.nodes())
edges_words = projected_graph_words.edges()
p_words = (2*len(edges_words))/(N_words*(N_words-1))
random_graph_words = nx.gnp_random_graph(N_words,p_words)
avg_clustering_random_graph_words = nx.average_clustering(random_graph_words)
print("Promedio del coeficiente de clustering de la red aleatoria de palabras:", avg_clustering_random_graph_words)


    

    




Promedio del coeficiente de clustering de la red de usuarios y palabras: 0.0
Promedio del coeficiente de clustering de la red de usuarios: 0.5791451045123506
Promedio del coeficiente de clustering de la red aleatoria de usuarios: 0.048741978424151074
Promedio del coeficiente de clustering de la red de palabras: 0.8373544832061259
Promedio del coeficiente de clustering de la red aleatoria de palabras: 0.005197855908852333

In [13]:

    

def export_network_file(network_edges, file_name):
    network_edges_file = open(file_name, 'w')
    print('Source\tTarget\tType', file=network_edges_file)
    for k, v in sorted(network_edges):
        print(k+'\t'+v+'\tUndirected', file=network_edges_file)

# export_network_file(giant_component_users_edges, 'giant_component_users_weights_edges_file.txt')
# export_network_file(giant_component_words_edges, 'giant_component_words_weights_edges_file.txt')


    

In [14]:

    

def export_to_gephi(G, file_name):
    nx.write_gexf(G, file_name)
# export_to_gephi(giant_component, "giant_component_gephi.gexf")
# export_to_gephi(giant_component_words, "giant_component_words_gephi.gexf")
# export_to_gephi(giant_component_users, "giant_component_users_gephi.gexf")


    

In [15]:

    

# Código para hallar las comunidades usando NetworkX y el módulo community
partition = community.best_partition(giant_component_words)
# Se agregan las comunidades escogidas como atributos de los nodos
# Esto se hace con el fin de pintar las comunidades obtenidas con NetworkX en Gephi
nx.set_node_attributes(giant_component_words, 'louvain', partition)

# El código que está comentado a continuación exporta el archivo con las comunidades obtenidas
# export_to_gephi(giant_component_words, "giant_component_words_gephi_louvain.gexf")