NoSQL Solution pour Persisting graphiques à l'échelle

Question

Je suis accro à l'aide de Python et NetworkX pour analyser les graphiques et comme j'apprends plus je veux utiliser de plus en plus de données (je suppose que je deviens un drogué de données :-). Finalement, je pense que mon graphique NetworkX (qui est stocké sous forme de dict dict) dépassera la mémoire sur mon système. Je sais que je peux probablement ajouter plus de mémoire, mais je me demandais s'il y avait un moyen d'intégrer au lieu NetworkX avec Hbase ou une solution similaire?

Je regardai autour et ne pouvait pas vraiment trouver quoi que ce soit, mais je ne pouvais pas non plus trouver tout ce qui concerne permettant d'un simple back-end de MySQL ainsi.

Est-ce possible? Est-ce que quelque chose exist pour permettre la connectivité à une sorte de stockage persistant?

Merci!

Mise à jour: Je me souviens avoir vu ce sujet dans « Social Network Analysis pour les startups », les pourparlers de l'auteur sur d'autres méthodes de stockage (y compris HBase, s3, etc ..) mais ne montre pas comment faire ou si son possible <. / p>

Answer 1

Il existe deux grands types de conteneurs pour le stockage de graphiques:

1. true bases de données graphiques: par exemple, Neo4j , Agamemnon , GraphDB et AllegroGraph ; ces magasins non seulement un graphique mais ils comprennent aussi qu'un graphique est, donc, par exemple, vous pouvez interroger ces bases de données par exemple, combien de nœuds sont entre le chemin le plus court de noeud X et Y noeud

2. conteneurs graphiques statiques : FlockDB adapté MySQL Twitter est le plus bien connu ici exemple. Ces blocs de données peuvent stocker et récupérer graphes très bien; mais pour interroger le graphique lui-même, vous devez d'abord récupérer le graphique à partir de la base de données puis utilisez une bibliothèque (par exemple, Python excellente NetworkX) pour interroger le graphique lui-même.

Le conteneur de graphique à base Redis-i est dans discuterai ci-dessous la deuxième catégorie, bien que Redis apparemment est aussi bien adapté pour les conteneurs dans la première catégorie comme en témoigne Redis-graphique , un paquet python remarquablement faible pour la mise en œuvre d'une base de données graphique dans Redis.

Redis fonctionnera très bien ici.

Redis est un lourd, les données durables stocker adapté à une utilisation de la production, mais il est aussi assez simple à utiliser pour l'analyse en ligne de commande .

Redis est différente de celle d'autres bases de données en ce qu 'il comporte plusieurs types de structures de données; celui que je recommande ici est le hachage type de données. En utilisant cette structure de données Redis vous permet de « liste des dictionnaires » de très près mimique un, un schéma classique pour les graphes de stockage, dans lequel chaque élément de la liste est un dictionnaire des arêtes calées au noeud à partir duquel ces arêtes sont originaires.

Vous devez d'abord installer Redis et le client python. DeGizmo Blog a un excellent "up-and-running" tutoriel qui comprend un étape par étape GUID sur l'installation à la fois.

Une fois que Redis et son client python sont installés, démarrer un serveur Redis , que vous faites comme ceci:

• cd dans le répertoire dans lequel vous avez installé Redis ( / usr / bin local / sur « nix si vous avez installé via make install ); suivant

• type Redis-server à l'invite puis entrez shell

vous devriez voir le fichier journal du serveur tailing sur votre fenêtre shell

>>> import numpy as NP
>>> import networkx as NX

>>> # start a redis client & connect to the server:
>>> from redis import StrictRedis as redis
>>> r1 = redis(db=1, host="localhost", port=6379)

Dans l'extrait ci-dessous, i sont mémorisées d'un diagramme à quatre nœuds; chaque ligne ci-dessous appels hmset sur le client Redis et stocke un noeud et les bords connectés à ce noeud ( « 0 » => pas de bord, « 1 » => Bordure). (Dans la pratique, bien sûr, vous abstrait ces appels répétitifs en fonction;. Ici, je suis montrant chaque appel, car il est probable que plus facile à comprendre cette façon)

>>> r1.hmset("n1", {"n1": 0, "n2": 1, "n3": 1, "n4": 1})
      True

