Teoria de Grafos y Situaciones para Internet

Teoría de grafos para situaciones reales en las redes sociales
Cevallos Mamani Cynthia Vanessa, Guevara López Lorena, Huaman cerna
Raged Alexander, Marcelo Toribio Jhonatan Raul, Onofre Espinar Jhanluck
Andres.
Julio 2019
Universidad Mayor de San Marcos.
Facultad de Ingeniería de Sistemas.
Matemática Discreta.
1
Dedicatoria
Este trabajo hecho en conjunto está dedicado a todos nuestros compañeros de la facultad de
Ingeniería d Sistemas que se esfuerzan día a día por lograr sus objetivos y cumplir sus sueños.
También se lo dedicamos a aquellos docentes que nos brindan paciencia al explicarnos las dudas
que poseemos y al saciar nuestra sed de conocimiento.
2
Agradecimientos
Agradecemos a Dios por bendecirnos la vida, por guiarnos a lo largo de nuestra existencia, ser
el apoyo y fortaleza en aquellos momentos de dificultad y de debilidad.
A nuestro profesor Román Concha, Norberto que nos motivó a realizar este trabajo el cual nos
llena de orgullo.
A las personas que nos apoyaron directa e indirectamente, como lo son nuestros padres por el
inmenso amor que nos brindan, nuestros hermanos por estar siempre presentes y demás familiares
por su apoyo moral.
3
Resumen
Las relaciones y las redes sociales son un componente clave en la vida de los seres humanos, el
cual siempre se vio limitado temporal y espacialmente.
En la actualidad, con la emergencia de Internet, las redes han evolucionado, permitiendo a las
personas organizarse en las, a partir de ahora llamadas, redes sociales virtuales. Estas divergen de
las redes sociales convencionales en la utilización de tecnologías para facilitar la comunicación.
Las redes sociales virtuales permiten a las personas acceder y compartir información sobre
diferentes áreas de interés, realizar publicaciones implicando a uno o más individuos, iniciar
conversaciones y muchas otras diversas funcionalidades. Todas ellas tienen como fin vincular a
las personas.
De esta evolución en la forma de socializar de los seres humanos se desprende el objetivo del
presente trabajo. Realizar un análisis sobre los diferentes individuos involucrados dentro de una
red social virtual, los roles que estos representan y las relaciones entre cada uno de ellos. Para ello,
se identifican los distintos tipos de redes que existen y sus características, los diferentes métodos
de análisis de redes sociales y las formas de representarlas gráficamente.
Tanto la información en común entre los usuarios como el grafo que representa la red,
constituyen una herramienta que permite obtener resultados sobre los comportamientos y
preferencias de las personas, otorgándole flexibilidad a quien lleva a cabo el análisis para poder
alterar las ponderaciones de las variables con el fin de obtener resultados precisos acotados a su
búsqueda.
4
Índice
Resumen.............................................................................................................................. 1
1. Introducción ............................................................................................................ 3
2. Redes sociales ........................................................Error! Bookmark not defined.
2.1. Concepto y finalidad. ......................................Error! Bookmark not defined.
2.2. Desarrollo ........................................................Error! Bookmark not defined.
3. Metodos..................................................................Error! Bookmark not defined.
3.1.Metodo Socio-céntrico .....................................Error! Bookmark not defined.
3.2.Metodo Ego-céntrico .......................................Error! Bookmark not defined.
3.3.Aplicación del metodo .....................................Error! Bookmark not defined.
4. Discusión y resultados ...........................................Error! Bookmark not defined.
5. Concluciones ..........................................................Error! Bookmark not defined.
6. Bibliografia ............................................................Error! Bookmark not defined.
5
indice de figuras
6
1. Introducción
El objetivo del presente trabajo consiste en realizar un análisis sobre los diferentes
individuos involucrados dentro de una red social virtual, los roles que estos representan y
las relaciones entre cada uno de ellos y proveer un prototipo de una herramienta para
facilitar el estudio de una red social acotada.
El presente escrito cuenta con una serie de secciones teóricas, es decir, que sirven de
marco teórico que servirá luego para el desarrollo de la herramienta, y una serie de
secciones aplicadas al desarrollo mismo del prototipo.
A continuación, se detalla brevemente qué se ofrece en cada una de las secciones
teóricas. El apartado “Análisis de Redes Sociales” explica los dos métodos principales para
el estudio de las redes, el Ego-céntrico y el
Socio-céntrico. Mediante la teoría de grafos y usando las herramientas que nos brindan los
lenguajes de programación como Python y Java buscamos realizar un código que explica
el funcionamiento que se tiene en una red social cuando se implementa mediante grafos.
Una vez finalizadas las secciones teóricas, se presentan una serie de secciones aplicadas
al desarrollo del prototipo. La primera sección es “Análisis del prototipo”, la cual enumera
las variables que se tendrán en cuenta y procedimiento mediante el cual estas se analizarán.
Una vez finalizado el análisis, se procede a la implementación, detallada en
“Implementación del prototipo”, donde se expresan una serie de aclaraciones sobre la
herramienta, las tecnologías utilizadas y diagramas que representan la estructura de la
aplicación y los distintos casos de uso existentes.
1
2. Redes sociales
2.1.Concepto y finalidad
A lo largo de la historia de las redes sociales ha sido definida de manera diferente
por muchos autores conocidos como son Hagel y Armstrong, Romm, Etzioni, Lazar
JR, Preece J, etc. Mediante sus definiciones según sus perspectivas hemos sacado
nuestras propias conclusiones.
Una red social la podemos definir como un medio en el cual se enlazan personas
u organizaciones mediante la comunicación e interacciones. En estos sitios de
internet se tiene la oportunidad de relacionarse con individuos que poseen intereses
o actividades en común (como amistad, parentesco, trabajo) y que permiten el
contacto entre estos, de manera que se puedan intercambiar información.
La finalidad principal de este medio es permitir a los usuarios enlazarse,
contactarse, compartir datos y crear comunidades que posean algún gusto en
común.
2.2.Desarrollo
Las redes sociales se han visto desde inicios del hombre siendo ésta muy amplia,
por eso nos centraremos en lo que es una red social virtual. El problema que se ha
visto en el pasado, es la transmisión de menajes a largas distancias, por ejemplo, en
el Perú existían los chasquis para transmitir los menajes de una cultura a otra, pero
2
luego con el desarrollo de la tecnología esto ha ido cambiando haciendo más fácil
la comunicación entre personas.
La manera de comunicación e interactuar con las personas ha ido evolucionando,
primero con el uso del fax, teléfonos, hasta que el internet estuvo al alcance de todas
las personas, mediante este medio se comenzó a usar las redes sociales que nos
permitieron una comunicación con nuestros allegados de manera rápida, segura y
muy cómoda.
3. Métodos
El objetivo de los métodos para recolectar información de las redes sociales virtuales es
proveer un conjunto de datos que permita analizar los efectos que la red tiene en los
diferentes aspectos de las actividades sociales tanto en los individuos como en su
interacción.
Los principales métodos utilizados para recolectar son el Socio-céntrico y el
Egocéntrico.
3.1.Método Socio-céntrico
El método Socio-céntricos analiza las relaciones entre los actores y permite
estudiar la estructura de la red social en sí. La colección de datos consiste en tres
etapas. La primera etapa consiste en analizar las relaciones entre cada uno de los
actores de la Red Social Virtual. Los tipos de relaciones deben ser analizados
teniendo en consideración la naturaleza de los vínculos, en particular, en referencia
a:
3
• Fuerza: frecuencia, duración y estabilidad de la relación en el tiempo.
• Confirmación: grado en el cual el actor replica la misma relación con otros,
en un área de contenido específica.
• Multiplicidad: grado en el cual un actor tiene diferentes roles en la Red
Social Virtual.
Figura 1: método de análisis Socio-céntrico
El segundo paso determina la existencia de subgrupos y si ciertos roles tienen
impacto dentro de la Red Social Virtual. Finalmente, el tercer paso consiste en
analizar las características generales de la red, datos como el tamaño y la densidad,
es decir, la cantidad de relaciones dentro de la red.
Estas etapas requieren que cada individuo responda una serie de preguntas
sobre cada actor de la red, cuyas respuestas se cuantifican y se transforman en un
conjunto de matrices (Figura 19).
4
Figura 2: Matriz utilizada para el análisis Socio-céntrico
La matriz está compuesta por filas y columnas que representan a todos los actores
de la red. Cada celda representa la respuesta dada por el primer actor sobre el
segundo actor. Este tipo de encuestas se realizan sobre grupos de 20 a 50 personas,
y permiten a los investigadores analizar cuán bien se conocen los actores dentro de
una red.
Sin embargo, cuando los grupos son grandes, el método Socio-céntrico tiene un
valor limitado debido a las limitaciones del software y el poder de procesamiento.
3.2.Método Ego-céntrico
El método Ego-céntrico se basa en los individuos y no en la red como un todo.
Esto permite seleccionar actores específicos e identificar con qué nodos se
conectan.
5
Figura 3: Método de análisis Ego-céntrico
El comienzo de este método consiste en identificar un actor y sus conexiones con
el resto de los nodos dentro de la red. El número de relaciones establece cuán central
es el actor dentro de la red social. Un número alto de relaciones establece que el
actor tiene un rol fundamental dentro de la red social virtual; por el contrario, si
este número es bajo, significa que este actor no es principal dentro de la red y, por
consiguiente, probablemente no tenga un rol relevante dentro de la misma.
3.3.Aplicación del método
3.3.1. Cómo analizar a sus amigos de la red Facebook con R
Para utilizar RFacebook, primero tiene que registrarse para obtener una
cuenta de desarrollador de Facebook, que es rápido y fácil, siempre y cuando
usted ya tiene un perfil en Facebook. JulianHi ofrece un excelente tutorial paso
a paso sobre cómo empezar con RFacebook, incluyendo la configuración de la
aplicación de Facebook y generar el token authentition que será necesaria para
el uso de las funciones RFacebook.
6
Una vez que estés autenticado, puede utilizar las funciones RFacebook para
consultar su lista de amigos y obtener información acerca de sus amigos (y sus
conexiones con sus otros amigos). He utilizado el código de abajo para
consultar mis amigos de Facebook, y utilicé el paquete igraph dibujar mi red
social:
require(Rfacebook)
load("fb_oauth.Rd") ## load my previously saved
authentication token
me <- getUsers("me", token=fb_oauth)

