데싸(Data Science) 노트

[그래프 ML] 그래프 분해(Graph Factorization) - 파이썬 GEM (Graph Embedding Methods)

백관구 — Tue, 2 Apr 2024 17:36:39 +0900

※ 출처 : 그래프 머신러닝 (클라우디오 스타밀레 외, 김기성·장기식 옮김)

1. 그래프 분해(Graph Factorization)란

1.1. 개념

행렬 분해를 그래프 데이터, 특히 그래프의 인접 행렬에 적용한 개념입니다. 그래프 분해를 통해 그래프 구조를 저차원의 잠재 공간으로 투영(projection)하는 것을 목표로 합니다. 주어진 그래프 $G$를 작은 차원의 두 행렬 "노드 임베딩 행렬 $F$"와 "잠재 그래프 구조 행렬 $H$"의 곱으로 근사합니다.

$$G \approx F \times H$$

[그래프 ML] 행렬 분해(Matrix Factorization) - 비음수 행렬 분해(NMF), 특이값 분해(SVD), 주성분 분석(PCA)

HTML 삽입 미리보기할 수 없는 소스 ※ 출처 : 그래프 머신러닝 (클라우디오 스타밀레 외, 김기성·장기식 옮김) 1. 행렬 분해(Matrix Factorization)란 1.1. 개념 $$X \approx S \times A$$ 대규모 행렬 데이터를

data-science-note.tistory.com

1.2. 활용

행렬 분해와 마찬가지로 그래프 분해를 통해 그래프의 노드들을 저차원의 잠재 공간에 임베딩할 수 있고, 동시에 그래프의 구조적 패턴을 포착할 수 있습니다.

분야	활용
네트워크 분석	- 통신 네트워크, 소셜 네트워크 구조 분석 - 커뮤니티 구조, 중심성, 연결성 파악
데이터 마이닝 & 패턴 인식	- 대규모 데이터에서 주요 패턴, 구조 발견 - 데이터 클러스터링, 유사성 측정, 이상 탐지
생물 정보학	- 단백질 구조, 유전자 네트워크, 대사 경로 분석 - 생물학적 네트워크의 모듈성, 중요 노드 식별, 기능 예측
웹 마이닝 & 링크 분석	- 웹 페이지와 하이퍼링크 구조를 그래프로 표현하고 분석 - 페이지 랭킹, 커뮤니티 탐색, 권위 페이지 탐색
정보 검색 & 추천 시스템	- 사용자와 아이템 간 관계를 그래프로 표현하고 분석 - 협력 필터링, 관련 아이템 추천, 개별 맞춤화

2. 파이썬 GEM (Graph Embedding Methods) 라이브러리

그래프 임베딩을 위한 파이썬 라이브러리로, 다양한 알고리즘을 구현하고 있어 효과적으로 그래프 데이터를 임베딩(벡터화) 할 수 있습니다. 임베딩과 관련한 알고리즘 외에도 평가 지표, 데이터 전처리, 시각화 툴을 제공합니다.

※ GEM Paper

GEM: A Python package for graph embedding methods

Goyal et al., (2018). GEM: A Python package for graph embedding methods . Journal of Open Source Software, 3(29), 876, https://doi.org/10.21105/joss.00876

joss.theoj.org

※ GEM GitHub

GitHub - palash1992/GEM

Contribute to palash1992/GEM development by creating an account on GitHub.

github.com

2.1. 설치

pip install git+https://github.com/palash1992/GEM.git

2.2. 주요 알고리즘

LLE (Locally Linear Embedding)	지역적으로 선형인 근사를 유지하는 임베딩 기법
Laplacian Eigenmaps	그래프 라플라시안 행렬의 고유벡터를 이용해 투영하는 비선형 임베딩 기법
그래프 분해 (Graph Factorization)
고차원 근접 보존 임베딩 (HOPE; Higher-Order Proximity preserved Embedding)	고유값 분해를 통해 그래프의 구조적 특성을 유지하는 임베딩 기법
SDNE (Structural Deep Network Embedding)	준지도 학습 기반으로 구조 및 특성 정보를 포함하는 임베딩 기법
Node2Vec	노드 시퀀스에 기반한 스킵그램 모델을 활용하는 임베딩 기법

2.3. 예제 : 그래프 분해(Graph Factorization)

① 예제 그래프 생성

import networkx as nx

G = nx.barbell_graph(m1=10, m2=4)  # 예제 그래프
nx.draw(G, with_labels=True)  # 그래프 시각화

예제 그래프 생성

② 그래프 임베딩 학습 및 실행

from gem.embedding.gf import GraphFactorization

gf = GraphFactorization(d=2,  # 임베딩 차원
                        eta=1e-4,  # 확률적 경사 하강법(SGD; Stochastic Gradient Descent)의 학습률
                        regu=0.7,  # 가중치 크기에 대한 정규화 계수
                        max_iter=10000,  # SGD 최대 반복 횟수
                        data_set=None)
# 입력 그래프의 노드 임베딩 연산
gf.learn_embedding(G)
embeddings = gf.get_embedding()
print("그래프 임베딩 크기:", embeddings.shape)

그래프 임베딩 크기: (24, 2)

③ 임베딩 결과 시각화

import matplotlib.pyplot as plt

fig, sub = plt.subplots(figsize=(5, 5))
for i, V in enumerate(embeddings):
    v0, v1 = V[0], V[1]
    sub.scatter(v0, v1, s=200)
    sub.annotate(str(i), (v0, v1), fontsize=10, ha="center", va="center")
plt.show()

그래프 분해 결과

[그래프 ML] 행렬 분해(Matrix Factorization) - 비음수 행렬 분해(NMF), 특이값 분해(SVD), 주성분 분석(PCA)

백관구 — Fri, 22 Mar 2024 17:45:17 +0900

※ 출처 : 그래프 머신러닝 (클라우디오 스타밀레 외, 김기성·장기식 옮김)

1. 행렬 분해(Matrix Factorization)란

1.1. 개념

$$X \approx S \times A$$

대규모 행렬 데이터를 두 개 이상의 작은 행렬들의 곱으로 나타내는 것을 말합니다. 일반적으로 원본 행렬 $X$를 원천 행렬(source matrix) $S$와 기여도 행렬(abundance matrix) $A$의 곱으로 근사합니다. 여기서 $S$는 데이터를 구성하는 기본 요소들을, $A$는 각 요소가 원본 데이터에 기여하는 정도를 의미합니다.

1.2. 활용

고차원 데이터의 잠재적인 패턴과 구조를 발견하고, 저차원 표현으로 압축하며, 노이즈를 제거하는 등의 목적으로 사용됩니다.

* 대표적인 활용 분야
- 추천 시스템의 협업 필터링
- 신호 처리
- 텍스트 마이닝과 토픽 모델링
- 생체 정보 분석
- 예시
. 영화 평점 데이터에서 사용자-영화 행렬을 분해하면 사용자 취향과 영화 장르 정보를 추출 가능

2. 행렬 분해의 수학적 배경

행렬 분해는 주어진 $m \times n$ 차원의 행렬 $X$를 원천 행렬 $S \in \mathbb{R}^{m \times d}$와 기여도 행렬 $A \in \mathbb{R}^{d \times n}$의 곱으로 나타내는 것입니다. 여기서 $d$는 잠재 차원의 개수를 가리킵니다. 목표는 $X$와 $S \times A$의 차이를 최소화하는 행렬 $S$, $A$를 찾는 것입니다. 이를 수식으로 표현하면:

$$\min \lVert X - S \times A \rVert^{2}_{F}$$

* $\lVert \rVert_F$ : 프로브니우스 노름(Frobenius norm)

※ 프로브니우스 노름(Frobenius Norm)
* 행렬의 노름(norm) 중 하나로, 행렬의 모든 원소 값에 대한 제곱 합의 제곱근
- 유클리드 노름이 벡터의 크기를 나타내듯, 프로브니우스 노름은 행렬의 크기를 나타내는 스칼라 값임
* $m \times n$ 행렬 $A = (a_{ij})$에 대해,
$$\lVert A \rVert_{F} = \sqrt{\sum_{i, j} a_{ij}^2}$$
* 연산이 간단하고 미분이 용이하여 최적화 문제에 적합

2.1. 원천 행렬(Source Matrix)와 기여도 행렬(Abundance Matrix)

* 원천 행렬(Source Matrix) $S$
- 데이터 $X$를 구성하는 기본 요소나 패턴
- 각 열 벡터는 하나의 기본 패턴을 의미

* 기여도 행렬(Abundance Matrix) $A$
- 각 기본 패턴이 원본 데이터 $X$에 기여하는 정도
- 원소 $A_{ij}$ : $j$번째 패턴이 $i$번째 데이터 포인트에 기여하는 정도

* 예시
- 텍스트 데이터 $X$가 문서-단어 행렬일 때,
. $S$ : 단어 $m$, 토픽 $d$ 행렬
. $A$ : 토픽 $d$, 문서 $n$ 행렬로, 각 문서가 토픽을 포함하는 정도

3. 대표적인 행렬 분해 기법

3.1. 비음수 행렬 분해(NMF; Non-negative Matrix Factorization)

$$X \approx W \times H$$

* 행렬 $X \in \mathbb{R}^{m \times n}$를 두 개의 비음수 행렬 기저 행렬 $W \in \mathbb{R}^{m \times d} \ge 0 $, 계수 행렬 $H \in \mathbb{R}^{d \times n} \ge 0 $의 곱으로 분해
* 비음수 제약 조건으로 인해 부분적으로 가산적인 구조를 가지므로 해석이 용이
* 텍스트 마이닝, 음성 처리, 이미지 처리에 활용

※ 비음수 제약 조건
* 분해된 행렬 $W$, $H$의 모든 원소가 0 이상의 값을 갖는 조건
- 이 제약 조건으로 인해 데이터 $X$가 $W$와 $H$의 곱으로 표현될 때, 부분적으로 합쳐지는 구조를 가짐

* 파이썬 예제
① 예제 그래프 생성

import networkx as nx

G = nx.karate_club_graph()  # 예제 그래프
nx.draw(G)  # 그래프 시각화

예제 그래프 생성

② 그래프 인접 행렬 추출

A = nx.to_numpy_array(G)  # 그래프 인접 행렬
print("인접 행렬 크기:", A.shape)
print("인접 행렬:\n", A)

인접 행렬 크기: (34, 34)
인접 행렬:
[[0. 4. 5. ... 2. 0. 0.]
[4. 0. 6. ... 0. 0. 0.]
[5. 6. 0. ... 0. 2. 0.]
...
[2. 0. 0. ... 0. 4. 4.]
[0. 0. 2. ... 4. 0. 5.]
[0. 0. 0. ... 4. 5. 0.]]

③ NMF 모델 학습 및 실행

from sklearn.decomposition import NMF

# NMF 모델 학습
nmf = NMF(n_components=5,  # 분해할 성분 개수
          init="nndsvd",  # 초기화 방법
          max_iter=200)  # 최대 반복 횟수
W = nmf.fit_transform(A)  # 기저 행렬(W)
H = nmf.components_  # 계수 행렬(H)
print("기저 행렬(W) 크기:", W.shape)
print("계수 행렬(H) 크기:", H.shape)

기저 행렬(W) 크기: (34, 5)
계수 행렬(H) 크기: (5, 34)

④ NMF 결과 시각화

import matplotlib.pyplot as plt

