[Python] Networkx 패키지 이용 그래프 그리기 (1)

 

 

In [53]:

from IPython.core.display import display, HTML
display(HTML("<style>.container { width:90% !important; }</style>"))

 

 

In [2]:

!pip install networkx

 

Requirement already satisfied: networkx in c:\users\thdus\anaconda3\lib\site-packages (2.5)
Requirement already satisfied: decorator>=4.3.0 in c:\users\thdus\anaconda3\lib\site-packages (from networkx) (4.4.2)

In [5]:

!pip install plotly

 

Collecting plotly
  Downloading plotly-5.11.0-py2.py3-none-any.whl (15.3 MB)
Collecting tenacity>=6.2.0
  Downloading tenacity-8.1.0-py3-none-any.whl (23 kB)
Installing collected packages: tenacity, plotly
Successfully installed plotly-5.11.0 tenacity-8.1.0

In [6]:

# !pip install networkx
# !pip install plotly

# networkx library 불러들이기
import networkx as nx
# plotly 시각화 툴 library 불러들이기
import plotly.graph_objects as go

In [12]:

import random

In [15]:

# 임의의 node 생성
node_list = [chr(i) for i in range(65, 77)]
node_list

Out[15]:

['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L']

In [16]:

# 임의의 from-to edge 생성
def draw_number(length) :
    from_index = random.randint(0, length)
    to_index = random.randint(0, length)
    return from_index, to_index
from_list = []
to_list = []
counter = 20 # ??
i = 0 
while i < counter : 
    from_index, to_index = draw_number(len(node_list) - 1)
    if from_index == to_index :
        continue
    from_list.append(node_list[from_index])
    to_list.append(node_list[to_index])
    i += 1

In [18]:

print(from_list)
print(to_list)

 

['G', 'H', 'A', 'D', 'E', 'A', 'G', 'G', 'K', 'A', 'E', 'D', 'C', 'L', 'B', 'G', 'L', 'H', 'C', 'D']
['L', 'A', 'L', 'A', 'I', 'D', 'E', 'D', 'I', 'D', 'G', 'I', 'I', 'G', 'E', 'K', 'B', 'D', 'A', 'L']

In [30]:

# 빈 그래프 생성
G = nx.Graph() 

# 빈 그래프에 node와 edge 추가
G.add_edges_from(list(zip(from_list, to_list)))

In [35]:

print("node 리스트: ", G.nodes, '\n')
print("edge 리스트: ", G.edges)

 

node 리스트:  ['G', 'L', 'H', 'A', 'D', 'E', 'I', 'K', 'C', 'B'] 

edge 리스트:  [('G', 'L'), ('G', 'E'), ('G', 'D'), ('G', 'K'), ('L', 'A'), ('L', 'B'), ('L', 'D'), ('H', 'A'), ('H', 'D'), ('A', 'D'), ('A', 'C'), ('D', 'I'), ('E', 'I'), ('E', 'B'), ('I', 'K'), ('I', 'C')]

In [37]:

import matplotlib.pyplot as plt

In [42]:

# nx 라이브러리 이용 시각화 
# random layout 사용
plt.figure(figsize = (15, 10))
nx.draw_random(G, with_labels = True, font_weight = 'bold', node_size = 1000)
plt.show()

 

In [43]:

# spring layout 사용
plt.figure(figsize = (15, 10))
nx.draw_spring(G, with_labels = True, font_weight = 'bold', node_size = 1000)
plt.show()

 

In [46]:

# plotly 이용 시각화
pos = nx.spring_layout(G, k = 0.5, iterations = 100)  #k는 노드 간의 최소 간격을 의미
for node, position in pos.items() :
    G.nodes[node]['pos'] = position

In [48]:

# plotly 형식으로 그래프 정보 입력
# edge 정보
edge_trace = go.Scatter(x = [], 
                        y = [], 
                        line = dict(width = 0.5, color = "grey"), 
                        hoverinfo = 'none',  # hoverinfo : 그래프 정보를 의미하는 말풍선
                        mode = 'lines')  

for edge in G.edges() :
    x0, y0 = G.nodes[edge[0]]['pos']
    x1, y1 = G.nodes[edge[1]]['pos']
    edge_trace['x'] += tuple([x0, x1, None])
    edge_trace['y'] += tuple([y0, y1, None])    

In [49]:

# node 정보
node_trace = go.Scatter(x = [], 
                        y = [], 
                        text = [], 
                        mode = 'markers+text', 
                        hoverinfo = 'text', 
                        marker = dict(showscale = True, 
                                      colorscale = 'rainbow', 
                                      reversescale = True, 
                                      color = [], 
                                      size = 50, 
                                      colorbar = dict(thickness = 1, 
                                                      title = "colorbar", 
                                                      xanchor = "left", 
                                                      titleside = 'top'), 
                                      line = dict(width = 0)))
for node in G.nodes() :
    x, y = G.nodes[node]['pos']
    node_trace['x'] += tuple([x])
    node_trace['y'] += tuple([y])

In [51]:

for node, adj in enumerate(G.adjacency()) :
    node_trace['marker']['color'] += tuple([len(adj[1])])
    node_info = adj[0]
    node_trace['text'] += tuple([node_info])

In [52]:

title = "Network Graph Demonstration"
fig = go.Figure(data = [edge_trace, node_trace],
                layout = go.Layout(title = "network graph with plotly",
                                   titlefont = dict(size = 16),
                                   showlegend = False,
                                   hovermode = 'closest',
                                   margin = dict(b = 21, l = 5, r = 5, t = 40),
                annotations = [dict(text = " ",
                                    showarrow = False,
                                    xref = "paper", yref = "paper")],
                xaxis = dict(showgrid = False, zeroline = False,
                             showticklabels = False, mirror = True),
                yaxis = dict(showgrid = False, zeroline = False,
                             showticklabels = False, mirror = True)))
fig.show()

 

 

 

In [ ]: