[5] GNN(GraphSAGE/ GAT) - Cora 논문 인용 Network

📊 성능 비교 (일반적으로)

모델핵심 아이디어성능특징

GCN	평균 이웃 정보 (정규화된 합산)	기본	빠름, 간단
GraphSAGE	이웃 정보 집계 (mean / LSTM 등)	★★☆	inductive 가능
GAT	이웃마다 attention 가중치 적용	★★★	성능 좋지만 느림

 

🧠 목표

• Cora 데이터로 GrapheSAGE 구현 
• Cora 데이터로 GAT 구현 

 

💡GraphSAGE (Graph Sample and Aggregation)

이웃 노드의 정보를 집계(aggregate) 해서 노드 임베딩을 업데이트 하는 방식

🧠 핵심 아이디어:

• 이웃 노드들을 단순 평균(MEAN), LSTM, MAX 등으로 집계
• 이렇게 집계한 값을 자기 자신의 값과 결합(concat)하여 다음 레이어로 전달

📦 특징

Inductive	학습 시 안 본 노드에도 일반화 가능!
다양한 Aggregator 지원	mean, max, LSTM, pooling 등
빠르고 유연함	미니배치 학습도 가능하게 설계됨

 

 

#Cora + GraphSAGE

import torch
import torch.nn.functional as F
from torch_geometric.datasets import Planetoid
from torch_geometric.nn import SAGEConv

• SAGEConv: PyG에서 제공하는 GraphSAGE 레이어입니다.

 

dataset = Planetoid(root='data/', name='Cora')
data = dataset[0]

• Cora는 논문 인용 그래프입니다.
• data.x: 논문 피처 (1433차원)
• data.edge_index: 인용 관계 (2, 10556)
• data.y: 정답 레이블 (주제 0~6)
• data.train_mask, data.test_mask: 학습/테스트에 사용할 노드

class GraphSAGE(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = SAGEConv(dataset.num_node_features, 32)
        self.conv2 = SAGEConv(32, dataset.num_classes)

    def forward(self, x, edge_index):
        x = F.relu(self.conv1(x, edge_index))
        x = self.conv2(x, edge_index)
        return x

✔️ 모델 구조

계층역할

conv1	입력 1433 → 중간 피처 32차원
conv2	32차원 → 클래스 수(7) 출력
relu	비선형성 주기

 

 

model = GraphSAGE()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)

 

• Adam: 가중치 업데이트 알고리즘
• lr: 학습률
• weight_decay: 과적합 방지 정규화

 

for epoch in range(200):
    model.train()
    optimizer.zero_grad()
    out = model(data.x, data.edge_index)
    loss = F.cross_entropy(out[data.train_mask], data.y[data.train_mask])
    loss.backward()
    optimizer.step()

 

model.train()	학습 모드로 설정
optimizer.zero_grad()	기울기 초기화
model(...)	forward 실행 → 예측
cross_entropy(...)	예측과 정답 비교해 손실 계산
loss.backward()	역전파: 기울기 계산
optimizer.step()	가중치 업데이트

 

 

model.eval()
pred = model(data.x, data.edge_index).argmax(dim=1)
correct = (pred[data.test_mask] == data.y[data.test_mask]).sum()
acc = int(correct) / int(data.test_mask.sum())
print(f"[GraphSAGE] Test Accuracy: {acc:.4f}")

 

model.eval()	평가 모드 설정
argmax(dim=1)	각 노드마다 가장 높은 클래스 선택
correct == y	정답과 비교해 맞춘 개수 계산
acc	정확도 (정답 수 / 전체 수)

 

 

🧠 한눈에 요약

구성 요소GraphSAGE 설명

모델 구조	이웃 정보를 평균 → 자신과 결합
PyG 레이어	SAGEConv
장점	빠르고 inductive (새로운 노드에도 적용 가능)
사용 방식	GCN과 거의 동일하게 사용 가능
성능	GCN보다 일반적으로 더 유연하고, 종종 더 정확함

 

 

 

 

💡GAT (Graph Attention Network)

🧠 1. GAT란?

**Graph Attention Network (GAT)**는 그래프 신경망(GNN)의 한 종류로,
**노드 간 연결(edge)**에 대해 ‘중요도(attention)’를 스스로 학습하여 정보 전파를 수행하는 모델입니다.

GAT은 기존 GNN(GCN 등)이 가지는 한계를 개선하기 위해 제안되었으며,
그래프의 이웃 노드들 중 어떤 노드의 정보가 더 중요한지 동적으로 판단할 수 있도록 설계되었습니다.

✅ 왜 Attention이 필요한가?

기존 GCN은 이웃 노드의 정보를 단순히 **평균(average) 또는 합(sum)**해서 사용합니다.
→ 즉, 모든 이웃 정보를 동일하게 간주합니다.