fig, subs = plt.subplots(ncols=2, figsize=(10, 5))
# 기저 행렬(W) 시각화
subs[0].imshow(W, cmap="Reds")
subs[0].set_title("W")
# 계수 행렬(H) 시각화
subs[1].imshow(H, cmap="Reds")
subs[1].set_title("H")

plt.show()

NMF 결과. (왼쪽) 기저 행렬, (오른쪽) 계수 행렬

3.2. 특이값 분해(SVD; Singular Value Decomposition)

$$X = U \Sigma V^T$$

* 행렬 $X$를 직교 행렬 $U$, $V^T$와 대각 행렬 $\Sigma$ 세 개의 행렬 곱으로 분해
* 데이터의 랭크와 고유값, 고유벡터를 계산할 수 있음

* 활용
- 차원 축소 및 데이터 압축
. $\Sigma$의 큰 특이값에 대응하는 $U$, $V$의 열 벡터만 선택하여 압축
. 데이터 차원을 축소하고 노이즈를 제거
- 노드 임베딩 및 시각화
. $U$, $V$의 열 벡터를 노드 임베딩 벡터로 활용
. 상위 k개의 열 벡터를 선택하여 k차원 공간에 노드를 임베딩하고 시각화
- 그래프 클러스터링
. $U$, $V^T$의 열 벡터를 기반으로 노드 클러스터링 수행
- 신호 분석 및 주파수 영역 변환
. $\Sigma$의 특이값은 그래프 신호의 주파수 성분을 나타냄
. 주파수 영역에서 분석하거나 필터링을 수행할 수 있음

* 파이썬 예제
① SVD 실행

import numpy as np

U, Sigma, Vt = np.linalg.svd(A, full_matrices=False)  # SVD
Sigma_matrix = np.diag(Sigma)

print("U 크기:", U.shape)
print("Sigma 크기:", Sigma_matrix.shape)
print("Vt 크기:", Vt.shape)

U 크기: (34, 34)
Sigma 크기: (34, 34)
Vt 크기: (34, 34)

② SVD 결과 시각화

fig, subs = plt.subplots(ncols=3, figsize=(15, 5))
# U 시각화
subs[0].imshow(U, cmap="Reds")
subs[0].set_title("U")
# Sigma 시각화
subs[1].imshow(Sigma_matrix, cmap="Reds")
subs[1].set_title("Sigma")
# V 시각화
subs[2].imshow(Vt, cmap="Reds")
subs[2].set_title("Vt")

plt.show()

SVD 결과. (왼쪽) U, (중앙) Sigma, (오른쪽) Vt

3.3. 주성분 분석(PCA; Principal Component Analysis)

$$X \approx u + \sum z_i p_i$$

* 데이터 $X$를 평균 벡터 $u$와 주성분 벡터 $p_i$, 주성분 벡터에 투영된 X의 값인 $z_i$의 선형조합으로 나타냄
* 고차원 데이터의 차원을 낮추면서 가능한 많은 변동성을 보존하는 기법
* 차원 축소, 데이터 시각화, 노이즈 제거에 활용

* 파이썬 예제
① PCA 실행

from sklearn.decomposition import PCA

pca = PCA(n_components=5)  # PCA 모델 생성
zi = pca.fit_transform(A)  # PCA 모델 학습 및 변환
u = pca.mean_  # 평균 벡터(u)
pi = pca.components_  # 주성분 벡터(pi)

print("투영 벡터(zi) 크기:", zi.shape)
print("평균 벡터(u) 크기:", u.shape)
print("주성분 벡터(pi) 크기:", pi.shape)

투영 벡터(zi) 크기: (34, 5)
평균 벡터(u) 크기: (34,)
주성분 벡터(pi) 크기: (5, 34)

② PCA 결과 시각화

fig, subs = plt.subplots(ncols=2, figsize=(10, 5))
# 투영 벡터(zi) 시각화
subs[0].imshow(zi, cmap="Reds")
subs[0].set_title("zi")
# 계수 행렬(H) 시각화
subs[1].imshow(pi, cmap="Reds")
subs[1].set_title("pi")

plt.show()

PCA 결과. (왼쪽) 투영 벡터, (오른쪽) 주성분 벡터

4. 행렬 분해의 활용 사례

4.1. 링크 예측(Link Prediction)

* 그래프 데이터에서 노드 간 링크 존재 여부를 예측하는 문제
- (소셜 네트워크) 친구 관계 예측
- (생물학 네트워크) 단백질 간 상호작용 예측

4.2. 노드 임베딩(Node Embedding)

* 그래프 데이터의 노드를 낮은 차원의 밀집 벡터로 변환하는 작업
- DeepWalk, Node2Vec 기법

4.3. 그래프 신호 처리(Graph Signal Processing)

* 그래프 신호(Graph Signal)
- 그래프 구조의 각 노드에 스칼라 값이 할당된 형태
- 예시
. (교통 네트워크) 각 도로 구간의 혼잡도
. (센서 네트워크) 각 센서의 측정값
. (소셜 네트워크) 각 사용자의 특성값
. (분자 구조) 각 원자의 전하량

* 그래프 신호의 필터링, 압축, 보간에 이용
- 그래프 신호를 푸리에 기저(Fourier basis)로 분해

※ 그래프 푸리에 기저(Graph Fourier Basis)
* 그래프 라플라시안 행렬(Graph Laplacian Matrix)의 고유벡터(eigenvectors)로 구성되며, 이 고유벡터들은 그래프 구조를 반영하는 기저 함수 역할을 함
- 그래프 신호를 그래프 라플라시안의 고유벡터들의 선형 조합으로 표현할 수 있음
$$f = \sum \alpha_i \phi_i$$
- $f$ : 그래프 신호, $\phi_i$ : 그래프 푸리에 기저(고유벡터), $\alpha_i$ : 계수

※ 그래프 라플라시안 행렬(Graph Laplacian Matrix)
* 그래프의 구조적 특성을 포착하는 행렬
$$L = D - A$$
- $D$ : 차수 행렬(Degree matrix)
. 대각 행렬로 $D(i, i)$는 $i$번째 노드의 차수
- $A$ : 인접 행렬(Adjacency matrix)
* 주요 특성
- 대칭 행렬
- 고유값은 0 이상
- 고유벡터들은 그래프 푸리에 기저를 형성

4.4. 그래프 클러스터링(Graph Clustering)

* 그래프의 구조적 유사성을 포착
- 커뮤니티 탐지

[그래프 ML] 그래프 머신러닝 - 파이썬 NetworkX, node2vec, karateclub

백관구 — Fri, 15 Mar 2024 13:39:57 +0900

※ 출처 : 그래프 머신러닝 (클라우디오 스타밀레 외, 김기성·장기식 옮김)

1. 그래프 머신러닝이란

* 그래프 구조로 표현되는 데이터에 대해 기계학습 알고리즘을 적용하는 분야
- 비정형 구조인 그래프 데이터는 소셜 네트워크, 분자 구조, 지식망, 교통망 등 다양한 영역에서 활용

1.1. 대표적인 그래프 머신러닝 기법

* 그래프 임베딩(Graph Embeddings)
* 그래프 신경망(GNN; Graph Neural Network)
* 그래프 커널(Graph Kernels)

→ 노드 분류, 링크 예측, 그래프 생성, 클러스터링 등 작업 수행

1.2. 그래프 세분화 수준

수준(Level)	설명	예시
노드 수준 (Node-level)	개별 노드의 특성을 예측하거나 분류	- 소셜 네트워크에서 사용자의 성향 예측 - 분자 구조에서 원자의 종류 예측
간선 수준 (Edge-level)	두 노드 간 연결 고리(링크)가 존재하는지 예측	- 친구 추천 시스템 - 단백질 간 상호작용 예측
서브그래프 수준 (Subgraph-level)	그래프 내 부분 구조를 인식하거나 추출	- 분자 구조에서 특정 기능기 패턴 탐지
그래프 수준 (Graph-level)	전체 그래프의 특성이나 라벨을 예측	- 분자 물성 예측 - 그래프 생성 - 그래프 유사도 계산

그래프 세분화 수준. 출처: Graph Machine Learning with Python Part 1: Basics, Metrics, and Algorithms

2. 그래프 임베딩 또는 네트워크 임베딩(Graph or Network Embedding)

* 표현 학습(Representation learning)이라고도 하며, 이산 그래프에서 연속 영역으로 사상 함수(mapping function) $f:G \rightarrow \mathbb{R}^n$를 학습하는 작업
- 사상 함수 $f$는 그래프 $G$의 속성이 보존되는 저차원 벡터로 표현되도록 동작함

* 사상 함수를 어디에 적용하냐에 따라,
- $f:G \rightarrow \mathbb{R}^n$ : 그래프 임베딩(Graph embedding)
- $f:V \rightarrow \mathbb{R}^n$ : 노드 임베딩(Node embedding)
- $f:E \rightarrow \mathbb{R}^n$ : 간선 임베딩(Edge embedding)

* 임베딩 함수로 생성된 공간에서,
- 유사한 구조는 유클리드 거리가 짧음
- 유사하지 않은 구조는 유클리드 거리가 길게 됨

2.1. 임베딩 알고리즘 분류

알고리즘	설명	장점	단점	계산 복잡도	구조정보 활용도
얕은 임베딩 (Shallow Embedding)	노드 속성과 구조적 정보를 결합하여 임베딩 벡터를 생성	연산량 적음	구조정보 활용 제한	낮음	낮음
그래프 자동인코딩 (Graph Auto-encoding)	인코더-디코더 활용하여 노드 임베딩과 그래프 복원을 최적화	그래프 구조 포착	과적합 가능	높음	높음
근방 집계 (Neighborhood Aggregation)	근방 노드 임베딩을 반복 집계하여 대상 노드의 임베딩을 생성	구조정보 통합	하이퍼파라미터 최적화 필요	높음	중간
그래프 정규화 (Graph Regularization)	그래프 구조정보를 정규화 항으로 활용하여 임베딩 학습을 안내	구조정보 활용	정규화 강도 설정 까다로움	중간	높음

알고리즘	지도 학습	비지도 학습
얕은 임베딩 (Shallow Embedding)	O	O
그래프 자동인코딩 (Graph Auto-encoding)	-	O
근방 집계 (Neighborhood Aggregation)	O	O
그래프 정규화 (Graph Regularization)	O (준지도 학습 포함)	-

3. 얕은 임베딩(Shallow Embedding) 예시

3.1. 노드 투 벡터(Node to Vector)

* node2vec 라이브러리 설치

pip install node2vec

* 아래 그림에서 유사한 구조의 노드는 2차원 임베딩 공간에서 서로 가깝고, 구조가 다른 노드와 비교적 멀리 떨어져 있음
- 두 클리크(0~6번 노드와 11~17번 노드)가 명확히 구별됨

import networkx as nx
from node2vec import Node2Vec
import matplotlib.pyplot as plt
plt.rc("font", family="Malgun Gothic")


G = nx.barbell_graph(m1=7, m2=4)  # 바벨 그래프(Barbell graph) 생성
encoder = Node2Vec(G, dimensions=2).fit(window=10)  # 2차원 노드 임베딩(Node-level embedding) 알고리즘

fig, subs = plt.subplots(ncols=2, figsize=(11, 5))

nx.draw(G, with_labels=True, font_size=10, node_size=200, ax=subs[0])  # 바벨 그래프 시각화
subs[0].set_title("바벨 그래프")

for x in G.nodes():
    name = str(x)
    V = encoder.wv.get_vector(name)
    v0, v1 = V[0], V[1]
    
    subs[1].scatter(v0, v1, s=200)
    subs[1].annotate(name, (v0, v1), fontsize=10, ha="center", va="center")