my_friends <- getFriends(token=fb_oauth, simplify=TRUE)
my_friends_info <- getUsers(my_friends$id, token=fb_oauth,
private_info=TRUE)
my_network <- getNetwork(fb_oauth, format="adj.matrix")
singletons <- rowSums(my_network)==0 # friends who are
friends with me alone
require(igraph)
my_graph <-
graph.adjacency(my_network[!singletons,!singletons])
layout <-
layout.drl(my_graph,options=list(simmer.attraction=0))
plot(my_graph, vertex.size=2,
#vertex.label=NA,
vertex.label.cex=0.5,
edge.arrow.size=0, edge.curved=TRUE,layout=layout)
Figure 4: Programa R
Quité los únicos de la tabla de abajo para que sea más sencilla, mediante la
exclusión de los amigos eran amigos de mí, pero ninguno de mis otros amigos.
7
Figure 5: Representación de los amigos en Facebook.
Decidí no incluir los nombres de mi amigo en la tabla, pero los grupos que
genera son buenas representaciones de mis diversos círculos sociales. El grupo
aislado en la parte superior derecha es mis amigos de la infancia de Australia,
que no conocen a ninguno de mis amigos en el resto del mundo. Otros grupos
aislados son mis amigos del Reino Unido, el trabajo y amigos relacionados con
R-y amigos de California. El grupo más grande es mi principal red social de
Seattle. Es bastante impresionante cómo usar sólo las relaciones amigo (el
gráfico de adyacencia), aparecen mis círculos sociales "naturales". Estoy seguro
de que baremo hacer más con el informativo adicional disponible, que incluye
8
el cumpleaños, la ubicación, la foto de perfil y estado civil de sus amigos. Sólo
se puede acceder a la información que se podía ver en facebook.com, e incluso
entonces sólo un subconjunto: sólo se puede acceder a información sobre las
personas que son amigos de (incluso si tienen perfiles públicos), y no se puede
ver todo de tus amigos red social, sólo la parte que está a sólo amigos. Aun así,
es una rica fuente de datos para jugar, y estoy seguro de capacidades adicionales
serán expuestos en la API RFacebook conforme pasa el tiempo.
3.3.2. Recopilación de datos de Facebook y visualización de la red de fotos con
Gephi y R
3.3.2.1.Recopilando datos de Facebook
A) Registro: Lo primero que debe hacer es obtener los datos de Facebook.
Antes de que se le permita sacarlo de R, tendrá que hacer un desvío rápido
a developers.facebook.com/apps, registrarse como desarrollador y crear una
nueva aplicación. El nombre y la descripción son irrelevantes, lo único que
tienes que hacer es ir a Settings → Website → Site URL y completar http: //
localhost: 1410 / (ese es el puerto que vamos a usar).
B) Autenticación: Ahora puedes ir a R, instalar el paquete de RFacebook y
autenticarte con el ID y el secreto que se muestran en la pestaña
Configuración de tu aplicación de Facebook.
9
Facebook authentication
01
02 install.packages("Rfacebook")
03 library(Rfacebook)
oauth <- fbOAuth(app_id = "your_app_id_here",
04 app_secret = "your_app_secret_here",
05 extended_permissions = T)
06 save(oauth, file="fb_oauth")
07 # load(file="fb_oauth")
08
Figure 6: autentificación de Facebook
C) Descarga de datos: En este punto, ya puede obtener información de
Facebook. El uso de getFriends le dará un marco de datos que contiene
(entre otras cosas) el nombre, nombre de usuario, género, ubicación, ciudad
natal y URL de imagen de todos los contactos de Facebook que han
proporcionado esa información. Puede usar getNetwork para recopilar los
vínculos entre las personas en su lista de amigos, ya sea como una lista de
bordes o como una matriz de adyacencia. Solo por el gusto de hacerlo (y
porque no lleva mucho tiempo), conseguiremos los dos.
Collect friend info & network data from Facebook