하지만 현실 세계의 그래프에서는 모든 이웃이 동등하게 중요하지 않습니다.

예:

• SNS에서 친구 중 영향력 있는 사용자의 정보가 더 중요할 수 있음
• 화학 분자 구조에서 특정 원자는 반응성에 더 중요한 역할을 할 수 있음

GAT은 이런 상황을 해결하기 위해, "어떤 이웃의 정보에 더 집중할 것인지"를 학습합니다.

 

📌 기존 GCN/SAGE vs GAT의 차이점

GCN / GraphSAGE                                                        GAT

이웃 정보를 평균하거나 고정 방식으로 합침	이웃마다 "얼마나 중요한지" attention 가중치를 계산해서 합침
모든 이웃이 동등하게 취급됨	중요한 이웃은 더 많이 반영, 덜 중요한 이웃은 덜 반영

 

💡 직관

“중요한 이웃은 말을 더 귀담아 듣고, 덜 중요한 이웃은 무시한다”
→ 논문 인용 네트워크에서 "핵심 논문"은 더 영향력을 갖게 됨

 

 

💡 초기 셋팅 

##GAT
import torch
import torch.nn.functional as F
from torch_geometric.datasets import Planetoid
from torch_geometric.nn import GATConv
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt

# 1. 데이터셋 로드
dataset = Planetoid(root='data/', name='Cora')
data = dataset[0]

 

💡 GAT 모델 정의 

# 2. GAT 모델 정의
class GAT(torch.nn.Module):
    def __init__(self, use_dropout=True):
        super().__init__()
        self.use_dropout = use_dropout
        self.gat1 = GATConv(dataset.num_node_features, 8, heads=8, dropout=0.6)
        self.gat2 = GATConv(8 * 8, dataset.num_classes, heads=1, concat=False, dropout=0.6)

    def forward(self, x, edge_index):
        if self.use_dropout:
            x = F.dropout(x, p=0.6, training=self.training)
        x = F.elu(self.gat1(x, edge_index))
        if self.use_dropout:
            x = F.dropout(x, p=0.6, training=self.training)
        x = self.gat2(x, edge_index)
        return x

💡 학습 함수

# 3. 학습 함수
def train(model):
    optimizer = torch.optim.Adam(model.parameters(), lr=0.005, weight_decay=5e-4)
    model.train()
    for epoch in range(200):
        optimizer.zero_grad()
        out = model(data.x, data.edge_index)
        loss = F.cross_entropy(out[data.train_mask], data.y[data.train_mask])
        loss.backward()
        optimizer.step()

💡 시각화 함수 정의

# 4. 시각화 함수
def visualize(model, title=''):
    model.eval()
    with torch.no_grad():
        x = data.x
        x = model.gat1(x, data.edge_index)  # 중간 임베딩 추출
    z = TSNE(n_components=2).fit_transform(x.cpu().numpy())
    y = data.y.cpu().numpy()
    plt.figure(figsize=(8, 6))
    plt.title(title)
    for i in range(dataset.num_classes):
        plt.scatter(z[y == i, 0], z[y == i, 1], label=f"Class {i}", alpha=0.6)
    plt.legend()
    plt.grid(True)
    plt.show()

1. model.eval()

• 학습이 아닌 “테스트/시각화” 모드로 전환합니다.
• Dropout, BatchNorm 같은 계층이 다른 방식으로 작동하므로 반드시 필요합니다.
• 즉, 항상 일정한 결과를 보장해주기 위해 씁니다.

2. with torch.no_grad():

• PyTorch의 연산 기록 기능을 끔
• 우리가 지금은 "학습"이 아니라 **“결과 보기”**만 하니까
  → GPU 메모리 아끼고, 속도도 빨라집니다.

3. x = data.x

• Cora 데이터에서 각 논문을 나타내는 벡터 (feature)
• shape: [2708, 1433]
  → 2708개의 노드(논문), 각각 1433차원 (단어 기준 bag-of-words)

4. x = model.gat1(x, data.edge_index)

• gat1은 GATConv 레이어입니다.
• 여기서 하는 일:
  • 각 노드가 자기 이웃(인용한 논문)의 정보를 보고
  • attention score를 계산해서,
  • 자신만의 벡터 표현을 생성합니다.
• 결과: shape [2708, 64]
  → 각 노드가 64차원의 벡터로 압축됨

5. z = TSNE(n_components=2).fit_transform(...)

✅ TSNE란?

• 고차원 벡터(64차원)를 2차원으로 줄여서 시각화하는 방법입니다.
• 단순히 PCA보다 더 군집 구조를 잘 보존합니다.
• Input : 2708개 벡터 (각각 64차원)
  ↓
  TSNE → 비슷한 벡터끼리 가깝게, 다른 벡터는 멀리
  ↓
  Output : 2708개 2D 좌표 (각각 [x, y])
