[python] J'ai créé un diagramme de corrélation de suivi pour Twitter (édition Gremlin)
Contenu de l'article
L'autre jour, j'ai écrit un article pour créer un diagramme de corrélation de suivi pour Twitter.
[Python] J'ai essayé de visualiser la relation de suivi de Twitter
Dans l'article ci-dessus, obtenez des informations de compte de suivi avec l'API Twitter et enregistrez-les dans mongoDB. Après cela, la logique était d'obtenir les données de mongoDB et de les dessiner sur le graphique tout en vérifiant si elles se suivaient.
J'ai appris que l'utilisation de GraphDB est pratique pour l'analyse de réseau, j'ai donc également utilisé GraphDB.
environnement
python：3.7 gremlinpython：3.4.6 gremlin：3.4.6
Installez Gremlin
J'ai construit l'environnement sur Windows. Vous pouvez télécharger les outils pour Windows à partir de ce qui suit.
https://downloads.apache.org/tinkerpop/3.4.6/
C'est "serveur" à télécharger. Il est pratique d'avoir "console", mais je ne l'utiliserai pas dans cet article.
Après le téléchargement, décompressez simplement le ZIP, placez-le dans n'importe quel dossier et exécutez bat sous le dossier bin.
gremlinpython Il peut être installé avec la commande pip.
pip install gremlinpython
la mise en oeuvre
Maintenant que nous avons un environnement, nous allons le mettre en œuvre.
Enregistrer les données mongoDB dans Gremlin
Gremlin est une base de données capable de gérer des modèles de données de type Graph. Puisque mongoDB n'a pas pu gérer la relation entre les données, nous enregistrerons la relation des données lors de l'enregistrement des données dans Gremlin.
données mongoDB
Les données de mongoDB sont les suivantes. Une liste des comptes Twitter et des comptes qu'ils suivent est enregistrée. Un grand nombre des données suivantes sont enregistrées.
{
"_id" : ObjectId("5e6c52a475646eb49cfbd62b"),
"screen_name" : "yurinaNECOPLA",
"followers_info" : [
{
"screen_name" : "Task_fuuka",
"id" : NumberLong("784604847710605312")
},
(Omis)
{
"screen_name" : "nemui_oyasumi_y",
"id" : NumberLong("811491671560974336")
}
]
}
code
from gremlin_python import statics
from gremlin_python.structure.graph import Graph
from gremlin_python.process.graph_traversal import __
from gremlin_python.process.traversal import TraversalSideEffects
from gremlin_python.driver.driver_remote_connection import DriverRemoteConnection
from mongo_dao import MongoDAO
mongo = MongoDAO("db", "followers_info")
graph = Graph()
# Créer une connexion Gremlin
g = graph.traversal().withRemote(DriverRemoteConnection('ws://localhost:8182/gremlin','g'))
start_name = 'yurinaNECOPLA'
def addValueEdge(parent_name, depth):
if depth == 0:
return False
print(parent_name)
result = mongo.find_one(filter={'screen_name': parent_name})
if result == None or len(result) == 0:
return False
# Ajouter des sommets
g.addV(parent_name).property('screen_name', parent_name).toSet()
p = g.V().has('screen_name', parent_name).toList()[0]
for follower in result['followers_info']:
if addValueEdge(follower['screen_name'], depth-1):
cList = g.V().has('screen_name', follower['screen_name']).toList()
if len(cList) != 0:
# Ajouter un bord
g.addE('follow').from_(p).to(cList[0]).toSet()
return True
addValueEdge(start_name, 3)
Commentaire de code
- Choisissez le meilleur compte
- Transmettez le nom du compte à addValueEdge
- Obtenez des données de MongoDB
- Ajouter des sommets à Gremlin une fois que les données sont disponibles
- Transmettez les noms de compte que vous suivez un par un (retournez à 2.)
- Ajouter un bord
De cette manière, les données et les arêtes sont enregistrées de manière récursive.
Créer un diagramme de corrélation
La construction de base est la même que lorsque les données ont été acquises à partir de mongoDB.
import json
import networkx as nx
import matplotlib.pyplot as plt
from gremlin_python import statics
from gremlin_python.structure.graph import Graph
from gremlin_python.process.graph_traversal import __
from gremlin_python.process.traversal import TraversalSideEffects
from gremlin_python.driver.driver_remote_connection import DriverRemoteConnection
start_screen_name = 'yurinaNECOPLA'
graph = Graph()
# Créer une connexion Gremlin
g = graph.traversal().withRemote(DriverRemoteConnection('ws://localhost:8182/gremlin','g'))
# Créer un nouveau graphique
G = nx.Graph()
#Ajouter un nœud
G.add_node(start_screen_name)
def add_edge(screen_name, depth):
if depth == 0:
return
name = g.V().has('screen_name', screen_name).toList()[0]
follows_list = g.V(name).both().valueMap().toList()
for follow in follows_list:
print(follow['screen_name'][0])
G.add_edge(screen_name, follow['screen_name'][0])
add_edge(follow['screen_name'][0], depth-1)
add_edge(start_screen_name, 3)
# Créer un diagramme. figsize est la taille de la figure
plt.figure(figsize=(10, 8))
# Déterminez la disposition de la figure. Plus la valeur de k est petite, plus le chiffre est dense
pos = nx.spring_layout(G, k=0.8)
# Dessin de nœuds et d'arêtes
# _color: spécifiez la couleur
# alpha: spécification de la transparence
nx.draw_networkx_edges(G, pos, edge_color='y')
nx.draw_networkx_nodes(G, pos, node_color='r', alpha=0.5)
# Ajouter un nom de nœud
nx.draw_networkx_labels(G, pos, font_size=10)
# Réglage de ne pas afficher l'axe X et l'axe Y
plt.axis('off')
plt.savefig("mutual_follow.png ")
# Dessinez un diagramme
plt.show()
Commentaire de code
Les points clés sont les suivants.
name = g.V().has('screen_name', screen_name).toList()[0]
follows_list = g.V(name).both().valueMap().toList()
for follow in follows_list:
print(follow['screen_name'][0])
G.add_edge(screen_name, follow['screen_name'][0])
add_edge(follow['screen_name'][0], depth-1)
La première ligne obtient les informations sur l'adepte de Gremlin. Vous pouvez obtenir les informations de bord des informations obtenues dans la deuxième ligne. Puisque ces données sont une liste de types de dict, vous pouvez obtenir le nom du compte en obtenant un par un et en obtenant screen_name.
résultat
Résultat d'exécution
Le résultat était assez disgracieux, mais j'ai pu créer un diagramme de corrélation.
Diagramme de corrélation d'un autre modèle
Le diagramme de corrélation ci-dessus montre également une relation cyclique telle que compte A → compte B, compte B → compte C et compte C → compte A.
Si vous ne souhaitez pas circuler, vous pouvez le réaliser en ajoutant le contrôle que les données déjà enregistrées au moment de l'inscription dans Gremlin ne sont pas ajoutées.
def registCheck(screen_name):
check = g.V().has('screen_name', screen_name).toList()
if len(check) == 0:
return False
else:
return True
def addValueEdge(parent_name, depth):
if depth == 0 or registCheck(parent_name):
return False
print(parent_name)
result = mongo.find_one(filter={'screen_name': parent_name})
if result == None or len(result) == 0:
return False
# Ajouter des sommets
g.addV(parent_name).property('screen_name', parent_name).toSet()
p = g.V().has('screen_name', parent_name).toList()[0]
for follower in result['followers_info']:
if addValueEdge(follower['screen_name'], depth-1):
cList = g.V().has('screen_name', follower['screen_name']).toList()
if len(cList) != 0:
# Ajouter un bord
g.addE('follow').from_(p).to(cList[0]).toSet()
return True
En ajoutant un registerCheck pour vérifier si les données sont enregistrées dans Gremlin, la relation de circulation pourrait être exclue.
résultat
Résumé
Dans la figure avec diffusion, les comptes qui sont étroitement liés les uns aux autres sont produits ensemble. Dans la figure sans circulation, le compte que le compte de départ suit est sorti à proximité, mais comme la logique est construite de manière récursive, le compte qui se suit avec le compte A est sorti à une position distante. Certains sont. Il semble que nous devons encore réfléchir à la façon de définir le bord.
L'enregistrement des relations de données est similaire à RDB, mais j'ai eu l'impression qu'il est très difficile de gérer intuitivement avec gremlin python. Si vous pouvez lire le document et comprendre le mécanisme dans une certaine mesure, il sera utile pour l'analyse du réseau.
Recommended Posts