그래프를 다루는 파이썬의 NetworkX 라이브러리 맛보기

1. NetworkX

 

그래프를 생성, 변경, 시각화하고 구조와 변화를 분석하는 함수들을 제공하는 파이썬의 라이브러리

 

속도가 느리나 사용이 편함

 

비슷한 라이브러리로 Snap.py(아마 Snap이 이름이겠지??)는 속도가 빠르나 사용이 불편하다고함

 

 

2. 그래프 시각화

 

nx.Graph()로 무방향 그래프, nx.DiGraph()로 방향 그래프를 초기화

 

#그래프의 생성과 초기화

G = nx.Graph()                     # 방향성이 없는 그래프
DiGraph = nx.DiGraph()             # 방향성이 있는 그래프

 

 

초기화된 그래프 객체에 add_node를 이용해 그래프에 node를 추가할 수 있음

 

G.add_node(1)

print("Num of nodes in G: " + str(G.number_of_nodes()))
print("Graph: " + str(G.nodes) + "\n")

Num of nodes in G: 1
Graph: [1]

 

1번 노드 중복으로 넣는다고 1번 노드가 2개가 들어가고 그러지는 않는듯?

 

# 더욱 많은 정점 추가

print("#Add vertex 2 ~ 10") 

for i in range(1, 11):                              # 정점 2 ~ 10 추가
    
    G.add_node(i)

print("Num of nodes in G : " + str(G.number_of_nodes()))
print("Graph : " + str(G.nodes) + "\n")

#Add vertex 2 ~ 10
Num of nodes in G : 10
Graph : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

 

add_edge로 두 node를 연결하는 link를 추가할 수 있음

 

#간선으로 연결하면 순서쌍으로 생성이 되는듯?

print("###### Add Edge to Graph ######")
G = nx.Graph()
print("#Add edge (1, 2)")
G.add_edge(1,2)                                #정점 1과 2 사이에 간선 추가
print("Graph: " + str(G.edges) + "Wn")         #간선 목록 반환

###### Add Edge to Graph ######
#Add edge (1, 2)
Graph: [(1, 2)]

 

 

sptring_layout으로 정점의 위치를 결정

 

draw_networkx_nodes, draw_networkx_edges로 노드와 간선을 표시

 

draw_networkx_labels는 노드에 라벨을 붙여줌

 

# 그래프를 시각화
# 정점의 위치 결정

# 정점의 위치는 랜덤으로 아무렇게나 결정하면 복잡해진다. 
# 정점의 위치를 신중하게 결정시켜줌
pos = nx.spring_layout(G) 

#정점의 색과 크기를 지정하여 출력함
im = nx.draw_networkx_nodes(G, pos, node_color = "red", node_size = 100)

#간선 출력
nx.draw_networkx_edges(G, pos)

#각 정점의 라벨을 출력
nx.draw_networkx_labels(G, pos, font_size = 10, font_color = "black")
plt.show()

 

 

 

 

3. 그래프 표현

 

networkx를 이용해서 그래프를 인접리스트, 간선리스트, 인접행렬, 희소행렬로 표현 가능함

 

다음과 같이 그래프 초기화

 

G = nx.Graph() #무방향 그래프

f = [[1,2],[2,3],[3,4],[4,5],[5,6],[6,7],[7,8],[8,9],[9,10],[10,1]]

for edge in f:
    
    v1,v2 = edge
    G.add_edge(v1,v2)

print(G.edges)

 

nx.to_dict_of_lists()는 그래프를 인접 리스트로 저장한다

 

#그래프를 인접 리스트로 저장

print("###### Graph to List #######")
ListGraph = nx.to_dict_of_lists(G)

for v in ListGraph:
    
    print(str(v) + " : " + str(ListGraph[v]))

###### Graph to List #######
1 : [2, 10]
2 : [1, 3]
3 : [2, 4]
4 : [3, 5]
5 : [4, 6]
6 : [5, 7]
7 : [6, 8]
8 : [7, 9]
9 : [8, 10]
10 : [9, 1]

 

nx.to_edgelist()로 그래프를 간선 리스트로 저장함

 

#그래프를 간선 리스트로 저장
print("###### Graph to EdgeList ######")

EdgeListGraph = nx.to_edgelist(G)

for e in EdgeListGraph:
    
    v1,v2,w = e
    print(v1,v2)

###### Graph to EdgeList ######
1 2
1 10
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10

 

nx.to_numpy_array()는 그래프를 인접 행렬로 저장시켜줌

 

#그래프를 인접 행렬(일반 행렬)로 저장

print("###### Graph to numpy array ######")

NumpyArrayGraph = nx.to_numpy_array(G)

print(NumpyArrayGraph)

###### Graph to numpy array ######
[[0. 1. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 1. 0. 0. 0. 0. 0. 0. 0.]
 [0. 1. 0. 1. 0. 0. 0. 0. 0. 0.]
 [0. 0. 1. 0. 1. 0. 0. 0. 0. 0.]
 [0. 0. 0. 1. 0. 1. 0. 0. 0. 0.]
 [0. 0. 0. 0. 1. 0. 1. 0. 0. 0.]
 [0. 0. 0. 0. 0. 1. 0. 1. 0. 0.]
 [0. 0. 0. 0. 0. 0. 1. 0. 1. 0.]
 [0. 0. 0. 0. 0. 0. 0. 1. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 1. 0.]]

 

nx.to_scipy_sparse_array()는 그래프를 희소 행렬로 저장

 

#그래프를 인접행렬(희소 행렬)로 저장

print("###### Graph to Scipy sparse array ######")

SparseMatrixGraph = nx.to_scipy_sparse_array(G)

print(SparseMatrixGraph)

###### Graph to Scipy sparse array ######
  (0, 1)	1
  (0, 9)	1
  (1, 0)	1
  (1, 2)	1
  (2, 1)	1
  (2, 3)	1
  (3, 2)	1
  (3, 4)	1
  (4, 3)	1
  (4, 5)	1
  (5, 4)	1
  (5, 6)	1
  (6, 5)	1
  (6, 7)	1
  (7, 6)	1
  (7, 8)	1
  (8, 7)	1
  (8, 9)	1
  (9, 0)	1
  (9, 8)	1

 

이외에도 기능은 많이 있을건데

 

딥러닝에서 그래프를  표현하는데 networkX라는 라이브러리를 사용한다.. 이 정도?

 

기억해두면 찾아보면서 쓰는거지