[PYTHON] Die Netzwerkanalyse ist eine Weblinkstruktur ②

Einführung

Die Linkstruktur des Webs ist ein großes Netzwerk, das Sie problemlos abspielen können. Netzwerkanalyse ist eine Linkstruktur im Web ① Wir werden das erworbene Netzwerk tatsächlich analysieren. Dies kann mehr als 3 Stunden dauern, versuchen Sie es also bitte mit Ihrem Herzen. Quellcode usw. sind auf Author GitHub verfügbar.

Programmübersicht

1. Erstellen Sie einen gerichteten Graphen mit networkx aus einer benachbarten Matrix
2. Spielen Sie mit dem Seitenrang, der Zentralität und der starken Zerlegung der Verbindungskomponenten
3. Spaß! !! !!

NetworkX Netzwerkanalysemodul.

• Dem Knotenrand des Diagramms können mehrere Informationen zugewiesen werden.
• Sie können problemlos Netzwerkanalysen wie die Zerlegung zentraler / stark verknüpfter Komponenten durchführen.
• Schöne Visualisierung.

Referenzseite

~~ Ich konnte es mir nicht leisten, die Rezepte zusammenzustellen ~~, also werde ich die Websites zusammenstellen, auf die ich verwiesen habe.

Offizielles NetworkX-Dokument Qiita: [Python] Zusammenfassung der grundlegenden Verwendung von Network X 2.0 PyQ: Graphentheorie und Netzwerk X [DATUM STUDIO: Ich habe versucht, das nationale Familiennamen-Netzwerk mit networkx zu visualisieren](https://datumstudio.jp/blog/networkx%E3%81%A7%E5%85%A8%E5%9B%BD%E5%90% 8D% E5% AD% 97% E3% 83% 8D% E3% 83% 83% E3% 83% 88% E3% 83% AF% E3% 83% BC% E3% 82% AF% E3% 82% 92% E5% 8F% AF% E8% A6% 96% E5% 8C% 96% E3% 81% 97% E3% 81% A6% E3% 81% BF% E3% 81% 9F)

Vorbereitung

import.py

from urllib.request import urlopen
from bs4 import BeautifulSoup

import networkx as nx

from tqdm import tqdm_notebook as tqdm
import numpy as np
from scipy import stats
import pandas as pd
pd.options.display.max_colwidth = 500

import seaborn as sns
import matplotlib.pyplot as plt
%matplotlib inline

import re

Die Netzwerkanalyse ist eine Linkstruktur im Web (.

Diagrammerstellung

make_graph.py

G = nx.DiGraph()

for i in tqdm(range(len(adj))):
    for j in range(len(adj)):
        if adj[i][j]==1:
            G.add_edge(i,j)

nx.DiGraph() Erstellen Sie ein gerichtetes Diagramm.

G.add_edge(i,j) Fügen Sie dem Diagramm "G" eine Kante hinzu. ~~ Es gibt eine intelligentere Möglichkeit, es hinzuzufügen. Jep. ~~

Berechnung der Grafikfunktionen

cal_centrality.py

degree = nx.degree_centrality(G)
print("degree completed")

closeness = nx.closeness_centrality(G)
print("closeness completed")

betweenness = nx.betweenness_centrality(G)
print("betweenness completed")

pagerank = nx.pagerank(G)
print("pagerank completed")

strong_connection = sorted(nx.strongly_connected_components(G), key=lambda x: len(x), reverse=True)
print("strongly　connected　components completed")

nx.degree_centrality(G) Ordnungszentralität. Die Summe der ausgehenden und eingehenden Bestellungen für jeden Knoten. nx.degree_centrality (G) gibt den Wert der Gradzentralität geteilt durch $ n-1 $ zurück. ($ n $: Anzahl der Scheitelpunkte des Graphen)

nx.closeness_centrality(G) Nähe Zentralität. Die Umkehrung der durchschnittlichen kürzesten Pfadlänge von jedem Knoten zu allen anderen Knoten.

nx.betweenness_centrality(G) Mediationszentralität. Die Häufigkeit, mit der der kürzeste Weg von allen anderen Knoten zu erreichbaren Knoten durch jeden Knoten verläuft.

nx.strongly_connected_components(G) Stark verknüpfte Zersetzung der Komponenten. sorted(nx.strongly_connected_components(G), key=lambda x: len(x), reverse=True) Auf diese Weise wird ein Array zurückgegeben, das in absteigender Reihenfolge nach der Anzahl der Scheitelpunkte der stark verbundenen Komponente sortiert ist.

Erstellen Sie "DataFrame" von "Pandas"

make_df.py

df = pd.DataFrame({"ID": range(len(url_list)), "URL": url_list)

df["category"] = df["URL"].apply(lambda s: s[s.index(":")+3:s.index("/", 8)])

df.loc[df['URL'] ==start_url, 'category'] = "start_page"

df["degree_centrality"] = df["ID"].map(degree)
df["closeness_centrality"] = df["ID"].map(closeness)
df["betweenness_centrality"] = df["ID"].map(betweenness)
df["Pagerank"] = df["ID"].map(pagerank)

df = df.assign(Pagerank_rank=len(df)-stats.mstats.rankdata(df["Pagerank"])+1)
df = df.assign(degree_centrality_rank=len(df)-stats.mstats.rankdata(df["degree_centrality"])+1)
df = df.assign(closeness_centrality_rank=len(df)-stats.mstats.rankdata(df["closeness_centrality"])+1)
df = df.assign(betweenness_centrality_rank=len(df)-stats.mstats.rankdata(df["betweenness_centrality"])+1)

df.to_csv(f"./{fname}.csv")

df["category"] Klassifizieren Sie jede Seite des Netzwerks nach der obersten Seite. [Die Netzwerkanalyse ist eine Linkstruktur im Web.](Https://qiita.com/takahiro_hasegawa/items/2d2a979ead0522c112a2#%E3%83%AA%E3%83%B3%E3%82%AF%E6%A7%8B % E9% 80% A0% E8% A7% A3% E6% 9E% 90% E3% 81% AE% E9% 96% A2% E6% 95% B0) Geben Sie in url_list die URL ein, die mit http beginnt Gelagert. Diese URLs werden nach Top-Seiten klassifiziert und als "Kategorie" verwendet. Nützlich für die Visualisierung.

df.assign(Pagerank_rank=len(df)-stats.mstats.rankdata(df["###"])+1) Fügen Sie Ranglisten verschiedener Zentralitäten als neue Spalten hinzu. stats.mstats.rankdata nimmt den Rang des gleichen Wertes wie ihr Durchschnittswert an. stats.mstats.rankdata rangiert in aufsteigender Reihenfolge von 0. Nehmen Sie die umgekehrte Reihenfolge und fügen Sie die Reihenfolge vom 1. Platz zum DataFrame hinzu.

Grafikvisualisierungsfunktion

draw_graph.py

pos = nx.spring_layout(G)

nx.spring_layout(G) Berechnen Sie die Position, um das Diagramm gut zu zeichnen. Wenn Sie "pos" nicht außerhalb der Funktion definieren, wird jedes Mal ein Diagramm mit einer anderen Form gezeichnet.

draw_graph.py

def draw_char_graph(G, pos, title, node_type):
    plt.figure(figsize=(15, 15))

    nx.draw_networkx_edges(G,
                           pos=pos,
                           edge_color="gray",
                           edge_cmap=plt.cm.Greys,
                           edge_vmin=-3e4,
                           width=0.3,
                           alpha=0.2,
                           arrows=False)
    
    if node_type=="centrality":
        node1=nx.draw_networkx_nodes(G,
                                     pos=pos,
                                     node_color="blue",
                                     alpha=0.8,
                                     node_size=[ d["closeness"]*300 for (n,d) in G.nodes(data=True)])

        node2=nx.draw_networkx_nodes(G,
                                     pos=pos,
                                     node_color="green",
                                     alpha=0.8,
                                     node_size=[ d["degree"]*2000 for (n,d) in G.nodes(data=True)])

        node3=nx.draw_networkx_nodes(G,
                                     pos=pos,
                                     node_color="yellow",
                                     alpha=0.8,
                                     node_size=[ d["betweenness"]*5000 for (n,d) in G.nodes(data=True)])

        node4=nx.draw_networkx_nodes(G,
                                     pos=pos,
                                     node_color="red",
                                     alpha=0.8,
                                     node_size=[ d["pagerank"]*10000 for (n,d) in G.nodes(data=True)])
        
        plt.legend([node1, node2, node3,node4], ["closeness", "degree","betweenness","pagerank"],markerscale=1,fontsize=18)
        plt.title(f"centrality: {start_url}\n {nx.number_of_nodes(G)} nodes,{nx.number_of_edges(G)} edges",fontsize=25)
        
    elif node_type=="simple":
        nx.draw_networkx_nodes(G,
                               pos=pos,
                               node_color="blue",
                               node_size=5)
        plt.title(f"{start_url}\n {nx.number_of_nodes(G)} nodes,{nx.number_of_edges(G)} edges",fontsize=25)
        
    elif node_type=="strong_connection":
        nx.draw_networkx_nodes(G,
                               pos=pos,
                               node_color="black",
                               node_size=10)
        
        node1=nx.draw_networkx_nodes(G,
                                     pos=pos,
                                     node_color="blue",
                                     nodelist=strong_connection[0],
                                     node_size=30)
        
        node2=nx.draw_networkx_nodes(G,
                                     pos=pos,
                                     node_color="yellow",
                                     nodelist=strong_connection[1],
                                     node_size=30)
        
        node3=nx.draw_networkx_nodes(G,
                                     pos=pos,
                                     node_color="red",
                                     nodelist=strong_connection[2],
                                     node_size=30)
        
        plt.title(f"strongly connected nodes: {title}\n {nx.number_of_nodes(G)} nodes,{nx.number_of_edges(G)} edges",fontsize=25)
        plt.legend([node1, node2, node3], [f"elements: {len(strong_connection[0])} ({round(len(strong_connection[0])/nx.number_of_nodes(G)*100,2)}%)",
                                           f"elements: {len(strong_connection[1])} ({round(len(strong_connection[1])/nx.number_of_nodes(G)*100,2)}%)",
                                           f"elements: {len(strong_connection[2])} ({round(len(strong_connection[2])/nx.number_of_nodes(G)*100,2)}%)"],markerscale=1,fontsize=18)

    plt.axis('off')
    plt.savefig(f"{title}_graph_{node_type}", dpi=300)
    plt.show()

draw_char_graph(G, pos, title, node_type) Eine Funktion, die ein Diagramm zeichnet. title Der Titel des zu zeichnenden Diagramms und der Name der zu speichernden Datei node_type

Visualisierung

Streudiagramm

visualize.py

sns.pairplot(df.drop("ID", axis=1), hue='category')
plt.savefig(f'{fname}_pairplot.png')

Jeder liebt "Pair Plot".

Netzwerk

visualize.py

draw_char_graph(G, pos, fname, node_type="simple")

visualize.py

draw_char_graph(G, pos, fname, node_type="centrality")

visualize.py

draw_char_graph(G, pos, fname, node_type="strong_connection")

Ich bin mir nicht sicher, weil es zu groß ist. Wenn es sich um ein kleines Netzwerk handelt, wird es ordentlich gezeichnet.

Zentralitätsranking

visualize.py

df_important = df[(df["Pagerank_rank"]<=10) | (df["degree_centrality_rank"]<=10) | (df["closeness_centrality_rank"]<=10) | (df["betweenness_centrality_rank"]<=10)]
df_important = df_important[["URL", "Pagerank_rank", "degree_centrality_rank", "closeness_centrality_rank", "betweenness_centrality_rank"]]

df_important.to_csv(f"./{fname}_important.csv")

Es macht Spaß! !! !!