subs[1].set_title("노드 투 벡터 결과")

plt.show()

3.2. 엣지 투 벡터(Edge to Vector)

import networkx as nx
from node2vec import Node2Vec
from node2vec.edges import HadamardEmbedder
import matplotlib.pyplot as plt
plt.rc("font", family="Malgun Gothic")


G = nx.barbell_graph(m1=7, m2=4)  # 바벨 그래프(Barbell graph) 생성
encoder = Node2Vec(G, dimensions=2).fit(window=10)  # 2차원 노드 임베딩(Node-level embedding) 알고리즘
edge_embedding = HadamardEmbedder(keyed_vectors=encoder.wv)

fig, subs = plt.subplots(ncols=2, figsize=(11, 5))

nx.draw(G, with_labels=True, font_size=10, node_size=200, ax=subs[0])  # 바벨 그래프 시각화
subs[0].set_title("바벨 그래프")

for x in G.edges():
    V = edge_embedding[(str(x[0]), str(x[1]))]
    v0, v1 = V[0], V[1]

    subs[1].scatter(v0, v1, s=200)
    subs[1].annotate(str(x), (v0, v1), fontsize=10, ha="center", va="center")
subs[1].set_title("엣지 투 벡터 결과")

plt.show()

3.3. 그래프 투 벡터(Graph to Vector)

* karateclub 라이브러리 설치

pip install karateclub

import random
from karateclub import Graph2Vec
import matplotlib.pyplot as plt
plt.rc("font", family="Malgun Gothic")


def generate_watts_strogatz_graph():  # Watts-Strogatz 그래프 랜덤 생성
    n = random.randint(5, 20)
    k = random.randint(5, n)
    p = random.uniform(0, 1)
    return nx.watts_strogatz_graph(n, k, p)


Gs = [generate_watts_strogatz_graph() for i in range(20)]
encoder = Graph2Vec(dimensions=2)  # 2차원 그래프 임베딩(Graph-level embedding) 알고리즘
encoder.fit(Gs)
graph_embedding = encoder.get_embedding()

fig, subs = plt.subplots(nrows=4, ncols=5, figsize=(15, 12))  # Watts-Strogatz 그래프 시각화
for i, (G, sub) in enumerate(zip(Gs, subs.flatten())):
    nx.draw(G, node_size=200, ax=sub)  # 그래프 시각화
    sub.text(sub.get_xlim()[0], sub.get_ylim()[-1], i, ha="left", va="top", fontsize=20)
plt.show()

fig, sub = plt.subplots(figsize=(5, 5))  # 그래프 투 벡터 임베딩 결과 시각화
for i, V in enumerate(graph_embedding):
    v0, v1 = V[0], V[1]
    sub.scatter(v0, v1, s=200)
    sub.annotate(str(i), (v0, v1), fontsize=10, ha="center", va="center")
plt.show()

[그래프 ML] 그래프 분석 라이브러리 - 파이썬 NetworkX, SNAP, igraph, graph-tool, NetworKit

백관구 — Thu, 14 Mar 2024 18:07:11 +0900

※ 이전 글 참고

[그래프 ML] 파이썬 networkx 시작하기