09 # Get friend info:
10 my.friends <- getFriends(oauth, simplify=F)
11 # Get friend network in two formats, matrix and edge list:
12 fb.net.mat <- getNetwork(oauth, format="adj.matrix")+0 # bool,+0 to
get numeric
13 fb.net.el <- as.data.frame(getNetwork(oauth, format = "edgelist"))
14
Figure 7: Recopilar información de amigos y datos de red de Facebook.
D) Descarga de imagen: Usando las URL del marco de datos de amigos de
Facebook, podemos descargar las fotos de perfil de las personas y
10
almacenarlas en una carpeta local (aquí FBImages). La descarga en sí
misma es simple con download. file: la mayoría de las líneas de scripts a
continuación se ocupan de nombrar correctamente los archivos de imagen.
Download images from Facebook

setwd("C:/Research/R")
dir.create("FbImages")
# Image file name and local path stored here:
my.friends$picture.dld <- NA
# Download the images:
for (i in 1:dim(my.friends)[1]) {
# Fb images appear to be mostly JPEGs, except for people
# with no profile pics - for those we seem to get a default GIF
pic.ext <- ".jpg"
if(grepl(".gif$", my.friends$picture[i])) pic.ext <- ".gif"
# We'll name files using people's full names plus file extension.
my.friends$picture.dld[i] <-
paste0("FBImages/", sub(" ", "_", my.friends$name[i]),
pic.ext)
# Some users have UTF-8 encoded names that don't work well as file names:
if (Encoding(my.friends$name[i])=="UTF-8") {
my.friends$picture.dld[i] <-
paste0("FBImages/", "FbID_", my.friends$id[i], pic.ext) }
download.file(my.friends$picture[i], my.friends$picture.dld[i], mode =
'wb')
}
Figure 8: Descarga de imágenes de Facebook.
3.3.2.2.Visualizando la red con Gephi
Hay varias maneras de mover datos de red de R a Gephi (ambos admiten varios
formatos como gexf). Sin embargo, para redes simples / pequeñas, la forma más
directa de exportar desde R es probablemente como CSV. Gephi necesita dos
archivos CSV: uno que contenga una lista de bordes que describa cada enlace
(las columnas que contienen el nodo de inicio y el nodo final para cada enlace
deben llamarse Origen y Destino). El segundo archivo es una tabla de atributos
de nodo: debe contener una columna llamada ID con identificadores de nodo
11
correspondientes a los utilizados en Origen y Destino. Cualquier otro atributo
generalmente es opcional, pero aquí debe tener una imagen llamada, que
contenga los nombres de los archivos de fotos para que funcione el
complemento de Vista previa de la imagen.
Export the network data for Gephi
colnames(fb.net.el) <- c("Source", "Target")

my.friends$ID <- my.friends$name
my.friends$image <- gsub("FBImages/(*.)", "\\1", my.friends$picture.dld)
write.csv(fb.net.el, file="Facebook-friend-EDGES.csv", row.names=F)

write.csv(my.friends, file="Facebook-friend-NODES.csv" row.names=F)
Figure 9: Exportar los datos de la red para Gephi.
Después de importar los archivos (del Data Laboratory → Import
Spreadsheet), puede retocar el diseño del gráfico en la pestaña Información
general hasta que esté satisfecho con él, luego cambie a la pestaña Vista
previa.
Figure 10: Pestaña vista previa.
Si tiene instalado el complemento de Vista previa de imagen, debería ver
una sección de Imágenes de nodo en la parte inferior de la barra de