>>> r1.hmset("n2", {"n1": 1, "n2": 0, "n3": 0, "n4": 1})
      True

>>> r1.hmset("n3", {"n1": 1, "n2": 0, "n3": 0, "n4": 1})
      True

>>> r1.hmset("n4", {"n1": 0, "n2": 1, "n3": 1, "n4": 1})
      True

>>> # retrieve the edges for a given node:
>>> r1.hgetall("n2")
      {'n1': '1', 'n2': '0', 'n3': '0', 'n4': '1'}

Maintenant que le graphique est persistait, le récupérer à partir du Redis DB sous forme de graphique NetworkX.

Il y a plusieurs façons de le faire, ci-dessous fait dans deux * étapes *:

1. extraire les données de la base de données Redis dans un matrice d'adjacence , mis en œuvre comme un tableau 2D NumPy; puis

2. directement ce graphique en utilisant un NetworkX NetworkX intégré fonction:

réduit à code, ces deux étapes sont:

>>> AM = NP.array([map(int, r1.hgetall(node).values()) for node in r1.keys("*")])
>>> # now convert this adjacency matrix back to a networkx graph:
>>> G = NX.from_numpy_matrix(am)

>>> # verify that G in fact holds the original graph:
>>> type(G)
      <class 'networkx.classes.graph.Graph'>
>>> G.nodes()
      [0, 1, 2, 3]
>>> G.edges()
      [(0, 1), (0, 2), (0, 3), (1, 3), (2, 3), (3, 3)]

Lorsque vous mettez fin à une session de Redis, vous pouvez arrêter le serveur du client comme ceci:

>>> r1.shutdown()

Redis sauvegarde sur le disque juste avant qu'il ne se arrête donc c'est une bonne façon d'assurer toutes les écritures ont été persistaient.

Alors, où est le Redis DB? Il est stocké dans l'emplacement par défaut avec le nom de fichier par défaut, qui est dump.rdb sur votre répertoire.

Pour changer cela, modifier le fichier redis.conf (inclus dans la distribution source Redis); aller à la ligne de départavec:

# The filename where to dump the DB
dbfilename dump.rdb

changement dump.rdb à tout ce que vous voulez, mais laissez l'extension .rdb en place.

Ensuite, pour changer le chemin du fichier, trouver cette ligne dans redis.conf:

# Note that you must specify a directory here, not a file name

La ligne ci-dessous qui est l'emplacement du répertoire de la base de données Redis. Modifier afin qu'il récite l'emplacement que vous voulez. Sauvegardez vos modifications et renommer ce fichier, mais conserver l'extension .conf. Vous pouvez stocker ce fichier de configuration où vous le souhaitez, juste fournir le chemin complet et le nom de ce fichier de configuration personnalisé sur la même ligne lorsque vous démarrez un serveur Redis:

Alors, la prochaine fois que vous démarrez un serveur Redis, vous devez le faire comme si (de l'invite du shell:

$> cd /usr/local/bin    # or the directory in which you installed redis 

$> redis-server /path/to/redis.conf

Enfin, la liste pypi un package spécifique pour la mise en œuvre d'une base de données graphique dans Redis. Le paquet est appelé Redis-graphique et je l'ai pas utilisé.

Answer 2

Il y a un SQLlite3 soutenu la mise en œuvre NetworkX appelé Cloudlight. https://www.assembla.com/spaces/cloudlight/wiki/Tutorial

Answer 3

Je serais curieux de voir la meilleure façon d'utiliser le disque dur. Dans le passé, je l'ai fait plusieurs graphiques et les avez enregistrées sous forme de fichiers .dot. Puis genre de mélange certains d'entre eux dans la mémoire en quelque sorte. Pas la meilleure solution si.

from random import random
import networkx as nx

def make_graph():
    G=nx.DiGraph()
    N=10
    #make a random graph
    for i in range(N):
        for j in range(i):
            if 4*random()<1:
                G.add_edge(i,j)

    nx.write_dot(G,"savedgraph.dot")
    return G

try:
    G=nx.read_dot("savedgraph.dot")
except:
    G=make_graph() #This will fail if you don't use the same seed but have created the graph in the past. You could use the Singleton design pattern here.
print G.adj