※ 출처 : 그래프 머신러닝 (클라우디오 스타밀레 외, 김기성·장기식 옮김) 1. 그래프(Graph) 뜻 * 개체 간의 관계를 설명하는 데 사용되는 수학적 구조 * 소셜 네트워크(팔로우), 지도(길로 이어진

data-science-note.tistory.com

☆★ 요약 ★☆

작업 규모 및 목적	적절한 라이브러리
소규모 네트워크 분석	NetworkX
대규모 네트워크 및 고성능 분석	SNAP, igraph, graph-tool, NetworKit
시각화 기능	graph-tool, NetworKit
신규 알고리즘 생성	NetworKit

라이브러리	주요 특징	장점	단점
NetworkX	- 표준 그래프 이론 알고리즘 구현 - 내장 시각화 기능 - 간편한 코드 작성 - 활발한 커뮤니티 및 문서화	- 사용법이 간단 - 많은 예제와 문서 - 다양한 알고리즘 제공	- 대규모 네트워크 처리 성능 낮음
SNAP	- 대규모 네트워크 처리 능력 - 고성능 계산 - 다양한 네트워크 파일 형식 지원	- 대규모 네트워크 처리 최적화 - 알고리즘 성능 뛰어남	- 사용법이 NetworkX에 비해 복잡함
igraph	- 빠른 계산 속도 - 다양한 파일 형식 지원 - 시각화 기능	- 대규모 네트워크 처리 가능 - 고급 네트워크 분석 기능 제공	- 개발 활동이 다소 적은 편 - NetworkX에 비해 문서화 수준 낮음
graph-tool	- 대규모 네트워크 처리 능력 - 내장 시각화 도구 - 통합 그래프 분석 파이프라인	- 계산 성능과 메모리 효율성 뛰어남 - 강력한 시각화 기능	- 코드가 다소 복잡함 - 문서화 수준이 NetworkX보다 낮음
NetworKit	- 대규모 네트워크 처리 능력 - 확장성과 유연성 - 파이썬 인터페이스 - 강력한 시각화 기능	- 계산 효율성 뛰어남 - 알고리즘 다양성 - 새로운 알고리즘 추가 용이	- 비교적 최근 개발된 라이브러리 - 문서화 수준이 낮은 편

1. NetworkX

* 네트워크와 그래프 구조를 생성, 조작, 시각화하기 위한 라이브러리

* 중·소규모 네트워크 분석에 적합
- 대규모 네트워크는 SNAP, igraph, graph-tool 라이브러리가 계산 효율성 측면에서 더 뛰어남

NetworkX — NetworkX documentation

NetworkX is a Python package for the creation, manipulation, and study of the structure, dynamics, and functions of complex networks. Software for complex networks Data structures for graphs, digraphs, and multigraphs Many standard graph algorithms Network

networkx.org

주요 특징	설명
다양한 네트워크 유형	* 무향/유향/가중/다중 간선 그래프 등 여러 유형의 네트워크를 지원 * 클래스 객체로 생성하거나 외부 파일에서 데이터를 불러올 수 있음
네트워크 분석 알고리즘	* 최단경로, 연결성, 중심성, 트리, 플로우 등 다양한 알고리즘 제공 * 이론 및 응용 분야에서 유용하게 사용됨
시각화 기능	* 내장된 시각화 도구를 통해 네트워크를 시각화 * Matplotlib, Graphviz와 통합을 통해 고급 시각화 가능
간단한 코드 작성	* 직관적이고 파이썬스러운(pythonic) 코드 구현 가능 * 표준 데이터 구조와의 연동 용이
활발한 커뮤니티와 문서화	* 꾸준한 유지보수 * 방대한 커뮤니티와 예제가 갖추어져 있음

2. SNAP (Stanford Network Analysis Platform)

* 스탠포드 대학에서 개발된 오픈소스 라이브러리로, 대규모 네트워크 분석을 위한 다양한 알고리즘과 데이터 구조를 제공

* NetworkX는 사용법이 간단하고 시각화 기능이 풍부한 반면에, SNAP은 대규모 네트워크 처리에 최적화되어 있으며 알고리즘 성능이 뛰어남
- 작은 규모의 네트워크 분석은 NetworkX가 적합하지만, 대규모 네트워크 분석은 SNAP이 더 효율적임

SNAP: Stanford Network Analysis Project

Stanford Network Analysis Project Stanford Network Analysis Platform (SNAP) is a general purpose network analysis and graph mining library. It is written in C++ and easily scales to massive networks with hundreds of millions of nodes, and billions of edges

snap.stanford.edu

주요 특징	설명
대규모 네트워크 처리	* 수억 개의 노드와 간선을 가진 대규모 네트워크를 효율적으로 처리 * 메모리 효율을 고려한 데이터 구조와 병렬 알고리즘 사용
다양한 네트워크 유형	* 무향/유향/가중/다중 간선 그래프 등 여러 유형의 네트워크를 지원
네트워크 분석 알고리즘	* 연결 요소, 단절 집합, 최단경로, 중심성 등 다양한 분석 알고리즘 제공 * 커뮤니티 탐지, 링크 예측, 시각화 기능
고성능 연산	* C++로 작성되어 높은 계산 성능 * Python, Java, C# 언어에서도 사용 가능
다양한 네트워크 파일 형식	* 간선 목록, 행렬, 페이스북 데이터 등 여러 파일 형식을 읽기/쓰기 가능

3. igraph

* 네트워크 분석을 위한 오픈소스 라이브러리로, C 라이브러리인 igraph의 핵심 기능을 Python에서 사용할 수 있도록 래핑한 라이브러리

* NetworkX와 유사한 점이 많지만, igraph는 대규모 네트워크 처리 성능이 더 뛰어나고 고급 분석 기능을 제공
- 다만, NetworkX에 비해 커뮤니티 활동이 다소 적은 편임

igraph – Network analysis software

igraph – The network analysis package igraph is a collection of network analysis tools with the emphasis on efficiency, portability and ease of use. igraph is open source and free. igraph can be programmed in R, Python, Mathematica and C/C++. igraph R p

igraph.org

주요 특징	설명
다양한 네트워크 유형	* 무향/유향/가중 그래프 등 여러 유형의 네트워크를 지원 * 대규모의 희소 행렬도 효율적으로 처리
네트워크 분석 알고리즘	* 연결성, 중심성, 커뮤니티 탐지, 레이아웃, 랜덤 네트워크 모델 등 광범위한 분석 알고리즘 제공 * 다중 모드 네트워크, 계층 네트워크, 동적 네트워크 등
고성능 연산	* C 라이브러리 기반으로 높은 계산 성능 * 대규모 네트워크 분석에 적합
다양한 네트워크 파일 형식	* GEXF, GraphML, LGL, Pajek 등 여러 파일 형식을 읽기/쓰기 가능
시각화 기능	* 고급 시각화를 위해 Cairo, Matplotlib과 통합 가능

4. graph-tool

* 효율적인 그래프 자료구조와 알고리즘을 제공하는 오픈소스 라이브러리로, C++로 작성되어 높은 계산 성능을 가지며 파이썬에서 사용할 수 있도록 래핑됨

* NetworkX보다 코드가 복잡할 수 있지만, graph-tool은 계산 성능과 메모리 효율성이 뛰어나 대규모 네트워크 분석에 적합하며 시각화 도구도 SNAP, igraph보다 강력함

graph-tool: Efficent network analysis with python

Extensive Features An extensive array of features is included, such as support for arbitrary vertex, edge or graph properties, efficient "on the fly" filtering of vertices and edges, powerful graph I/O using the GraphML, GML and dot file formats, graph pic

graph-tool.skewed.de

주요 특징	설명
대규모 네트워크 처리	* 수억 개의 노드와 간선을 가진 대규모 네트워크도 효율적으로 처리 * 메모리 효율을 고려한 자료구조와 병렬 알고리즘을 사용
다양한 네트워크 유형	* 무향/유향/가중 그래프, 트리 등 여러 유형의 네트워크를 지원 * 노드와 간선에 임의 속성을 부여 가능
네트워크 분석 알고리즘	* 연결성, 중심성, 커뮤니티 탐지, 레이아웃, 랜덤 네트워크 모델 등 광범위한 분석 알고리즘 제공 * 다중 모드 네트워크, 계층 네트워크, 동적 네트워크 등
시각화 기능	* 그래프 시각화 도구와 레이아웃 알고리즘을 내장 * 대화형(Interactive) 시각화 및 3D 렌더링 가능
통합 그래프 분석 파이프라인	* 데이터 불러오기, 전처리, 알고리즘 실행, 결과 시각화까지 통합된 파이프라인 제공

5. NetworKit

* 대규모 네트워크 분석을 위한 오픈소스 라이브러리로, C++로 작성되어 연산 효율이 뛰어나며 파이썬 인터페이스도 제공

* 비교적 최근에 개발된 라이브러리이며, NetworkX나 igraph에 비해 문서화 수준이 낮지만 지속적인 업데이트를 통해 점차 발전할 것으로 기대됨

NetworKit

NetworKit is a growing open-source toolkit for large-scale network analysis. Its aim is to provide tools for the analysis of large networks in the size range from thousands to billions of edges. For this purpose, it implements efficient graph algorithms, m

networkit.github.io

주요 특징	설명
대규모 네트워크 처리	* 수억 개의 노드와 간선을 가진 대규모 네트워크도 효율적으로 처리 * 메모리 효율을 고려한 자료구조와 병렬 알고리즘을 사용
네트워크 분석 알고리즘	* 연결성, 중심성, 커뮤니티 탐지, 링크 예측, 동적 네트워크 등 광범위한 분석 알고리즘 제공 * 최신 연구 결과를 반영한 알고리즘도 포함
확장성과 유연성	* 새로운 알고리즘이나 데이터 구조를 쉽게 추가할 수 있는 모듈식 디자인 * 다양한 입출력 형식을 지원하며, 사용자 정의 형식도 가능
파이썬 인터페이스	* 직관적인 파이썬 인터페이스를 제공 * Jupyter Notebook과 통합도 지원
시각화 기능	* 그래프 시각화 도구와 레이아웃 알고리즘을 내장 * 대화형(Interactive) 시각화 및 애니메이션 기능 제공

[그래프 ML] 에고 그래프 - 파이썬 NetworkX, Gephi

백관구 — Thu, 14 Mar 2024 17:28:47 +0900

※ 출처 : 그래프 머신러닝 (클라우디오 스타밀레 외, 김기성·장기식 옮김)

※ 이전 글 참고

[그래프 ML] 그래프 데이터셋 - networkx, Network Repository, SNAP

※ 출처 : 그래프 머신러닝 (클라우디오 스타밀레 외, 김기성·장기식 옮김) 1. networkx Graph generators — NetworkX 3.2.1 documentation [0] D.G. Corneil, H. Lerchs, L.Stewart Burlingham, “Complement reducible graphs”, Discrete

data-science-note.tistory.com

1. 파이썬 NetworkX 활용

* 특정 노드의 에고 그래프(ego graph)를 그리려면 어떻게 해야할까?
- 근방 노드들을 모두 그릴수도 있지만, 개수가 많은 경우 관계를 파악하기 어려울 수 있기 때문에 아래와 같은 방법이 주로 사용됨
- 근방을 임의로 선택
- 중심성이 높은 근방을 선택
- 지역 군집 계수가 높은 근방을 선택

import numpy as np
import matplotlib.pyplot as plt
plt.rc("font", family="Malgun Gothic")


n_top = round(len(neighbors) * 0.1)  # 근방 노드 중 10% 추출
idx = {
    "랜덤": np.random.choice(neighbors, n_top ,replace=False),  # 임의로 선택
    "중심성": stats.loc[neighbors].sort_values("betweenness_centrality", ascending=False).index[:n_top],  # 중심성 높은 근방 선택
    "지역 군집 계수": stats.loc[neighbors].sort_values("C_i", ascending=False).index[:n_top]  # 지역 군집 계수 높은 근방 선택
}

fig, subs = plt.subplots(ncols=3, figsize=(15, 5))
for method, sub in zip(["랜덤", "중심성", "지역 군집 계수"], subs.flatten()):
    subgraph = nx.subgraph(G, list(idx[method]) + [5502])  # 부분그래프 추출
    nx.draw(subgraph, pos=nx.kamada_kawai_layout(subgraph),
            node_size=50,  # 노드 크기
            node_color=["k"]*n_top+["r"],  # 노드 색상(5502번만 red 색상)
            width=0.5,  # 간선 너비
            edge_color="grey",  # 간선 색상
            ax=sub)
    sub.set_title(method)  # 제목 설정

ASTRO-PH 5502번 에고 그래프(ego graph). 10% 추출 방식(랜덤, 중심성, 지역 군집 계수)

2. Gephi 활용

* mtx 파일을 Gephi에서 사용하기 위해 데이터를 Gephi에서 인식할 수 있는 파일 형식(GEXF; Graph Exchange XML Format)으로 내보내야 함

nx.write_gexf(G, "astro_ph.gexf")  # GEXF 형식으로 내보내기

2.1. Gephi 실행

① Welcome 화면에서 "Open Graph File"을 클릭
② 위에서 저장한 "astro_ph.gexf" 파일을 선택

초기화면에서 "Open Graph FIle" 선택

"astro_ph.gexf" 파일 열기

오른쪽 위에 있는 [Context] 탭을 통해 16,706개 노드(Nodes)와 121,251개 간선(Edges)으로 구성된 그래프임을 확인 가능합니다. 이제 위에서 NetworkX를 활용해 작업했던 것처럼, 차수가 가장 높은 노드의 에고 그래프를 그리는 작업에 대해 알아보겠습니다.

2.2. 노드 차수 계산

① [Statistics] 탭 ▶ [Network Overview] ▶ "Average Degree"의 [Run] 실행
② 좌측 상단 [Data Laboratory] 탭 ▶ "Degree" 열 클릭하여 내림차순 정렬하여 가장 높은 차수의 노드 Id 확인

Average Degree 실행

Data Laboratory

2.3. 에고 그래프(Ego graph) 생성

① [Filters] 탭 ▶ [Topology] ▶ "Giant Component" 필터를 아래 Queries로 드래그
② "Ego Network" 필터를 아래 Giant Component의 "subfilter"로 드래그
③ Ego Network를 클릭하여 "Node ID"에 5502 입력하고 "OK" 클릭

5502번 노드의 에고 그래프(ego graph)

2.4. 가시성 개선 : 노드/간선 색상, 노드 크기 변경

* 노드 색상을 모듈성 기준으로, 간선 색상을 단일 색상인 회색으로 변경
* 노드 크기를 차수 기준으로 변경
① [Statistics] 탭 ▶ [Community Detection] 탭 ▶ "Modularity"의 [Run] 실행
② [Appearance] 탭 ▶ [Nodes] 팔레트(Color) 아이콘 ▶ [Partition]에서 "Modularity Class" 선택하고 [Apply] 적용
③ [Edges] 팔레트(Color) 아이콘 ▶ [Unique]에서 회색 선택하고 [Apply] 적용
④ [Nodes] 동심원(Size) 아이콘 ▶ [Ranking]에서 "Degree" 선택하고 Max size에 50 입력

노드 색상 변경

간선 색상 변경

노드 크기 변경

2.5. 가시성 개선 : 레이아웃 변경

* 레이아웃을 Fruchterman Reingold로 변경
① [Layout] 탭 ▶ "Fruchterman Reingold" 선택하고 [Run] 실행

레이아웃 변경

2.6. 가시성 개선 : 노드 라벨 추가

* 노드 라벨을 추가하고, 글자 크기를 차수 기준으로 변경
① 화면 하단 T 아이콘(Show Node Labels) 클릭
② [Appearance] 탭 ▶ [Nodes] TT (Label Size) 아이콘 ▶ [Ranking]에서 "Degree" 선택하고 Min size 0.5, Max size 1 입력

노드 라벨 추가

[그래프 ML] 그래프 데이터셋 - NetworkX, Network Repository, SNAP (Stanford Network Analysis Platform), OGB (Open Graph Benchmark)

백관구 — Tue, 12 Mar 2024 17:53:07 +0900

※ 출처 : 그래프 머신러닝 (클라우디오 스타밀레 외, 김기성·장기식 옮김)

1. NetworkX

Graph generators — NetworkX 3.2.1 documentation

[0] D.G. Corneil, H. Lerchs, L.Stewart Burlingham, “Complement reducible graphs”, Discrete Applied Mathematics, Volume 3, Issue 3, 1981, Pages 163-174, ISSN 0166-218X.

networkx.org

2. 네트워크 저장소(Network Repository)

Network Data Repository | The First Interactive Network Data Repository

The first interactive network dataset repository with interactive graph visualization and analytics

networkrepository.com

여기서는 ASTRO-PH 그래프 데이터셋을 살펴보겠습니다. ASTRO-PH 그래프는 1993년 1월부터 2003년 4월까지 천체 물리학 분야에 게시된 arXiv 저장소에서 확인할 수 있는 과학 논문을 사용해 생성되었습니다. 위 링크를 따라 접속한 후, 검색 박스에 "ASTRO-PH"를 검색합니다. 아래와 같은 화면에서 압축파일(ZIP)을 다운로드 받고 작업할 폴더에 압축 해제를 진행합니다.

ASTRO-PH 데이터셋

ASTRO-PH 압축 해제

압축파일을 풀면 위 화면과 같이 "astro-ph.mtx"라는 파일이 보입니다. 우선 이 파일은 제껴두고 아래 readme.html 파일부터 열어보겠습니다. 만약 이 데이터셋을 사용하여 출처를 밝혀야 할 일이 있을 때, 아래와 같이 작성하라는 가이드가 들어있습니다.

readme.html

이번에는 astro-ph.mtx 파일을 열어볼 차례입니다. 먼저, 윈도우에서 제공하는 워드패드를 사용해 파일을 열어보겠습니다. 상당히 많은 행(줄)으로 데이터가 입력되어 있습니다. 이 mtx 형식의 파일을 파이썬에서 어떻게 읽고 작업할 수 있는지 알아보겠습니다.

astro-ph.mtx 일부

2.1. MTX (Matrix Market Exchange Format) 파일 형식

* ASCII (American Standard Code for Information Interchange) 형식의 텍스트 파일을 통해 실수나 복소수 행렬, 희소 행렬을 지정하기 위한 파일 형식
- 헤더에는 아래와 같이 시작 부분에 %%가 위치함

%%MatrixMarket matrix coordinate real symmetric

* 파이썬의 Scipy 라이브러리를 사용해 읽을 수 있음

from scipy.io import mmread
import networkx as nx


matrix = mmread("../data/network_repository/astro-ph/astro-ph.mtx")  # mtx 파일 읽기
G = nx.from_scipy_sparse_array(matrix)  # scipy matrix를 networkx 형식으로 변환

print(f"그래프 위수 (노드 개수): {G.order()}")
print(f"그래프 크기 (간선 개수): {G.size()}")

그래프 위수 (노드 개수): 16706
그래프 크기 (간선 개수): 121251

2.2. 측정지표 분석

① 매개 중심성(Betweenness Centrality), 지역 군집 계수(Local Clustering Coefficient), 노드 차수(Degree) 연산

betweenness_centrality = nx.centrality.betweenness_centrality(G)  # 매개 중심성
clustering = nx.clustering(G)  # 지역 군집 계수
degree = dict(nx.degree(G))  # 노드 차수

print(f"매개 중심성: {betweenness_centrality}")
print(f"지역 군집 계수: {clustering}")
print(f"노드 차수: {degree}")

매개 중심성: {0: 0.003160341116179179, 1: 0.0, 2: 0.0002895806033400033, 3: 0.0003601880676500333, 4: 0.0001708166540733188, 5: 0.00050286583593598, ...}

지역 군집 계수: {0: 0.06031746031746032, 1: 0, 2: 0.2, 3: 0.16666666666666666, 4: 0.49166666666666664, 5: 0.08088235294117647, ...}

노드 차수: {0: 36, 1: 1, 2: 5, 3: 4, 4: 16, 5: 17, ...}

② pandas.DataFrame으로 변환

import os
import pandas as pd


stats = pd.DataFrame({
    "betweenness_centrality": betweenness_centrality,
    "C_i": clustering,
    "degree": degree
})

os.makedirs("04_read_mtx", exist_ok=True)  # 저장할 디렉토리 생성
stats.to_csv("astro_ph_metrics.csv")  # CSV 형식으로 파일 저장
stats

betweenness_centrality C_i degree
0 0.003160 0.060317 36
1 0.000000 0.000000 1
2 0.000290 0.200000 5
3 0.000360 0.166667 4
4 0.000171 0.491667 16
... ... ... ...
16701 0.000000 0.000000 0
16702 0.000000 1.000000 10
16703 0.000000 1.000000 10
16704 0.000000 1.000000 10
16705 0.000000 1.000000 10
16706 rows × 3 columns

③ 차수 기준 내림차순 정렬
- 가장 큰 차수를 가진 5502번 노드가 360개의 근방으로 연결되는 것을 통해, 이 분야에서 핵심적인 인물이라는 것을 유추할 수 있음

stats.sort_values("degree", ascending=False).head()

betweenness_centrality C_i degree
5502 0.011944 0.100155 360
912 0.016902 0.100856 353
1231 0.015462 0.092242 329
5507 0.008890 0.121367 299
6197 0.008748 0.116170 296

3. 스탠포드 네트워크 분석 플랫폼(SNAP; Stanford Network Analysis Platform)

SNAP: Stanford Network Analysis Project

snap.stanford.edu

SNAP 홈페이지

여기서는 "amazon0302" 데이터셋을 다운로드 받아 사용하겠습니다. SNAP 홈페이지 좌측 탭 중 [SNAP Datasets]를 클릭합니다. 그리고 "Amazon networks"를 선택하면 Amazon과 관련된 여러 데이터셋을 볼 수 있습니다. 그 중 "amazon0302"를 클릭하고, 아래와 같은 페이지 하단에 있는 압축파일(.gz)을 다운로드해 압축을 풀어줍니다.

amazon0302 데이터셋 설명

amazon0302 압축 해제

이번에는 텍스트 파일 형식(txt)으로 그래프 데이터가 구성되어 있습니다. 워드패드를 통해 파일을 열어보겠습니다. 데이터에 대한 설명과 간단한 그래프 정보가 포함되어 있습니다. 0 1, 0 2 부분은 간선 정보를 가리킵니다.

amazon0302.txt

3.1. 파이썬 NetworkX 사용해 읽기

import networkx as nx


G = nx.read_edgelist("amazon0302.txt")

3.2. 파이썬 SNAP 사용해 읽기

 python -m pip install snap-stanford

아래의 코드를 실행하면 SNAP 라이브러리의 무향 그래프(PNGraph) 객체를 받게 되지만, 이 객체에서 NetworkX의 기능들을 사용할 수 없습니다. 따라서 NetworkX 기능을 사용하려면, SNAP 그래프 객체를 NetworkX 그래프 객체로 변환해야 합니다.

import snap


snap_G = snap.LoadEdgeList(snap.PNGraph,  # 생성할 그래프 유형(PNGraph: 무향 그래프, TNGraph: 유향 그래프)
                      "amazon0302.txt",  # 간선 목록이 포함된 입력 파일
                      SrcColId=0, DstColId=1,  # SrcColId / DstColId: 근원(Src)/타겟(Dst) 노드 ID가 있는 열의 인덱스
                      Separator="\t")  # Separator: 입력 파일에서 필드를 구분하는 기호

3.3. 파이썬 SNAP 그래프를 NetworkX 그래프로 변환

def snap2networkx(snap_G):
    """
    snap 그래프를 networkx 그래프로 변환하는 함수
    
    Args:
        snap_G: snap 그래프 객체 (snap.PNGraph, snap.TNGraph 등)
    
    Returns:
        nx_G: networkx 그래프 객체
    """
    
    # networkx 그래프 객체 생성
    if isinstance(snap_G, snap.TNGraph):  # 유향 그래프
        nx_G = nx.DiGraph()
    else:  # 무향 그래프
        nx_G = nx.Graph()
    
    # 노드 추가
    for node in snap_G.Nodes():
        nx_G.add_node(node.GetId())
    
    # 간선 추가
    for edge in snap_G.Edges():
        nx_G.add_edge(edge.GetSrcNId(), edge.GetDstNId())  # 근원(Src)/타겟(Dst) 노드 ID (NId)
    
    return nx_G


nx_G = snap2networkx(snap_G)  # snap_G: snap 그래프, nx_G: networkx 그래프

4. 오픈 그래프 벤치마크(OGB; Open Graph Benchmark)

Open Graph Benchmark

A collection of benchmark datasets, data-loaders and evaluators for graph machine learning in PyTorch.

ogb.stanford.edu

[그래프 ML] 그래프 생성 - 파이썬 NetworkX

백관구 — Mon, 11 Mar 2024 17:10:36 +0900

※ 출처 : 그래프 머신러닝 (클라우디오 스타밀레 외, 김기성·장기식 옮김)

※ 이전 글 참고

2024.03.08 - [인공지능/그래프] - [그래프 ML] 파이썬 networkx 시작하기

2024.03.11 - [인공지능/그래프] - [그래프 ML] 그래프 속성 - 파이썬 networkx

1. 간단한 그래프

1.1. 완전 연결 무향 그래프(Fully Connected Undirected Graph)

* $n$개의 노드일 때, $\frac{n(n-1)}{2}$개의 간선과 군집 계수 $C=1$을 가짐
* 더 큰 그래프를 구성하는 기본 구성 요소(building block)
- $n$개의 노드로 구성된 완전 연결 부분그래프를 크기가 $n$인 클리크(clique)라 함
- 클리크를 찾는 작업(clique problem)은 컴퓨터 공학에서 연구되는 비결정적 다항시간 완전(NP-complete) 문제로 밝혀짐

import networkx as nx


fully_connected_undirected_G = nx.complete_graph(n=7)
nx.draw(fully_connected_undirected_G, with_labels=True)

완전 연결 무향 그래프(Fully Connected Undirected Graph)

1.2. 롤리팝 그래프(Lollipop Graph)

* 크기가 $m$인 클리크와 $n$개 노드의 가지(branch)가 있는 그래프

lollipop_G = nx.lollipop_graph(m=7, n=3)  # m: 클리크 크기, n: 가지의 노드 개수
nx.draw(lollipop_G, with_labels=True)

롤리팝 그래프(Lollipop Graph)

1.3. 바벨 그래프(Barbell Graph)

* 크기가 $m1$인 클리크 2개가 $m2$개 노드의 가지로 연결된 그래프

barbell_G = nx.barbell_graph(m1=7, m2=4)  # m1: 클리크 크기, m2: 가지의 노드 개수
nx.draw(barbell_G, with_labels=True)

바벨 그래프(Barbell Graph)

1.4. 그래프 병합

* networkx.disjoint_union_all 함수 사용

import numpy as np


all_G = nx.disjoint_union_all([fully_connected_undirected_G, lollipop_G, barbell_G])
for _ in range(2):  # 임의의 간선 추가
    all_G.add_edge(np.random.choice(all_G.nodes), np.random.choice(all_G.nodes))

nx.draw(all_G, with_labels=True)

완전 연결 무향 그래프, 롤리팝 그래프, 바벨 그래프 병합

2. 그래프 생성 모델

* 그래프가 자동으로 성장하는 확률 모델(probabilistic model)과 생성 모델(generative model)로 그래프를 구성할 수 있음

2.1. 와츠-스트로가츠 모델(Watts-Strogatz Model; 1998)

* 작은세상 네트워크(Small-world network)를 생성하는 대표적인 그래프 생성 모델
- 작은세상 네트워크(Small-world network) : 높은 군집화 계수, 짧은 평균 경로 길이를 갖는 네트워크

* 생성 과정
1. 고리 격자(Ring lattice) 구조의 정규 그래프를 생성
. 각 노드는 양쪽으로 일정 거리 이내의 노드들과 연결됨
2. 각 간선에 대해 일정 재배선 확률(rewiring probability; $p$)로 한쪽 끝을 다른 임의의 노드로 재배선

G = nx.watts_strogatz_graph(n=20, k=5, p=0.2)  # n: 노드 개수, k: 이웃 노드 개수(n의 절반보다 작아야 함), p: 재배선 확률(0~1)
nx.draw(G)

와츠-스트로가츠 모델(Watts-Strogatz Model; 1998)

2.2. 바라바시-알베르트 모델(Barabasi-Albert Model; 1999)

* 척도없는 네트워크(Scale-free network)를 생성하는 대표적인 그래프 생성 모델
- 척도없는 네트워크(Scale-free network) : 노드 차수 분포가 멱함수 분포를 따르는 네트워크
. 소수의 노드가 매우 높은 차수를 갖고, 대다수의 노드는 작은 차수를 가짐

* 생성 과정
1. 초기에 $n0$개 노드로 구성된 작은 그래프를 생성
2. 새로운 노드를 하나씩 추가하며, 새 노드를 기존 노드들과 $m$개의 간선으로 연결
3. 새 노드와 기존 노드를 연결할 때, 기존 노드 $i$가 가진 차수 $k_i$에 비례하는 확률 $p_i$로 연결
$$p_i = \frac{k_i}{\sum k_j}$$
. 부가적 선호 연결(Preferential attachment) 원리

G = nx.extended_barabasi_albert_graph(n=20, m=1, p=0.2, q=0.2)  # n: 최종 노드 개수, m: 각 새 노드가 연결될 간선 개수, p: 부가적 선호 연결 확률, q: 노드 생성 확률 
nx.draw(G)

바라바시-알베르트 모델(Barabasi-Albert Model; 1999)

[그래프 ML] 그래프 속성 - 파이썬 NetworkX

백관구 — Mon, 11 Mar 2024 17:05:43 +0900

※ 출처 : 그래프 머신러닝 (클라우디오 스타밀레 외, 김기성·장기식 옮김)

※ 이전 글 참고

[그래프 ML] 파이썬 networkx 시작하기

data-science-note.tistory.com

1. 그래프 속성이란

* 모든 그래프는 고유한 속성을 가지며, 이러한 속성은 측정지표(metrics)로 정량화할 수 있음
- 그래프 전체 / 지역(local) / 전역(global) 측면을 특성화 함
- 간단한 속성 : 노드 및 간선의 개수 → 복잡한 그래프를 표현하기 힘듦
- 통합(Integration), 분리(Segregation), 중심성(Centrality), 탄력성(Resilience) 측정지표를 사용해 그래프의 속성을 보다 잘 표현할 수 있음

종류	설명
통합 측정지표(Integration Metrics)	노드가 상호 연결되는 경향을 측정
분리 측정지표(Segregation Metrics)	상호 연결된 노드 그룹의 존재를 측정
중심성 측정지표(Centrality Metrics)	개별 노드의 중요성을 측정
탄력성 측정지표(Resilience Metrics)	노드 및 간선 추가/제거, 속성 변화 등 변화에 그래프가 얼마나 기능을 유지하는지 측정

2. 통합 측정지표(Integration Metrics)

2.1. 거리(Distance), 경로(Path), 최단경로(Shortest Path), 지름(Diameter)

* 거리(Distance)
- 근원 노드(Source node)에서 목표 노드(Target node)에 도달하기 위해 거쳐야 하는 간선의 개수

* 경로(Path)
- 근원 노드와 목표 노드를 연결하는 간선의 집합

* 최단경로(Shortest Path)
- 근원 노드와 목표 노드 사이의 가능한 모든 경로에 대해 간선의 수가 가장 적은 경로

* 지름(Diameter)
- 그래프 내 가능한 모든 최단경로 중 가장 긴 최단경로에 포함된 간선의 수

import networkx as nx


G = nx.Graph()
nodes = {0: "서울", 1: "부산", 2: "인천", 3: "대구", 4: "대전", 5: "광주", 6: "수원"}
G.add_nodes_from(nodes.keys())
G.add_edges_from([(0, 2), (0, 6), (1, 3), (2, 5), (2, 6), (3, 4), (4, 5), (4, 6)])

shortest_path = nx.shortest_path(G, source=0, target=1)  # 0: 서울, 1: 부산
print(f"최단경로: {shortest_path}")

nx.draw(G, with_labels=True)  # 그래프 시각화

최단경로: [0, 6, 4, 3, 1]

라이언(0)이 어피치(1)를 찾아가는 최단 경로는 0, 6, 4, 3, 1

2.2. 특성 경로 길이(Characteristic Path Length)

* 정보가 네트워크를 통해 얼마나 효율적으로 분산되는지 측정하는 방법
- 특성 경로 길이가 짧은 네트워크는 정보를 빠르게 전송할 수 있어 비용 절감에 유리

* 가능한 모든 노드 쌍 사이의 모든 최단경로 길이의 평균
$$\frac{1}{q(q-1)} \sum_{i \in V} l_i$$
- $l_i$ : 노드 $i$와 다른 모든 노드 사이의 평균 경로 길이
- $V$ : 그래프 노드의 집합
- $q = |V|$ : 그래프의 위수

* 문제점 : 연결이 끊긴 그래프에서는 모든 노드 간의 경로를 계산할 수 없기 때문에, 항상 측정할 수는 없음

print(f"특성 경로 길이: {nx.average_shortest_path_length(G)}")

특성 경로 길이: 2.0

2.3. 전역 효율성(Global Efficiency)

* 네트워크를 통해 정보가 얼마나 효율적으로 교환되는지에 대한 척도
- 그래프가 완전히 연결됐을 때 효율성 최대, 완전히 연결이 끊긴 그래프는 효율성이 최소

* 모든 노드 쌍에 대한 역최단경로(inverse shortest path) 길이의 평균
- 역최단경로(Inverse shortest path) : 목표 노드에서 다른 모든 노드까지의 최단 거리(일반적인 최단경로와 반대로)
$$\frac{1}{q(q-1)} \sum \frac{1}{l_{ij}}$$
- $l_{ij}$ : 노드 $i$와 $j$ 간의 역최단경로

완전 연결 그래프(Fully Connected Graph)	원형 그래프(Circulant Graph)
각 노드는 다른 노드에서 모두 도달할 수 있으므로, 정보가 네트워크를 통해 빠르게 교환됨	각 노드에 도달하기 위해서는 여러 노드를 통과해야 하므로, 효율성이 떨어짐
전역 효율성 ↑	전역 효율성 ↓

fully_connected_G = nx.complete_graph(7)  # 완전 연결 그래프
print(f"완전 연결 그래프의 전역 효율성: {nx.global_efficiency(fully_connected_G)}")
nx.draw(fully_connected_G, with_labels=True)  # 그래프 시각화

완전 연결 그래프의 전역 효율성: 1.0

완전 연결 그래프(Fully Connected Graph)

circulant_G = nx.circulant_graph(7, offsets=[1])  # 원형 그래프
print(f"원형 그래프의 전역 효율성: {nx.global_efficiency(circulant_G)}")
nx.draw(circulant_G, with_labels=True)  # 그래프 시각화

원형 그래프의 전역 효율성: 0.6111111111111109

원형 그래프(Circulant Graph)

3. 분리 측정지표(Segregation Metrics)

* 그래프 내 그룹의 존재에 대한 정보

3.1. 군집 계수(Clustering Coefficient)

* 그래프에서 노드들이 서로 얼마나 잘 묶여있는지를 측정하는 지표

* 군집 계수가 높은 경우
- 노드들이 서로 밀집되어 있고 삼각형 구조가 많이 형성됨
- 지역 커뮤니티, 모듈성이 강한 구조를 가진 네트워크
- 생물학에서 기능적으로 연관된 단백질
→ 정보 전파, 전염병 확산이 빠르게 일어날 수 있음

* 군집 계수가 낮은 경우
- 노드들이 분산되어 있고 삼각형 구조가 적음
- 허브 노드를 중심으로 방사형 구조를 가진 네트워크
- 인터넷(www) 같은 복잡한 네트워크
→ 다양한 정보 유입에 유연하게 대처 가능하며, 취약성이 낮음

* 전역 군집 계수(Global Clustering Coefficient)
- 그래프 전체에 대해 계산
- 삼각형(3개 노드와 3개 간선)으로 이뤄진 완전 부분그래프(complete subgraph) 개수를 그래프에 존재할 수 있는 최대 삼각형 개수로 나눈 비율

* 지역 군집 계수(Local Clustering Coefficient)
- 각 노드에 대해 계산
- 한 노드의 이웃 노드들 사이에 연결된 간선 수를 가능한 최대 간선 수로 나눈 비율

G = nx.Graph()
nodes = {0: "서울", 1: "부산", 2: "인천", 3: "대구", 4: "대전", 5: "광주", 6: "수원"}
G.add_nodes_from(nodes.keys())
G.add_edges_from([(0, 2), (0, 6), (1, 3), (2, 5), (2, 6), (3, 4), (4, 5), (4, 6)])

print(f"전역 군집 계수: {nx.average_clustering(G)}")
print(f"지역 군집 계수: {nx.clustering(G)}")

nx.draw(G, with_labels=True, node_size=list(map(lambda x: 500*x, nx.clustering(G).values())))  # 그래프 시각화

전역 군집 계수: 0.23809523809523808
지역 군집 계수: {0: 1.0, 1: 0, 2: 0.3333333333333333, 3: 0, 4: 0, 5: 0, 6: 0.3333333333333333}

지역 군집 계수(Local Clustering Coefficient)

3.2. 전이성(Transitivity)

* 0과 1 사이의 값을 가지며, 1에 가까울수록 삼각형 구조가 많아 군집화된 구조임을 의미

* 닫힌 트리플렛(Closed triplet; 3개 노드와 2개 간선으로 구성된 완전 부분그래프)의 개수와 그래프에서 가능한 닫힌 트리플렛의 최대 개수의 비율

print(f"전이성: {nx.transitivity(G)}")

전이성: 0.25

※ 군집 계수(Clustering Coefficient) vs. 전이성(Transitivity)

	군집 계수(Clustering Coefficient)	전이성(Transitivity)
정의	한 노드의 이웃 노드들 사이에 존재하는 간선의 비율	전체 그래프에서 연결된 삼각형의 상대적 빈도
계산 방식	개별 노드에 대해 계산	그래프 전체에 대해 하나의 값
범위	0 ~ 1	0 ~ 1 삼각형이 있어야만 0이 아닌 값을 가짐
활용	개별 노드의 군집화 정도를 파악	전체 네트워크의 전역적인 군집화 수준을 파악

3.3. 모듈성(Modularity)

* 서로 연결된 노드 집합의 네트워크 분할을 집계하도록 설계됨
- 높은 모듈성을 가진 그래프는 모듈 내에서 밀집된 연결을 보여주고 모듈 간의 연결이 희박함

print(f"모듈성: {nx.algorithms.community.modularity(G, communities=[{0, 2, 6}, {1, 3, 4, 5}])}")

모듈성: 0.25

4. 중심성 측정지표(Centrality Metrics)

4.1. 연결 중심성(Degree Centrality)

* 노드의 차수와 특정 노드의 입사 간선(incident edge)의 개수와 연관됨
- 노드가 다른 노드에 많이 연결될수록 해당 노드의 연결 중심성은 높은 값을 가짐

* 유향 그래프라면 들어오는 간선과 나가는 간선의 수와 관련해 각 노드에 대한 내차중심성과 외차중심성을 고려해야 함

print(f"연결 중심성: {nx.degree_centrality(G)}")

연결 중심성: {0: 0.3333333333333333, 1: 0.16666666666666666, 2: 0.5, 3: 0.3333333333333333, 4: 0.5, 5: 0.3333333333333333, 6: 0.5}

4.2. 근접 중심성(Closeness Centrality)

* 노드가 다른 노드와 얼마나 잘 연결되어 있는지를 정량화

* 다른 모든 노드까지의 평균 거리
$$\frac{1}{\sum_{i \in V, i != j} l_{ij}}$$
- $l_{ij}$ : 노드 $i$와 $j$ 간의 최단경로 길이
- $V$ : 노드의 집합

print(f"근접 중심성: {nx.closeness_centrality(G)}")

근접 중심성: {0: 0.46153846153846156, 1: 0.35294117647058826, 2: 0.5, 3: 0.5, 4: 0.6666666666666666, 5: 0.5454545454545454, 6: 0.6}

4.3. 매개 중심성(Betweenness Centrality)

* 노드가 다른 노드 간의 다리 역할을 하는 정도
- 해당 노드를 통과하는 최단경로 개수가 많을수록 매개 중심성 값이 높아짐

$$\sum_{w != i != j} \frac{L_{wj}(i)}{L_{wj}}$$
- $L_{wj}$ : 노드 $w$와 $j$ 사이의 최단경로 개수
- $L_{wj}(i)$ : 노드 $i$를 통과하는 $w$와 $j$ 간의 최단경로 개수

print(f"매개 중심성: {nx.betweenness_centrality(G)}")

매개 중심성: {0: 0.0, 1: 0.0, 2: 0.1, 3: 0.3333333333333333, 4: 0.5666666666666667, 5: 0.1, 6: 0.3}

※ 중심성 측정지표 비교

import matplotlib.pyplot as plt
plt.rc("font", family="Malgun Gothic")


fig, subs = plt.subplots(ncols=3, figsize=(9, 3))

nx.draw(G, with_labels=True, node_size=list(map(lambda x: 500*x, nx.degree_centrality(G).values())), ax=subs[0])  # 연결 중심성
subs[0].set_title("연결 중심성")

nx.draw(G, with_labels=True, node_size=list(map(lambda x: 500*x, nx.closeness_centrality(G).values())), ax=subs[1])  # 근접 중심성
subs[1].set_title("근접 중심성")

nx.draw(G, with_labels=True, node_size=list(map(lambda x: 500*x, nx.betweenness_centrality(G).values())), ax=subs[2])  # 매개 중심성
subs[2].set_title("매개 중심성")

중심성 측정지표 비교

5. 탄력성 측정지표(Resilience Metrics)

5.1. 동류성(Assortativity)

* 그래프에서 연결된 노드들의 유사성 정도를 측정하는 지표로, 특히 노드의 차수가 비슷한 노드들이 서로 연결되어 있는 경향을 파악

* 동류성 계수(Assortativity coefficient)는 -1 ~ 1 사이의 값을 가짐 (∵ 피어슨 상관계수를 사용)
- 양의 계수 : 유사한 차수를 가진 노드들이 서로 연결되는 경향 (동종 연결)
- 0 : 노드 연결에 특별한 경향 없음
- 음의 계수 : 차수가 다른 노드들이 서로 연결되는 경향 (이종 연결)

* 동류성이 높은 경우
- 소셜 네트워크에서 인플루언서끼리 연결되는 경향
- 생태계에서 비슷한 크기의 종들이 상호작용하는 경향
- 이론적으로 동류 네트워크는 노드의 차수 분포가 멱함수 분포를 보이며 견고성이 높음

* 동류성이 낮은 경우
- 핵심 노드(허브)와 주변 노드가 연결된 구조
- 정보 전달이나 확산에 취약
- 이론적으로 노드의 차수 분포가 지수 분포를 보이며 중심성이 높은 노드에 집중됨

멱함수 분포와 지수함수 분포 비교. (a) 정상 스케일, (b) 로그 스케일.

print(f"동류성: {nx.degree_pearson_correlation_coefficient(G)}")

동류성: -2.7755575615628914e-17

[그래프 ML] Gephi 시작하기

백관구 — Fri, 8 Mar 2024 17:42:41 +0900

※ 출처 : 그래프 머신러닝 (클라우디오 스타밀레 외, 김기성·장기식 옮김)

1. Gephi 다운로드 및 설치

* 복잡한 그래프 시각화 작업에 활용
* 아래 https://gephi.org/ 접속 ▶ [Download FREE] 클릭 ▶ OS에 맞는 파일 다운로드(Windows, Mac OS, Linux)

Gephi - The Open Graph Viz Platform

The Open Graph Viz Platform Gephi is the leading visualization and exploration software for all kinds of graphs and networks. Gephi is open-source and free. Runs on Windows, Mac OS X and Linux. Learn More on Gephi Platform » Support us! We are non-profit.

gephi.org

2. Gephi 실행

Gephi를 실행하면, 아래 화면이 처음에 나타납니다.

Gephi 실행 초기화면

Gephi 사용법을 익히기 위해, 프로그램에서 제공하는 샘플 그래프 Les Miserables.gexf를 사용하도록 합니다. Les Miserables.gexf 그래프를 불러오기 위해서는 초기화면에서 아래 부분을 선택합니다.

[Samples] ▶ Les Miserables.gexf 그래프 불러오기

Les Miserables.gexf 그래프

3. Gephi 인터페이스

이 글에서는 Gephi를 구성하는 인터페이스 Graph (그래프), Appearance (외관), Layout (레이아웃), Context (환경), Filters / Statistics (필터/통계)에 대해 알아보도록 합니다. 이외 모든 기능에 대한 설명은 Gephi 공식 가이드를 참고해 주세요.

Learn how to use Gephi

Welcome to Gephi! Gephi is an open-source software for visualizing and analysing large networks graphs. Gephi uses a 3D render engine to display graphs in real-time and speed up the exploration. You can use it to explore, analyse, spatialise, filter, clute

gephi.org

3.1. 그래프(Graph)

Graph (그래프)

* 그래프가 표현되는 부분
* 그래프 옵션을 변경할 때마다 그래프 이미지가 자동으로 업데이트 됨

3.2. 외관(Appearance)

Appearance (외관)

* 노드(Nodes), 간선(Edges)의 스타일(색상, 크기, 라벨)을 지정
* 지정 후 [Apply] 버튼 클릭하여 그래프에 적용

* 노드, 간선의 색상(Color)
- 팔레트 아이콘 클릭
- 고유 색상(Unique), 파티션(Partition), 색상 순위(Ranking) 방식 선택
. 파티션과 색상 순위의 경우, 드롭다운 메뉴에서 색상 범위에 참조할 그래프 속성을 선택해야 함
. Statistics에서 계산된 그래프 속성도 사용 가능

* 노드의 크기(Size)
- 동심원 아이콘 클릭
- 고유 크기(Unique), 크기 순위(Ranking) 방식 선택

Appearance 변경

* 노드, 간선의 라벨 색상(Label Color)
- A 아이콘 클릭
- 고유 색상(Unique), 파티션(Partition), 색상 순위(Ranking) 방식 선택

* 노드, 간선의 라벨 크기(Label Size)
- TT 아이콘 클릭
- 고유 크기(Unique), 크기 순위(Ranking) 방식 선택

3.3. 레이아웃(Layout)

Layout (레이아웃)

* 노드 레이아웃을 선택해 그래프의 노드 위치를 조정할 수 있음
* Contraction, Expansion, Force Atlas, Force Atlas2, Fruchterman Reingold, Label Adjust, Noverlap, OpenOrd, Random Layout, Rotate, Yifan Hu, Yifan Hu Proportional 기능 지원
* 사용할 레이아웃 선택 후, [Run] 버튼 클릭하여 적용 (실행 후 그래프가 변경되면 [Stop] 버튼 클릭)

레이아웃 예시

3.4. 환경(Context)

Context (환경)

* 노드(Nodes), 간선(Edges)의 개수와 그래프 유형(유향/무향) 정보를 표현
- 필터 기능 사용 시, 필터링 된 노드와 간선 비율(%)도 표시

3.5. 필터(Filters) / 통계(Statistics)

Filters (필터)와 Statistics (통계)

* Statistics 탭을 사용해 계산한 집합 속성에 따라 그래프의 특정 하위 영역을 필터링하고 시각화 함
* 계산된 측정 지표를 속성으로 사용해 노드, 간선의 모양을 지정하거나 그래프 하위 영역을 필터링 할 수 있음
* 그래프 계산에 사용할 수 있는 그래프 측정 지표를 [Run] 버튼을 클릭해 연산

차수 범위(Degree Range)가 9 이상

[그래프 ML] 파이썬 NetworkX 시작하기

백관구 — Fri, 8 Mar 2024 17:22:13 +0900

※ 출처 : 그래프 머신러닝 (클라우디오 스타밀레 외, 김기성·장기식 옮김)

1. 그래프(Graph) 뜻

* 개체 간의 관계를 설명하는 데 사용되는 수학적 구조
* 소셜 네트워크(팔로우), 지도(길로 이어진 도시), 생물학적 구조, 웹 페이지, 프로세스 등 여러 분야에 사용됨

2. 라이브러리 설치

jupyter, networkx, snap-stanford, matplotlib, pandas, scipy

3. 단순무향그래프(Simple Undirected Graph)

$$G = (V, E)$$

* $V$ : 꼭지점(vertex) 또는 노드(node)의 집합
$$V = \{v_1, ..., v_n\}$$

* $E$ : 두 꼭지점 간의 연결을 나타내는 간선(edge)으로 순서가 없는 순서쌍의 집합
$$E = \{(v_k, v_w), ..., (v_i, v_j)\}$$
- 각 간선 간에 순서가 없으므로, $(v_k, v_w), (v_w, v_k)$는 같은 간선을 나타냄

import networkx as nx

G = nx.Graph()  # 무향그래프
V = {"서울", "부산", "인천", "대구"}  # 문자열, 클래스, 다른 networkx 그래프와 같이 해시가능한 객체
E = [
    ("서울", "부산"),
    ("서울", "인천"),
    ("서울", "대구"),
    ("부산", "대구")
]
G.add_nodes_from(V)
G.add_edges_from(E)

print(f"V = {G.nodes}")
print(f"E = {G.edges}")

V = ['부산', '서울', '대구', '인천']
E = [('부산', '서울'), ('부산', '대구'), ('서울', '인천'), ('서울', '대구')]

3.1. 기본 속성

* 그래프 위수(order) $|V|$
- 노드의 개수

* 그래프 크기(size) $|E|$
- 간선의 개수

* 노드 차수(degree)
- 해당 노드에 연결된 간선의 개수

* 노드 근방(neighbor)
- 노드에 연결된 모든 노드 $V$의 부분집합

print(f"그래프 위수: {G.number_of_nodes()}")
print(f"그래프 크기: {G.number_of_edges()}")
print(f"노드 차수: { {v: G.degree(v) for v in G.nodes} }")
print(f"노드 근방: { {v: list(G.neighbors(v)) for v in G.nodes} }")

그래프 위수: 4
그래프 크기: 4
노드 차수: {'부산': 2, '서울': 3, '대구': 2, '인천': 1}
노드 근방: {'부산': ['서울', '대구'], '서울': ['부산', '인천', '대구'], '대구': ['서울', '부산'], '인천': ['서울']}

* 노드 근방그래프(neighborhood graph) 또는 에고그래프(ego graph)
- 노드에 연결된 노드와 연결된 모든 변으로 구성된 $G$의 부분그래프(subgraph)

neighborhood_graph_busan = nx.ego_graph(G, "부산")

print(f"노드: {neighborhood_graph_busan.nodes}")
print(f"간선: {neighborhood_graph_busan.edges}")

노드: ['부산', '서울', '대구']
간선: [('부산', '서울'), ('부산', '대구'), ('서울', '대구')]

4. 그래프 종류

유향그래프(Directed Graph)
다이그래프(Digraph)

가중그래프(Weighted Graph)

다중그래프(Multigraph)

4.1. 유향그래프(Directed Graph)

$$G = (V, E)$$

* $V$ : 꼭지점 또는 노드의 집합
$$V = \{v_1, ..., v_n\}$$
- 머리(Head) : 출발 노드
- 꼬리(Tail) : 도착 노드

* $E$ : 두 꼭지점 간의 연결을 나타내는 간선으로 순서가 있는 순서쌍의 집합
$$E = \{(v_k, v_w), ..., (v_i, v_j)\}$$
- 각 간선 간에 순서가 있으므로, $(v_k, v_w), (v_w, v_k)$는 다른 간선을 나타냄
. $(v_k, v_w)$ : $v_k$ → $v_w$
. $(v_w, v_k)$ : $v_w$ → $v_k$

* 노드 차수
- 입력차수(Indegree) $deg^{-}(v)$ : 노드로 도착하는 간선의 개수
- 출력차수(Outdegree) $deg^{+}(v)$ : 노드에서 출발하는 간선의 개수

G = nx.DiGraph()  # 유향그래프
V = {"서울", "부산", "인천", "대구"}
E = [
    ("부산", "서울"),
    ("인천", "서울"),
    ("대구", "서울"),
    ("부산", "인천"),
    ("대구", "부산"),
    ("대구", "인천")
]
G.add_nodes_from(V)
G.add_edges_from(E)

print(f"입력차수: { {v: G.in_degree(v) for v in G.nodes} }")
print(f"출력차수: { {v: G.out_degree(v) for v in G.nodes} }")

입력차수: {'부산': 1, '서울': 3, '대구': 0, '인천': 2}
출력차수: {'부산': 2, '서울': 0, '대구': 3, '인천': 1}

4.2. 다중그래프(Multigraph)

* 한 노드에서 출발해서 같은 노드로 도착하는 간선이 여러 개인 다중 간선이 있는 그래프

$$G = (V, E)$$

* $V$ : 노드의 집합
* $E$ : 간선의 다중집합
※ 다중집합 : 집합의 각 원소에 다중 인스턴스를 허용하는 집합

* 유향다중그래프(Directed Multigraph)
- $E$ 순서가 있는 순서쌍의 다중집합
* 무향다중그래프(Undirected Multigraph)
- $E$ 순서가 없는 순서쌍의 다중집합

directed_multi_graph = nx.MultiDiGraph()  # 유향다중그래프
undirected_multi_graph = nx.MultiGraph()  # 무향다중그래프

V = {"서울", "부산", "인천", "대구"}
E = [
    ("부산", "서울"),
    ("부산", "서울"),
    ("인천", "서울"),
    ("대구", "서울"),
    ("대구", "서울"),
    ("부산", "인천"),
    ("대구", "부산"),
    ("대구", "인천")
]
directed_multi_graph.add_nodes_from(V)
undirected_multi_graph.add_nodes_from(V)
directed_multi_graph.add_edges_from(E)
undirected_multi_graph.add_edges_from(E)

4.3. 가중그래프(Weighted Graph)

* 간선가중그래프(Edge-weighted Graph)
- 일반적인 가중그래프
$$G = (V, E, w)$$
- $V$ : 노드의 집합
- $E$ : 간선의 집합
- $w:E \to \mathbb{R}$ : 각 간선 $e \in E$를 실수 가중값으로 대응시키는 가중 함수

* 노드가중그래프(Node-weighted Graph)
$$G = (V, E, w)$$
- $V$ : 노드의 집합
- $E$ : 간선의 집합
- $w:V \to \mathbb{R}$ : 각 노드 $v \in V$를 실수 가중값으로 대응시키는 가중 함수

G = nx.DiGraph()
V = {"서울", "부산", "인천", "대구"}
E = [
    ("부산", "서울", 13),
    ("인천", "서울", 7),
    ("대구", "서울", 10),
    ("부산", "인천", 17),
    ("대구", "부산", 5),
    ("대구", "인천", 15)
]
G.add_nodes_from(V)
G.add_weighted_edges_from(E)

5. 다분그래프(Multipartite Graph)

5.1. k분그래프(kth-partite Graph)

* k개의 노드 집합으로 분할할 수 있는 그래프
* 간선은 서로 다른 집합에 대해서만 허용되며, 같은 집합에 속한 노드 안에서는 허용되지 않음
* 응용 예시
- 신용카드 거래 그래프 분석
- 문서와 그 안의 개체들을 이용한 이분그래프(bipartite graph)로 문서를 처리하고 정보를 구조화

import pandas as pd
import numpy as np

n_nodes = 10
n_edges = 12

bottom_nodes = [ith for ith in range(n_nodes) if ith%2==0]  # [0, 2, 4, 6, 8]
top_nodes = [ith for ith in range(n_nodes) if ith%2==1]  # [1, 3, 5, 7, 9]
iter_edges = zip(
    np.random.choice(bottom_nodes, n_edges),
    np.random.choice(top_nodes, n_edges)
)
edges = pd.DataFrame([{"source": a, "target": b} for a, b in iter_edges])

B = nx.Graph()
B.add_nodes_from(bottom_nodes, bipartite=0)
B.add_nodes_from(top_nodes, bipartite=1)
B.add_edges_from([tuple(x) for x in edges.values])

from networkx.drawing.layout import bipartite_layout  # 그래프 그리기

pos = bipartite_layout(B, bottom_nodes)
nx.draw_networkx(B, pos=pos)

이분그래프(Bipartite Graph)

6. 인접행렬(Adjacency Matrix)

* 원소 $M_{ij}$의 값은 노드 $i$에서 노드 $j$로 가는 간선이 있을 때에는 1, 없을 때에는 0인 정방행렬($|V| \times |V|$)

* 무향그래프
- 간선의 방향이 없기 때문에 대칭이 됨

G = nx.Graph()  # 무향그래프
V = {"서울", "부산", "인천", "대구"}  # 문자열, 클래스, 다른 networkx 그래프와 같이 해시가능한 객체
E = [
    ("서울", "부산"),
    ("서울", "인천"),
    ("서울", "대구"),
    ("부산", "대구")
]
G.add_nodes_from(V)
G.add_edges_from(E)

print("Pandas DataFrame:\n", nx.to_pandas_adjacency(G))  # Pandas DataFrame 인접행렬
print("Numpy Array:\n", nx.to_numpy_array(G))  # Numpy Array 인접행렬

Pandas DataFrame:
부산 서울 대구 인천
부산 0.0 1.0 1.0 0.0
서울 1.0 0.0 1.0 1.0
대구 1.0 1.0 0.0 0.0
인천 0.0 1.0 0.0 0.0
Numpy Array:
[[0. 1. 1. 0.]
[1. 0. 1. 1.]
[1. 1. 0. 0.]
[0. 1. 0. 0.]]

* 유향그래프
- 대칭이 보장되지 않음

G = nx.DiGraph()  # 유향그래프
V = {"서울", "부산", "인천", "대구"}
E = [
    ("부산", "서울"),
    ("인천", "서울"),
    ("대구", "서울"),
    ("부산", "인천"),
    ("대구", "부산"),
    ("대구", "인천")
]
G.add_nodes_from(V)
G.add_edges_from(E)

print("Pandas DataFrame:\n", nx.to_pandas_adjacency(G))  # Pandas DataFrame 인접행렬
print("Numpy Array:\n", nx.to_numpy_array(G))  # Numpy Array 인접행렬

Pandas DataFrame:
부산 서울 대구 인천
부산 0.0 1.0 0.0 1.0
서울 0.0 0.0 0.0 0.0
대구 1.0 1.0 0.0 1.0
인천 0.0 1.0 0.0 0.0
Numpy Array:
[[0. 1. 0. 1.]
[0. 0. 0. 0.]
[1. 1. 0. 1.]
[0. 1. 0. 0.]]

* 다중그래프
- 같은 노드 쌍을 연결하는 간선이 여러 개 있을 수 있으므로, 1보다 큰 값을 가질 수 있음

G = nx.MultiDiGraph()  # 유향다중그래프
V = {"서울", "부산", "인천", "대구"}
E = [
    ("부산", "서울"),
    ("부산", "서울"),
    ("인천", "서울"),
    ("대구", "서울"),
    ("대구", "서울"),
    ("부산", "인천"),
    ("대구", "부산"),
    ("대구", "인천")
]
G.add_nodes_from(V)
G.add_edges_from(E)

print("Pandas DataFrame:\n", nx.to_pandas_adjacency(G))  # Pandas DataFrame 인접행렬
print("Numpy Array:\n", nx.to_numpy_array(G))  # Numpy Array 인접행렬

Pandas DataFrame:
부산 서울 대구 인천
부산 0.0 2.0 0.0 1.0
서울 0.0 0.0 0.0 0.0
대구 1.0 2.0 0.0 1.0
인천 0.0 1.0 0.0 0.0
Numpy Array:
[[0. 2. 0. 1.]
[0. 0. 0. 0.]
[1. 2. 0. 1.]
[0. 1. 0. 0.]]

* 가중그래프
- 인접행렬의 값이 두 노드를 연결하는 간선의 가중값과 같음

G = nx.DiGraph()
V = {"서울", "부산", "인천", "대구"}
E = [
    ("부산", "서울", 13),
    ("인천", "서울", 7),
    ("대구", "서울", 10),
    ("부산", "인천", 17),
    ("대구", "부산", 5),
    ("대구", "인천", 15)
]
G.add_nodes_from(V)
G.add_weighted_edges_from(E)

print("Pandas DataFrame:\n", nx.to_pandas_adjacency(G))  # Pandas DataFrame 인접행렬
print("Numpy Array:\n", nx.to_numpy_array(G))  # Numpy Array 인접행렬

Pandas DataFrame:
부산 서울 대구 인천
부산 0.0 13.0 0.0 17.0
서울 0.0 0.0 0.0 0.0
대구 5.0 10.0 0.0 15.0
인천 0.0 7.0 0.0 0.0
Numpy Array:
[[ 0. 13. 0. 17.]
[ 0. 0. 0. 0.]
[ 5. 10. 0. 15.]
[ 0. 7. 0. 0.]]

7. 간선 리스트(Edge List)

* 변 $|E|$의 크기에 대한 리스트
* 각 원소는 간선이 출발하는 노드와 도착하는 노드의 쌍으로 표현

G = nx.DiGraph()
V = {"서울", "부산", "인천", "대구"}
E = [
    ("부산", "서울", 13),
    ("인천", "서울", 7),
    ("대구", "서울", 10),
    ("부산", "인천", 17),
    ("대구", "부산", 5),
    ("대구", "인천", 15)
]
G.add_nodes_from(V)
G.add_weighted_edges_from(E)

print(nx.to_pandas_edgelist(G))

source target weight
0 부산 서울 13
1 부산 인천 17
2 대구 서울 10
3 대구 부산 5
4 대구 인천 15
5 인천 서울 7

8. 그래프 그리기

* 노드는 원으로, 간선은 두 노드를 연결하는 선으로 표현

8.1. NetworkX

* networkx.draw 함수를 통해 그래프 개체를 그릴 수 있음

import networkx as nx


def draw_graph(graph, nodes_position: dict, weight):  # nodes_position: {노드 이름: 노드의 위치 좌표(직교좌표계의 2개의 값을 갖는 배열)}
    nx.draw(graph, nodes_position,
            with_labels=True, font_family="Malgun Gothic", font_size=10,  # 각 노드에 이름을 표시
            node_size=400,  # 노드의 크기
            edge_color="grey",  # 간선의 색상
            arrowsize=30)  # 간선의 화살표 크기(유향그래프인 경우)
    if weight:
        edge_labels = nx.get_edge_attributes(graph, "weight")
        nx.draw_networkx_edge_labels(graph, nodes_position, edge_labels=edge_labels)


G = nx.DiGraph()
V = {"서울", "부산", "인천", "대구"}
E = [
    ("부산", "서울", 13),
    ("인천", "서울", 7),
    ("대구", "서울", 10),
    ("부산", "인천", 17),
    ("대구", "부산", 5),
    ("대구", "인천", 15)
]
G.add_nodes_from(V)
G.add_weighted_edges_from(E)

nodes_position = {
    "서울": [1, 1],
    "부산": [1, 0],
    "인천": [0, 1],
    "대구": [0.5, 0]
}
draw_graph(G, nodes_position, True)

* 노드 레이아웃 종류
- NetworkX는 레이아웃에 따라 각 노드의 위치를 자동으로 계산하는 기능 지원
- networkx.drawing.layout 라이브러리에 있는 bipartite_layout, circular_layout, kamada_kawai_layout, planar_layout, random_layout, spring_layout, shell_layout, spectral_layout, spiral_layout 레이아웃 활용 가능
- 복잡한 그래프는 Gephi를 사용하는 것을 추천!

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import networkx as nx
from networkx.drawing.layout import bipartite_layout, circular_layout, kamada_kawai_layout, planar_layout, random_layout, spring_layout, shell_layout, spectral_layout, spiral_layout


n_nodes = 10
n_edges = 20
nodes = np.arange(n_nodes)  # [0, ..., 9]

fig, subs = plt.subplots(nrows=3, ncols=3, figsize=(9, 9))
for sub, layout in zip(subs.flatten(),
                       [bipartite_layout, circular_layout, kamada_kawai_layout, planar_layout, random_layout, spring_layout, shell_layout, spectral_layout, spiral_layout]):
    iter_edges = zip(
        np.random.choice(nodes[:5], n_edges),
        np.random.choice(nodes[5:], n_edges)
    )
    edges = pd.DataFrame([{"source": a, "target": b} for a, b in iter_edges])
    
    G = nx.Graph()
    G.add_nodes_from(nodes)
    G.add_edges_from([tuple(x) for x in edges.values])
    
    if layout.__name__=="bipartite_layout":
        pos = layout(G, nodes=nodes[:5])
    else:
        pos = layout(G)
    nx.draw(G, pos=pos, ax=sub, with_labels=True, font_size=10, node_size=100)
    sub.set_title(layout.__name__)

NetworkX 그래프 레이아웃