12
Configuración de vista previa del lado derecho. Marque Renderizar nodos
como imágenes y especifique la carpeta donde se encuentran las fotos en el
campo a continuación.
Gephi tomará los nombres de archivo almacenados en el atributo de nodo
de imagen y los buscará en la ruta de la imagen que haya establecido. Una
falla que encontré (que el creador del plugin Chris Xueamablemente ayudó)
era que el complemento tenía problemas de compatibilidad con Java 7. Tuve
que instalar Java 6 (descargar aquí) y cambiar la configuración de inicio de
Gephi (en Gephi-0.8.2 \ etc \ gephi. conf cambiando el parámetro jdkhome)
antes de que el complemento funcione.
Figure 11: Red de Facebook: Gephi
13
Figure 12:Red de imágenes de Facebook: Gephi.
3.3.2.3.Visualizando la red con igraph
R siempre ha sido capaz de manejar la adición de imágenes a gráficos de red
(y gráficos en general). Intenté un par de paquetes diferentes para hacer esto;
ambos funcionan bien. Estoy más familiarizado con el igraph, lo que hace que
sea más fácil modificarlo, pero qgraph tiene incorporada la opción de imágenes
de nodo, por lo que es muy fácil obtener un mapa de red con fotos de nodos
(ver la siguiente sección, solo se necesitan unas pocas líneas). de código).
Antes de hacer una visualización de igraph usando imágenes de nodo,
podemos trazar el gráfico a la antigua usanza y ajustar el diseño hasta que se
vea bien.
14
Plot the network with igraph (no images yet)
require("png")
require("jpeg")
require("igraph")
fb.net <- graph.adjacency(fb.net.mat)
# Add node degree, node colors based on gender, and
# edge colors based on the color of the source node.
my.friends$degree <- degree(fb.net)
my.friends$color <- "gray45"
my.friends$color[my.friends$gender=="female"] <- "lightpink3"
my.friends$color[my.friends$gender=="male"] <- "lightblue"
fb.net.el$color <- my.friends$color[match(fb.net.el$Source, my.friends$name)]
l <- layout.fruchterman.reingold(fb.net, niter=10000,area=vcount(fb.net)^2.3,
repulserad=vcount(fb.net)^2.2)
png("Facebook-friends-net-IGRAPH.png", width = 2500, height = 2000)
plot(fb.net, vertex.size=my.friends$degree/20, vertex.label=NA,
vertex.color=my.friends$color, edge.color=fb.net.el$color,
edge.width=1, edge.arrow.size=0, edge.curved=0.3, layout=l)
dev.off()
Figure 13: Trazar la red con igraph (todavía no hay imágenes)
Para trazar con imágenes, aplicaremos el diseño que creamos anteriormente y
trazaremos el grafo, pero esta vez con cuadrados blancos para los nodos. Luego
usaremos las coordenadas devueltas desde la función de diseño para superponer
las fotos sobre esos cuadros blancos. Una cosa que tardó un poco en descubrirse
(la obtuve gracias a un comentario dejado en algún lugar en las interwebs por el
autor de qgraph Sacha Epskamp) es que el diseño debe ser re-escalado a [-1,1]
primero.
Plot the image network with igraph

67 # Rescale the layout so it goes from -1 to 1
l <- layout.norm(l, -1, 1, -1, 1)
68
69 png("Facebook-friends-net-IGRAPH.png", width = 2500, height = 2000)
70 plot(fb.net, vertex.size=4, vertex.label=NA, edge.color=fb.net.el$color,
71 vertex.shape="square",vertex.color="white",
72 vertex.frame.color="white",
edge.width=1, edge.arrow.size=0, edge.curved=0.2, layout=l)
73
img.sc <- 0.03 #Image scaling
74 for (i in 1:dim(l)[1]) {
75 img <- my.friends$picture.dld[i]
15
76 img <- if(grepl(".jpg", img)) readJPEG(img) else "gray20"
rasterImage(img, l[i,1]-img.sc, l[i,2]-img.sc, l[i,1]+img.sc,
77 l[i,2]+img.sc)
78 }
79 dev.off()
80 detach(package:igraph)
81
82
Figure 14: trazar la red de imágenes con igraph.
Y así es como se ven los archivos de imagen exportados:
Figure 15: Red de Facebook: igraph.
16
Figure 16: Red de fotografías de Facebook: igraph.
3.3.2.1.Visualizando la red con qgraph
Realmente no hay mucho que explicar aquí: las imágenes de nodo son una opción
incorporada para qgraph. La función qgraph tomará una matriz y un vector de
nombres de imágenes (con rutas), y producirá un gráfico con imágenes de nodo de
inmediato sin ningún retoque adicional.
17
.
Plot the image network with qgraph
83 require("png")
84 require("qgraph")
85 png("Facebook-friends-net-2014-04-QGRAPH.png", width = 2500, height =
2000)
86 qgraph(fb.net.mat, images = my.friends$picture.dld, labels = F,
87 borders = F, esize=0.1, curve=0.2, curveAll=T,
88 edge.color="gray55")
89 dev.off()
90 detach(package:qgraph)
Figure 17: Trazar la red de imágenes de qgraph.
Figure 18: Red de Facebook: qgraph.
3.3.3. Python: En este algoritmo trataremos de codificar grafos que estén
relacionados con la red social FACEBOOK
18
3.3.3.1.Incrementar un grafo por un arco en Python
1 def incremental_vertex(self, source, target, weight):

