Utilisez networkx, une bibliothèque qui gère les graphiques en python (Partie 2: Tutoriel)

Cours liés à l'analyse de réseau d'Eric Ma à Datacamp (Introduction à l'analyse de réseau en Python -network-analysis-in-python)) était très bon, je vais donc résumer ce que j'ai appris sur networkx en fonction du contenu du cours.

Qu'est-ce qui s'est passé

1. Un résumé du didacticiel sur le site Web officiel de networkx.

environnement

L'environnement docker créé la dernière fois a été modifié comme suit.

host

$ cat /etc/lsb-release 
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=16.04
DISTRIB_CODENAME=xenial
DISTRIB_DESCRIPTION="Ubuntu 16.04.6 LTS"

Dockerfile

FROM nvcr.io/nvidia/tensorflow:19.12-tf1-py3  

ARG DEBIAN_FRONTEND=noninteractive
             
RUN apt-get update && \
    apt-get install -y python3-tk && \
    pip install --upgrade pip && \
    pip install networkx && \
    pip install nxviz && \
    pip install pytest && \
    pip install nose

Élément graphique

Un graphe est défini par une collection de nœuds (nœuds ou sommets) et une paire de nœuds appelés arêtes (arêtes, ou liens, etc.). Ici, un nœud est composé d'objets hachables (texte, images, objets définis en XML, autres graphes, etc.). En ce qui concerne le concept de hachage, Explication de cet article était facile à comprendre.

python_shell

>>> import networkx as nx
>>> G = nx.Graph()
>>> G2 = nx.Graph([(0, 1), (1, 2), (2, 0)])  #Spécifiez les nœuds et les arêtes

Ajouter des nœuds et des arêtes

python

>>> G.add_node(1)      　　　　#Ajouter un nœud
>>> G.add_node('one')　　　　　
>>> G.add_nodes_from([2, 3])　#Ajouter plusieurs nœuds
>>> G.add_nodes_from(['two', 'three'])　

>>> G.add_edge(1, 2)          #Ajouter un bord
>>> G.add_edges_from([('one',1), (2, 3), (2, 4), (2, 'two'),  (2, 'three'), ('two', 'three')])

Supprimer les nœuds et les arêtes

python

>>> G.remove_node(1)                         #Les arêtes de connexion sont également supprimées
>>> G.remove_nodes_from(['one', 'Two'])      #Supprimer plusieurs nœuds

>>> G.remove_edge('one', 1)　　　　　　　　　　 #Supprimer un bord
>>> G.remove_edges_from([(2, 3), (2, 4)])　　 #Supprimer plusieurs bords
>>> G.clear()                                #Supprimer tous les éléments

Affichage du graphique

python

>>> import matplotlib.pyplot as plt
>>> nx.draw(G, with_labels=True)             #Étiquette
>>> plt.show()

Création de graphique automatique

networkx a la capacité de créer automatiquement plusieurs types de graphiques. Site officiel Il y a une explication détaillée, mais le graphique principal est ce blog //piroshhh.hatenablog.com/entry/2016/04/06/221852) a été utile. Après tout, il est plus facile à comprendre en regardant la structure du graphique, j'ai donc créé le code graph_generator_classic.py pour créer le graphique classique sur le site officiel ci-dessus. (Graph_generator_small.py pour les petits graphiques et graph_generator_random.py pour les graphiques aléatoires seront également créés.) (Remarque: si vous créez un environnement avec le Dokerfile ci-dessus, la version de networkx sera 2.3. Networkx2.4 est Vous avez besoin de $ pip install --upgrade networkx si nécessaire. )

python

>>> H = nx.path_graph(7)
>>> J = nx.turan_graph(5, 2)
>>> K = nx.star_graph(5)

Ici, dans networkx, vous pouvez extraire des nœuds et des arêtes d'autres graphiques et les ajouter à un autre nœud, ou vous pouvez faire de l'autre graphique lui-même un nœud.

python

>>> G.add_nodes_from(H)　　　　　　  #Ajouter uniquement les nœuds dans le graphique H
>>> G.add_edges_from(H.edges)　　　 #Ajouter uniquement les arêtes du graphe H

>>> G.add_node(H)    　　　　　　    #Ajouter le graphe H comme un nœud du graphe G
>>> G.add_nodes_from([J, K])

Extraction d'informations d'éléments graphiques

Il existe quatre propriétés de base qui décrivent les éléments du graphique. En prenant le graphe de roue suivant avec 7 nœuds comme exemple, ce sera comme suit.

python

>>> G = nx.wheel_graph(7)
>>> nx.draw(G, with_labels=True)
>>> plt.show()

>>> G.nodes
NodeView((0, 1, 2, 3, 4, 5, 6))
>>> G.edges
EdgeView([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (1, 2), (1, 6), (2, 3), (3, 4), (4, 5), (5, 6)])
>>> G.adj　　　　　　　　#Informations sur les nœuds voisins
AdjacencyView({0: {1: {}, 2: {}, 3: {}, 4: {}, 5: {}, 6: {}}, 1: {0: {}, 2: {}, 6: {}}, 2: {0: {}, 1: {}, 3: {}}, 3: {0: {}, 2: {}, 4: {}}, 4: {0: {}, 3: {}, 5: {}}, 5: {0: {}, 4: {}, 6: {}}, 6: {0: {}, 5: {}, 1: {}}})
>>> G.degree　　　　　　#Nombre de nœuds adjacents
DegreeView({0: 6, 1: 3, 2: 3, 3: 3, 4: 3, 5: 3, 6: 3})

Puisque la valeur de retour est similaire au type de dictionnaire, vous pouvez effectuer une boucle avec .items () ou effectuer une recherche dans l'attribut avec .data ('mot'). De plus, il peut être converti en listes, ensembles, dictionnaires et taples par affectation.

Accès aux attributs des éléments graphiques

Les attributs des nœuds et des arêtes du graphe sont accessibles par abonnement.

python

>>> G.nodes[0]           #Accès aux attributs du nœud 0
{}
>>> G.edges[0,1]　　　　　#Bord(0, 1)Accès aux attributs de
{}
>>> G.adj[0]　　　　　　　 #Accès à l'arête adjacente au nœud 0
AtlasView({1: {}, 2: {}, 3: {}, 4: {}, 5: {}, 6: {}})
>>> G.degree[0]　　　　　　#Nombre de nœuds adjacents du nœud 0
6

Les attributs des éléments graphiques peuvent être ajoutés avec la description suivante.

python

>>> G.nodes[0]['color'] = 'blue'
>>> G.edges[0,1]['weight']=0.1

>>> G.nodes[0]
{'color': 'blue'}
>>> G.edges[0,1]
{'weight': 0.1}
>>> G.adj[0]
AtlasView({1: {'weight': 0.1}, 2: {}, 3: {}, 4: {}, 5: {}, 6: {}})

Les attributs montrés dans G.adj [0] sont des attributs de bord, pas des attributs de nœud. Les attributs couramment utilisés, tels que les poids, sont également écrits comme suit.

python

>>> G.add_weighted_edges_from([(0, 1, 0.1), (0, 2, 0.2), (0, 3, 0.3), (0, 4, 0.4), (0, 5, 0.5), (0, 6, 0.6)])
>>> G.adj[0]
AtlasView({1: {'weight': 0.1}, 2: {'weight': 0.2}, 3: {'weight': 0.3}, 4: {'weight': 0.4}, 5: {'weight': 0.5}, 6: {'weight': 0.6}})

Si vous souhaitez supprimer l'attribut, écrivez comme suit.

python

>>> del G.node[1]['color']
>>> del G.edges[0,1]['weight']

Le graphique dessiné en spécifiant d'autres attributs ressemble à ceci. Le code peut être trouvé sur draw_graph.py. (Ce document officiel et Cet article ) A été mentionnée.)

Type de graphique

En plus des graphiques non orientés que nous avons traités jusqu'à présent, il existe également des graphiques orientés avec des arêtes et des multi-graphes qui peuvent définir plusieurs arêtes entre la même paire de nœuds. Concernant les types de graphes, l'explication de cet article était facile à comprendre.

python

>>> GG = nx.Graph()          #Graphique non orienté
>>> DG = nx.DiGraph()        #Graphique dirigé
>>> MG = nx.MultiGraph()     #Graphique non dirigé multiple
>>> MG = nx.MultiDiGraph()   #Graphique orienté multiple

Pour les graphes orientés, vous pouvez utiliser nx.out_degree () et nx.in_degree () pour compter les nœuds adjacents séparément en fonction de la direction des arêtes. Dans nx.degree (), la somme des deux est donnée.

Opération graphique

Le traitement entre les graphiques pour les graphiques est également défini. Concernant le résultat du traitement, je me suis également référé à cet article. J'ai également écrit le code graph_operation.py pour dessiner ces graphiques.

Graphique partiel

Un graphe défini par seulement quelques nœuds du graphe est appelé graphe partiel. Par exemple, à partir du graphe complet avec 5 nœuds à gauche, le graphe partiel constitué de l'ensemble de nœuds [1,2,3,4] se trouve à droite. Parmi les arêtes contenues dans le graphe d'origine, seules les arêtes entre l'ensemble de nœuds sélectionné sont incluses dans le graphe partiel.

python

>>> Ga = nx.complete_graph(5)
>>> nbunch = [1,2,3,4]
>>> H = nx.subgraph(Ga, nbunch)

Union or Disjoint-Union of Graph Un processus appelé union / disjoint-union, qui est la somme des graphes, est défini. D'une manière générale, l'union est la somme des nœuds et des arêtes, mais networkx suppose que les graphes G1 et G2 n'incluent pas le même nœud (disjoint). Si vous voulez trouver l'union de deux graphes contenant des nœuds avec le même nom, utilisez disjoint_union ou utilisez l'attribut rename in union pour renommer les nœuds contenus dans chaque graphique. Pour le concept d'union disjointe de graphes, cet article wikipedia a été utile.

python

>>> Ga = nx.complete_graph(5)
>>> Gb = nx.ladder_graph(5)
>>> H = nx.union(Ga, Gb, rename=('a-','b-'))   #Lors de l'utilisation de l'union
>>> H = nx.disjoint_union(Ga, Gb)　　　　　　　　#disjoint_Lors de l'utilisation de l'union

Graphique produit direct

Le graphique de produit direct constitué des Ga et Gb ci-dessus est le suivant.

python

>>> H = nx.cartesian_product(Ga, Gb)

compose Le graphique comose constitué des Ga et Gb ci-dessus est le suivant. Comoise est un graphe dans lequel les nœuds du même nom sont partagés et configurés.

python

>>> nx.compose(Ga, Gb)

Compliment

Un graphe composé d'arêtes qui ne sont pas définies entre les nœuds du graphe d'origine est appelé graphe supplémentaire. Par exemple, à partir du graphique en échelle sur le côté gauche, le graphique supplémentaire qui est composé se trouve sur le côté droit.

python

>>> nx.complement(Gb)

Conversion entre graphiques orientés et non orientés

Il y a aussi le processus de conversion des graphiques dirigés et non dirigés. Maintenant, si vous convertissez un graphique non orienté en un graphique orienté, les arêtes auront les deux directions.

python

>>> H = nx.to_directed(Ga)
>>> H = nx.to_undirected(Ga)

Enregistrer le graphique

Vous pouvez enregistrer le graphique créé dans un fichier ou le charger à partir d'un fichier.

python

>>> nx.write_gml(red, "test.gml")
>>> G = nx.read_gml("test.gml")

Article associé

• Utilisez networkx, une bibliothèque qui gère les graphiques avec python (Partie 1: Construction de l'environnement)
• Utilisez networkx, une bibliothèque qui gère les graphiques avec python (Partie 2: Tutoriel)