• 결과 shape: [2708, 2]
• 이걸 평면(x, y) 위에 뿌립니다.

6. y = data.y.cup().numpy()

• 각 노드의 **정답 라벨 (0~6 클래스)**을 가져옵니다.
• shape: [2708]

7. Plotting with matplotlib

for i in range(dataset.num_classes):
    plt.scatter(z[y == i, 0], z[y == i, 1], label=f"Class {i}", alpha=0.6)

 

• 클래스별로 나눠서 다른 색깔로 점들을 찍어요
• z[y == i]: 클래스 i에 속한 노드들만 선택
• .scatter(...): 해당 노드들의 x, y 좌표를 2D에 찍기

🔁 왜 gat1까지만?

model.gat1(...)까지만 통과시킨 이유는
출력층(gat2)은 softmax 이전의 로짓이므로, 군집 형태가 명확하지 않아요.

gat1은 "내가 이웃 정보를 기반으로 어떤 벡터로 변했는지"를 보여주는 중간 표현이라
내부 표현 공간이 어떻게 형성됐는지 확인하기에 좋습니다.

✅ 요약 정리

구성설명

model.gat1(...)	GAT 첫 레이어의 임베딩 추출
TSNE(n_components=2)	64차원 → 2차원 축소
scatter(...)	각 클래스를 다른 색으로 찍기
목적	모델이 노드를 얼마나 잘 구분하는지 시각적으로 확인

 

 

# 5. 학습 및 시각화
# (1) Dropout 포함
model_dropout = GAT(use_dropout=True)
train(model_dropout)
visualize(model_dropout, title='GAT with Dropout')

# (2) Dropout 없이
model_nodrop = GAT(use_dropout=False)
train(model_nodrop)
visualize(model_nodrop, title='GAT without Dropout')

 

 

 

 

 

[참고사항]

🎯 GCN이랑 GraphSAGE 차이는 ? 

한 줄 요약

모델이웃 정보를 어떻게 처리?

GCN	이웃의 정보를 **평균(MEAN)**해서 업데이트
GraphSAGE	이웃 정보를 **커스터마이즈된 방식(MEAN, LSTM, MAX 등)**으로 집계해서 업데이트

🧠 구조적 차이 요약

항목GCNGraphSAGE

핵심 아이디어	선형 변환 후 정규화된 평균	다양한 Aggregator 함수로 이웃 정보 요약
자기 정보 포함	YES	YES
파라미터 공유	YES (공통 W)	YES (공통 W), Aggregator는 선택 가능
연산 방식	"정규화된 합성곱"처럼 동작	"샘플링 + Aggregation" 구조
대표 Aggregator	평균(MEAN)	MEAN, LSTM, MAX, POOL 등

🔎 직관적 예시

예: 노드 A의 이웃 = {B, C}

🟢 GCN

• A의 새 피처 = B, C, A의 벡터를 평균 → 선형 변환
• "이웃 정보를 평등하게 합쳐서 전달"

🔵 GraphSAGE

• A의 새 피처 =
  • (1) A 자체의 벡터
  • (2) B, C의 벡터를 평균
    → 이 둘을 이어붙인 뒤 → 선형변환
• "자기 정보 + 이웃 정보를 나눠서 처리"

 

 

 

---

🎯 Dropout이란?

Dropout은 딥러닝 모델의 과적합(overfitting)을 막기 위해 고안된 정규화 기법입니다.
학습할 때 무작위로 일부 뉴런을 꺼서(= 0으로 만들어서) 학습하게 합니다.

 

📌 왜 필요한가요?

신경망은 학습 데이터에 너무 잘 맞게 되면,
→ **새로운 데이터에 일반화가 잘 안 되는 현상 (과적합)**이 발생합니다.

예: 훈련 데이터만 외우고, 시험은 못 보는 상태

그래서 Dropout을 쓰면,
→ 학습 중 일부 뉴런을 꺼서 강제로 모델이 “더 일반적인” 패턴을 학습하도록 유도합니다.

 

🧪 학습 vs 테스트

단계dropout 사용설명

학습 (train)	✅ 사용	일부 뉴런을 랜덤하게 끔
평가 (eval)	❌ 미사용	모든 뉴런 사용 (평균화됨)

🧩 Cora 데이터 구조 복습

• data.x: 1433차원 벡터 (논문에서 어떤 단어가 등장했는지)
• 예:
  data.x[0] = [0, 1, 0, 0, 1, ..., 0] # 논문 0은 단어2, 단어5 등장
• GAT 모델은 이걸 받아서 노드 임베딩을 만듭니다.

🔥 Dropout이 작동하는 부분