2
3 returned = np.array([])
4
5 self.source = np.append(self.source, source)
6 returned = np.append(returned, source)
7
8 self.target = np.append(self.target, target)
9 returned = np.append(returned, target)
10
11 self.weight = np.append(self.weight, weight)
12 returned = np.append(returned, weight)
13
14 return returned
Figure 19: incremento de grafo.
A) Grafo principal: Es la clase principal grafo que detalla cómo se detalla
para mostrar los grafos relacionados con Facebook que toma 4 campos de
arreglos por lo cual tendrán esa dirección.
19
import numpy as np
class Graph:
source = []
target = []
weight = []
vertex = []
undirected = 0
def __init__(self, source=[], target=[], weight=[],

directed=True):
self.source = np.array(source)
self.target = np.array(target)
self.weight = np.array(weight)
self.directed = directed
self.set_vertex()
def print_r(self):
print("Source: ", self.source)
print("Target: ", self.target)
print("Weight: ", self.weight)
print("Vertex: ", self.vertex)
def set_vertex(self):
vertex = np.unique(self.source)
vertex2 = np.unique(self.target)
self.vertex = np.unique(np.concatenate([vertex,
vertex2]))
return self.vertex
def get_weight(self, n1, n2):

if n1 == n2:
return 0
w = self.weight[np.logical_and(self.source == n1,
self.target == n2)]
return np.inf if w.size == 0 else w[0]
def export(self):
array_export = [(int(self.source[i]),
int(self.target[i]), self.weight[i]) for i in
range(self.source.size)]
return array_export
Figure 20: Grafo principal.
B) Grafo ASP: En el grafo dinámico detalla principalmente el algoritmo
DIJKSTRA que trata principalmente en recorrer el camino más corto y
también se utiliza warshall.
20
import numpy as np
from _graph.DynamicGraph import DynamicGraph
class GraphAPSP(DynamicGraph):

directed=True):
DynamicGraph.__init__(self, source, target, weight,
directed)
def sssp_dijkstra(self, source):
total_vertex = len(self.vertex)
Q = np.array(self.vertex)
dist = np.zeros(total_vertex)
dist.fill(np.inf)
dist[self.vertex == source] = 0
while len(Q) != 0:
min = np.inf
u = 0
for q in Q:
if dist[self.vertex == q] <= min:
min = dist[self.vertex == q]
u = q
Q = np.delete(Q, np.argwhere(Q == u))
for v in self.target[self.source == u]:

alt = dist[self.vertex == u] +
self.get_weight(u, v)
index_v = self.vertex == v
if alt < dist[index_v]:
dist[index_v] = alt
return dist
def apsp_dijkstra(self):
result = np.full((self.vertex.size, self.vertex.size),

np.inf)
count = 0
for v in self.vertex:
result[count] = self.sssp_dijkstra(v)
count = count + 1
return result
def floyd_warshall(self):
total_vertex = len(self.vertex)
dist = np.zeros((total_vertex, total_vertex))
dist.fill(np.inf)
21
for idx in range(self.source.size):
index_s = self.vertex == self.source[idx]
index_t = self.vertex == self.target[idx]
dist[index_s, index_t] = self.weight[idx]
for index in range(self.vertex.size):
dist[index, index] = 0
for k in np.nditer(self.vertex):
for i in np.nditer(self.vertex):
for j in np.nditer(self.vertex):
index_k = self.vertex == k
index_i = self.vertex == i
index_j = self.vertex == j
if dist[index_i, index_j] >

dist[index_i, index_k] + dist[index_k, index_j]:
dist[index_i, index_j] =
dist[index_i, index_k] + dist[index_k, index_j]
return dist
Figure 21: Grafo ASP.
C) Grafo Pro: Trata principalmente las condiciones que debe tener un grafo
por la función sí que puede modificarse si no cumple esa condición por lo
cual se aplica esas condiciones y además sentencias.
from _graph.GraphKNNB import GraphKNNB

import matplotlib.pyplot as plt
import networkx as nx
import numpy as np
class GraphPro(GraphKNNB):
directed=True):
GraphKNNB.__init__(self, source, target, weight, directed)
@staticmethod
def creategraph(total_nodes, pro_edges, weights, directed=True):
source = np.array([])
target = np.array([])
weight = np.array([])
for i in range(total_nodes):
for k in range(i+1, total_nodes):
if k == i:
continue
22
p = 1 - pro_edges
has_edge = np.random.choice(2, 1, p=[p,
pro_edges])[0]
if not has_edge:
continue
probabilities = np.zeros(len(weights))
probabilities = probabilities + (1 /
len(weights))
w = np.random.choice(weights, 1,
p=probabilities)[0]
source = np.append(source, i)
target = np.append(target, k)
weight = np.append(weight, w)
if not directed:
source = np.append(source, k)
target = np.append(target, i)
weight = np.append(weight, w)
return GraphPro(source, target, weight)
def draw(self, with_weight=True):

gr = nx.DiGraph()
gr.add_weighted_edges_from(self.export())
pos = nx.spring_layout(gr)
list_edges = list(gr.edges())
last = ()
if self.last_vertex_modified.size > 0:
last = (int(self.last_vertex_modified[0]),
int(self.last_vertex_modified[1]))
list_edges.remove(last)
if not self.directed:
list_edges.remove((int(self.last_vertex_modified[1]),
int(self.last_vertex_modified[0])))
nx.draw(gr, pos=pos, with_labels=True,

edgelist=list_edges, node_size=600)
if with_weight:
edge_labels = dict([((u, v,), d['weight']) for
u, v, d in gr.edges(data=True)])
nx.draw_networkx_edge_labels(gr, pos=pos,
edgelist=list_edges, edge_labels=edge_labels)
if len(last) > 0:
nx.draw_networkx_edges(gr, pos=pos,
edgelist=[last], width=2.0, edge_color='b')
plt.axis('off')
plt.show()
Figure 22: Grafo Pro.
23
D) Grafo KNNB: Trata principalmente de determinar nodos en qué posición
debe ir, también se habla de este algoritmo los vértices que longitud debe
ir, etc.
import numpy as np
from _graph.GraphRR import GraphRR
class GraphKNNB(GraphRR):

directed=True):
GraphRR.__init__(self, source, target, weight, directed)
def knnb_node_incremental(self, dist):

dist = np.array(dist)
add = np.full(self.vertex.size-1, np.inf)

dist = np.vstack([dist, add])
dist = np.hstack([dist, np.append(add, np.inf)[:, None]])
dist[self.vertex.size-1, self.vertex.size-1] = 0
z = self.node_incremental['node']
T1 = self.node_incremental['source']
T2 = self.node_incremental['target']
min_in_z = {}
min_out_z = {}
for k_in in T1:

dist[self.vertex == k_in, self.vertex == z] =
self.get_weight(k_in, z)
for k_out in T2:

dist[self.vertex == z, self.vertex == k_out] =
self.get_weight(z, k_out)
for v in self.vertex:
if v == z:
continue
for k_in in T1:
#if v == k_in:
# continue
L_vz = dist[self.vertex == v, self.vertex == k_in][0]
+ self.get_weight(k_in, z)
if v not in min_in_z or L_vz < min_in_z[v]:
min_in_z[v] = L_vz
for k_out in T2:
#if v == k_out:
# continue
L_zv = dist[self.vertex == k_out, self.vertex == v][0]

+ self.get_weight(z, k_out)
24
if v not in min_out_z or L_zv <
min_out_z[v]:
min_out_z[v] = L_zv
for i, L_iz in min_in_z.items():
for j, L_jz in min_out_z.items():
if i == j:
continue
if L_iz + L_jz < dist[self.vertex == i,
self.vertex == j][0]:
dist[self.vertex == i, self.vertex == j]
= L_iz + L_jz
for i, value in min_in_z.items():

dist[self.vertex == i, self.vertex == z] = value
for j, value in min_out_z.items():
dist[self.vertex == z, self.vertex == j] = value
return dist
Figure 23: grafo KNNB
E) Grafo dinámico: Esta función realiza un recorrido de los vértices hasta que
resulte un cambio en el grafo. Recibe un parámetro behavior sobre el
comportamiento del grafo (incremental o decreciente).
import numpy as np
from _graph.Graph import Graph
class DynamicGraph(Graph):