x = F.dropout(x, p=0.6, training=self.training)

즉,

• x는 각 논문(노드)의 1433차원 피처 벡터
• 이걸 학습 중에는 60% 확률로 랜덤하게 일부 차원을 꺼버립니다
• 즉, 논문 0의 피처 중 일부 단어 정보는 "없는 것처럼" 학습하게 됩니다.

 

🎯 왜 이렇게 하냐?

이유:
👉 특정 피처(단어)에 너무 의존하지 않도록 하기 위해서입니다.

만약 dropout 없이 학습하면,

• 어떤 단어 하나가 "답"을 암시하는 경우,
• 모델이 그 단어만 외우게 됨 → 일반화 잘 안 됨

반면 dropout을 쓰면,

• 그 단어가 랜덤하게 사라지기도 함
• → 모델은 다양한 단어 조합에서 잘 작동해야 함

 

data.x → Dropout → GATConv (attention) → Dropout → GATConv → 결과
위치 역할
첫 번째 Dropout 입력 피처 일부 제거해서 강건한 표현 유도
두 번째 Dropout 중간 임베딩 일부 제거 (오버피팅 방지)

 

 

x = F.dropout(x, p=0.6, training=True)

이건 내부적으로 다음을 합니다:

1. x와 같은 shape의 마스크 mask를 생성 (1 또는 0)
2. 각 원소에 대해:
   • 60% 확률로 0
   • 40% 확률로 1 / 0.4 (= 2.5)로 스케일

즉, 다음처럼 작동합니다:

원래 x마스크드롭아웃 후

1.0	0	0.0
0.0	1	0.0
1.0	1	1.0 / 0.4 ≈ 2.5
0.0	0	0.0

 

👉 0인 값은 무조건 0 그대로 유지,
👉 1인 값은 랜덤하게 살거나 죽고, 살아남으면 2.5로 조정됩니다 (학습 평형 유지용)

 

✋ 중요 개념: Dropout은 무조건 무작위!

오해진실

"값이 작으면 드롭되고, 크면 안 드롭된다?"	❌ X
"중요하지 않으면 드롭된다?"	❌ X
"무조건 랜덤하게 드롭된다"	✅ O

 

 

GAT는:

• **attention 계수 α_ij**를 통해
  → 이웃 중 중요한 노드에 더 많은 가중치를 줍니다.
• 이 자체로 중요하지 않은 이웃은 무시하는 효과가 있어요.

Dropout은:

• 이 attention 계수 또는 입력 피처에 **무작위성(randomness)**을 넣어서
• 학습을 더 robust하게 만들고,
• 특정 피처나 연결에만 의존하지 않도록 도와줍니다.

그래서 정리하면:

✅ Dropout은 GAT의 attention과 상호 보완적인 역할을 합니다.
GAT이 연결에 가중치 차이를 두는 기능이라면,
Dropout은 이 연결이나 피처 자체에 무작위성을 부여해서 과적합을 방지합니다.

 

 

---

🎯 GAT 에서 head란?

GATConv는 **멀티-헤드 어텐션(Multi-head Attention)**을 사용합니다.

즉, "여러 개의 독립된 attention layer를 동시에 학습해서 결과를 합친다"

GAT에서 head란, "각기 다른 방식으로 이웃 정보를 통합하는 병렬적인 attention 계산기"입니다.

물리적으로는:

• 각 head는 독립된 weight(가중치)를 갖는 하나의 GNN 레이어예요.
• Cora 데이터에서 각 head는 **논문(노드)**가 이웃 논문으로부터 정보를 받아올 때,
  → “다르게 중요도를 판단해서” 정보를 취합합니다.

 

 

 

🔍 어떻게 64차원이 만들어지나?

1개의 GAT head는:

• 이웃 정보를 attention으로 받아서 → out_channels = 8차원 출력

8개의 GAT head는:

• 이 과정을 8번 독립적으로 병렬 수행
• 마지막에 **concat (연결)**합니다.

Head 1: 8차원
Head 2: 8차원
...
Head 8: 8차원
-------------
Concat → 총 64차원

 

 

🎯 핵심 정리

항목의미

💡 head란?	이웃을 바라보는 독립된 attention 계산기
📦 내부에 뭐 있음?	각 head마다 독립적인 weight, attention 계산
📌 역할	이웃 노드의 중요도를 다르게 평가해서 피처 조합
🤝 여러 head 쓰는 이유	다양한 관점으로 이웃을 보고 더 강력한 표현 만들기

✅ 그럼 head는 몇 개가 적당할까?

데이터셋일반적인 head 수

Cora, Citeseer	4~8개
PubMed	4~16개
복잡한 그래프	더 많게 가능하지만 주의 필요

 

즉, head 는 각 노드의 가중치를 계산하는 function 같은거 !