directed=True):
Graph.__init__(self, source, target, weight, directed)
self.last_vertex_modified = np.array([])
self.node_incremental = {
'node': None,
'source': np.array([]),
'target': np.array([]),
}
def dynamic_decreasing_random_vertex(self):
node = np.random.choice(self.vertex, 1)[0]
25
choisen = self.target[node == self.source]
if choisen.size < 1:
choisen = self.source[node == self.target]
other_node = np.random.choice(choisen, 1)[0]
return
self.dynamic_decreasing_vertex(other_node, node)
return self.dynamic_decreasing_vertex(node,
other_node)
def dynamic_decreasing_vertex(self, source, target):
index = np.where(np.logical_and(self.source ==
source, self.target == target))[0][0]
returned = np.array([])
self.source = np.delete(self.source, index)
returned = np.append(returned, source)
self.target = np.delete(self.target, index)
returned = np.append(returned, target)
self.weight = np.delete(self.weight, index)
self.last_vertex_modified = returned
return returned
26
def dynamic_incremental_random_vertex(self, weights=[1,
2, 3, 4, 5, 6, 7, 8, 9]):
w = np.random.choice(weights)
index_for_target = np.invert(
np.logical_or(np.in1d(self.vertex,
self.target[node == self.source]), self.vertex == node)
choisen = self.vertex[index_for_target]
index_for_source = np.invert(
np.logical_or(np.in1d(self.vertex,
self.source[node == self.target]), self.vertex == node)
choisen = self.vertex[index_for_source]
return
self.dynamic_incremental_vertex(other_node, node, w)
return self.dynamic_incremental_vertex(node,
other_node, w)
def dynamic_incremental_vertex(self, source, target,

weight=1):
returned = np.array([])
self.source = np.append(self.source, source)
returned = np.append(returned, source)
self.target = np.append(self.target, target)
27
returned = np.append(returned, target)
self.weight = np.append(self.weight, weight)
returned = np.append(returned, weight)
self.last_vertex_modified = returned
return returned
def dynamic_incremental_node(self, node, sources,

w_sources, targets, w_targets):
if self.vertex[self.vertex == node].size > 0:
return -1
sources = np.array(sources)
targets = np.array(targets)
self.source = np.concatenate((self.source, sources,

np.full(targets.size, node)))
self.target = np.concatenate((self.target,
np.full(sources.size, node), targets))
self.weight = np.concatenate((self.weight,
w_sources, w_targets))
self.vertex = np.append(self.vertex, node)
self.node_incremental['node'] = node
self.node_incremental['source'] = sources
self.node_incremental['target'] = targets
return self.node_incremental
28
def vertex_update(self, source, target, weight=1):
self.weight[np.logical_and(self.source == source,
self.target == target)] = weight
if not self.directed:
self.weight[np.logical_and(self.source ==
target, self.target == source)] = weight
self.last_vertex_modified = np.array([source,
target, weight])
return self.last_vertex_modified
def vertex_update_random(self, weight=1):
choisen = self.target[node == self.source]
choisen = self.source[node == self.target]
return self.vertex_update(other_node, node,

weight=weight)
return self.vertex_update(node, other_node,

weight=weight)
Figure 24: Grafo dinámico.
4. Discusión y Resultados
4.1. Resultado de en el programa Python
En la primera salida tenemos el grafo generado aleatoriamente. En la segunda el
mismo grafo después de una inserción, en este caso el arco insertado es \left (3, 0, 1
\right). En la tercera, el mismo grafo después de un decrecimiento por arco, el arco
29
removido fue \left (0, 4 \right). De esta manera tenemos nuestro grafo dinámico
aleatorio.
Figure 25: Resultado Python
Salida 1
from _graph.GraphPro import GraphPro as G

from time import time
import os
#os.system('clear')
print("<--------Test Create------->\n")
num_tries = 1000
sources = [1, 0, 3, 2, 1, 4, 5, 4, 3, 5]
targets = [0, 2, 0, 1, 3, 1, 1, 3, 5, 4]
weights = [2, 2, 4, 3, 2, 4, 4, 3, 5, 1]
graph = G(sources, targets, weights)
graph.print_r()
print("-------Incremental-----")
print("-------Calc source(2)-----")
source = 1
dist = graph.sssp_dijkstra(source)
print(dist)
graph.vertex_update(1, 3, 1)
mean_time_dijkstra_sp = 0
for times1 in range(num_tries):
t = time()
graph.sssp_dijkstra(source)
lapsed = time() - t
mean_time_dijkstra_sp = mean_time_dijkstra_sp + lapsed
mean_time_dijkstra_sp = mean_time_dijkstra_sp / num_tries
30
dist_new = graph.dijkstra_truncated(dist.tolist())
print(dist_new)
mean_time_rr_sp = 0
for times2 in range(num_tries):
t = time()
graph.dijkstra_truncated(dist.tolist())
lapsed = time() - t
mean_time_rr_sp = mean_time_rr_sp + lapsed
mean_time_rr_sp = mean_time_rr_sp / num_tries
print()
print('SSSP Dijkstra: ', mean_time_dijkstra_sp)
print('SSSP RR :', mean_time_rr_sp)
print('Is less?', mean_time_rr_sp < mean_time_dijkstra_sp)
print()
graph.draw()
print()
print("------------------------")
Figure 26: salida 1 de grafo Pro.
Salida2
from _graph.GraphPro import GraphPro as g

import os
os.system('clear')
print("<--------Test Floyd-Warshall------->\n")
weights = [1, 2, 3, 4, 5]
#graph = g.creategraph(6, .75, weights, directed=False)
sources = [0, 1, 0, 2, 0, 3, 0, 5, 1, 2, 1, 3, 1, 4, 1, 5, 2, 3, 2, 4, 3, 4,
3, 5, 4, 5]
targets = [1, 0, 2, 0, 3, 0, 5, 0, 2, 1, 3, 1, 4, 1, 5, 1, 3, 2, 4, 2, 4, 3,
5, 3, 5, 4]
weights = [2, 2, 2, 2, 4, 4, 1, 1, 3, 3, 2, 2, 4, 4, 4, 4, 2, 2, 1, 1, 3, 3,
5, 5, 1, 1]
graph = g(sources, targets, weights)
graph.print_r()
print('.........................')
t = time()
print(graph.floyd_warshall())
elapsed = time() - t
print("Time: ", elapsed)
graph.draw()
Figure 27: Salida 2 de grafo Pro.

31
Salida3
from _graph.GraphPro import GraphPro as g

import os
os.system('clear')
print("<--------Test Khopkar------->\n")
weights = [1, 2, 3, 4, 5]
sources = [1, 0, 3, 2, 1, 4, 5, 4, 5]
targets = [0, 2, 0, 1, 3, 1, 1, 3, 4]
weights = [2, 2, 4, 3, 2, 4, 4, 3, 1]
graph = g(sources, targets, weights)
print('.........................')
dist = graph.floyd_warshall()
print(dist)
graph.dynamic_incremental_node(
node=6, sources=[2], w_sources=[1], targets=[5], w_targets=[1])
dist_new = graph.knnb_node_incremental(dist.tolist())
print(dist_new)
graph.print_r()
#graph.draw()
sources = [10, 11, 5, 5, 6, 4, 8, 4, 9, 9, 2, 12, 3]

targets = [1, 1, 1, 6, 4, 7, 4, 9, 8, 2, 12, 9, 2]
weights = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
graph2 = g(sources, targets, weights)
print('.........................')
dist2 = graph2.floyd_warshall()
print(dist2)
graph2.dynamic_incremental_node(
node=13, sources=[1, 3], w_sources=[1, 1], targets=[2, 4], w_targets=[1, 1])
dist2_new = graph2.knnb_node_incremental(dist2.tolist())
print(dist2_new)
graph2.print_r()
Figure 28: salida 3 de grafo Pro
32
4.2. Aplicación Gephi
En este caso copiamos el enlace de dirección de una página a través de Facebook
reconocible por lo cual escogemos GOP. Por lo cual nos va mostrar un código de su
dirección de enlace.
Figure 29: Copiar el enlace de la página
Esta página trata principalmente las noticias más recientes del presidente de Estados
Unidos que es TRUMP. La idea es saber que personas le dieron me gusta esa página
y interrelacionarlo a través de grafos por lo cual haremos una simulación de grafo de
esa página de grafos.
33
Figure 30: página de Facebook de elección.
Después que nos da el código buscamos en Facebook NETVIZ por lo cual nos
pedirá el código y lo insertamos y damos comenzar. Nos va mostrar los grafos
interrelacionados la página de Facebook con los usuarios que dieron me gusta y
además las páginas que están relacionadas de otras páginas.
34
Figure 31: Ubicación de las personas que interactúan con la página.
Terminando si queremos simular ese grafo descargamos ese archivo y luego lo
guardamos en nuestro pc recomendable en la dirección Escritorio. Abrimos El
programa Gephi y nos fijamos en abrir archivo y lo damos click y nos mostrara que
archivo desea abrir y lo mostramos la dirección donde hemos guardado.
35
Y podemos simular el grafo y darle girarían 3d cambiarle colores las aristas,
aumentar los tamaños de los nodos, etc. También podemos ver las tablas de datos o
registros.
Figura 32: el grafo girando en 3D.

Figure 32: Grafo giratorio en 3D.
Tabla de datos: Ahí muestra detalle por detalle los id, dirección de Facebook que
dieron like la página, las páginas relacionadas con esta página, etc.
36
Figure 33: Base de datos.
5. Conclusiones
La realización del presente trabajo implico varias partes en todo su desarrollo, como
primera parte fue hacer una exhaustiva investigación para adquirir conocimientos de las
redes sociales, como funcionan, cual es el impacto de las redes sociales como Facebook o
twitter en la población, la segunda parte fue la investigación de como extraer la información
de una red social para posteriormente hacer el respectivo análisis, se encontró una
aplicación que podría hacerlo para así pasar a la tercera parte que corresponde al análisis
de esa base de datos, en esta parte decidimos a través de que lenguaje de programación
sería más conveniente realizar el análisis, cabe destacar que Python fue lo ideal para la
realización del proyecto, ya que hay distintos programas que pueden realizar esta acción,
finalmente, se procedió a interpretar los resultados del análisis ya obtenido.
37
Usamos varios métodos entre los más comunes se encuentran aquellos que se desarrollan
mediante lenguajes de programación como los que usamos que son Programa en R, Python,
Gephi, qgraph y rgraph lenguajes que nos demuestran a su manera el análisis de las redes
sociales a través de las conexiones, con las personas a lo largo del mundo y como estas
interactúan en el medio online, mediante grafos, estos nos pueden indicar desde las
ubicaciones de nuestros amigos en Facebook, el lugar geográfico que brinda de más likes
a una página en Facebook incluso se muestran grafos de imágenes de las personas
relacionadas entre sí.
38
6. Bibliografía
Gámez, Julián & Varela, Agustina – (2015). Análisis de la red social virtual Facebook.
"Redes Sociales". Autor: María Estela Raffino. Para: Concepto. De. Disponible en:
https://concepto.de/redes-sociales/. Consultado: 03 de julio de 2019.
Peres Solá, Cristina & Casas Roma, Jordi (2016). Análisis de Datos de redes sociales.
39

Teoria de Grafos y Situaciones para Internet

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Teoria de Grafos y Situaciones para Internet

Cargado por

Copyright:

Formatos disponibles

Teoría de grafos para situaciones reales en las redes sociales

Cevallos Mamani Cynthia Vanessa, Guevara López Lorena, Huaman cerna

Raged Alexander, Marcelo Toribio Jhonatan Raul, Onofre Espinar Jhanluck

Universidad Mayor de San Marcos.

Facultad de Ingeniería de Sistemas.

que poseemos y al saciar nuestra sed de conocimiento.

el apoyo y fortaleza en aquellos momentos de dificultad y de debilidad.

por su apoyo moral.

cual siempre se vio limitado temporal y espacialmente.

las redes sociales convencionales en la utilización de tecnologías para facilitar la comunicación.

de análisis de redes sociales y las formas de representarlas gráficamente.

2. Redes sociales ........................................................Error! Bookmark not defined.

2.1. Concepto y finalidad. ......................................Error! Bookmark not defined.

2.2. Desarrollo ........................................................Error! Bookmark not defined.

3. Metodos..................................................................Error! Bookmark not defined.

3.1.Metodo Socio-céntrico .....................................Error! Bookmark not defined.

3.2.Metodo Ego-céntrico .......................................Error! Bookmark not defined.

3.3.Aplicación del metodo .....................................Error! Bookmark not defined.

4. Discusión y resultados ...........................................Error! Bookmark not defined.

5. Concluciones ..........................................................Error! Bookmark not defined.

6. Bibliografia ............................................................Error! Bookmark not defined.

facilitar el estudio de una red social acotada.

secciones aplicadas al desarrollo mismo del prototipo.

A continuación, se detalla brevemente qué se ofrece en cada una de las secciones

el estudio de las redes, el Ego-céntrico y el

Una vez finalizado el análisis, se procede a la implementación, detallada en

“Implementación del prototipo”, donde se expresan una serie de aclaraciones sobre la

herramienta, las tecnologías utilizadas y diagramas que representan la estructura de la

aplicación y los distintos casos de uso existentes.

A lo largo de la historia de las redes sociales ha sido definida de manera diferente

nuestras propias conclusiones.

u organizaciones mediante la comunicación e interacciones. En estos sitios de

internet se tiene la oportunidad de relacionarse con individuos que poseen intereses

o actividades en común (como amistad, parentesco, trabajo) y que permiten el

contacto entre estos, de manera que se puedan intercambiar información.

La finalidad principal de este medio es permitir a los usuarios enlazarse,

contactarse, compartir datos y crear comunidades que posean algún gusto en

visto en el pasado, es la transmisión de menajes a largas distancias, por ejemplo, en

la comunicación entre personas.

La manera de comunicación e interactuar con las personas ha ido evolucionando,

permitieron una comunicación con nuestros allegados de manera rápida, segura y

diferentes aspectos de las actividades sociales tanto en los individuos como en su

Los principales métodos utilizados para recolectar son el Socio-céntrico y el

El método Socio-céntricos analiza las relaciones entre los actores y permite

estudiar la estructura de la red social en sí. La colección de datos consiste en tres

teniendo en consideración la naturaleza de los vínculos, en particular, en referencia

• Confirmación: grado en el cual el actor replica la misma relación con otros,

en un área de contenido específica.

• Multiplicidad: grado en el cual un actor tiene diferentes roles en la Red

Figura 1: método de análisis Socio-céntrico

El segundo paso determina la existencia de subgrupos y si ciertos roles tienen

impacto dentro de la Red Social Virtual. Finalmente, el tercer paso consiste en

analizar las características generales de la red, datos como el tamaño y la densidad,

es decir, la cantidad de relaciones dentro de la red.

sobre cada actor de la red, cuyas respuestas se cuantifican y se transforman en un

conjunto de matrices (Figura 19).

segundo actor. Este tipo de encuestas se realizan sobre grupos de 20 a 50 personas,

valor limitado debido a las limitaciones del software y el poder de procesamiento.

El método Ego-céntrico se basa en los individuos y no en la red como un todo.

Esto permite seleccionar actores específicos e identificar con qué nodos se

El comienzo de este método consiste en identificar un actor y sus conexiones con

es el actor dentro de la red social. Un número alto de relaciones establece que el

consiguiente, probablemente no tenga un rol relevante dentro de la misma.