[AI 기초 다지기] RNNsearch & Pointer Networks 논문 분석 및 코드 구현

Neural Machine Translation with Attention

목차

1. 소개
2. 기존 접근 방식의 한계
3. 주목 메커니즘(Attention Mechanism)
4. 모델 아키텍처
5. 학습 방법
6. 실험 결과
7. 결론 및 향후 연구 방향

1. 소개

1.1 연구 배경

Neural Machine Translation(NMT)은 최근 제안된 기계번역의 새로운 패러다임입니다. 기존의 통계 기반 기계번역과 달리, NMT는:

• 단일 신경망으로 번역 성능 최적화
• End-to-End 학습 가능
• 수작업으로 설계된 특징(feature) 불필요

1.2 기존 NMT의 문제점

• 고정 길이 벡터로 인한 정보 압축의 한계
• 긴 문장에서의 성능 저하
• 문맥 정보 손실 위험

2. 기존 접근 방식의 한계

2.1 인코더-디코더 구조

# 기존 인코더-디코더 방식
c = q({h1, ..., hTx})  # 전체 문장을 고정 길이 벡터로 압축

2.2 성능 제한 요소

• 입력 문장 길이에 관계없이 동일한 크기의 컨텍스트 벡터 사용
• 긴 문장에서 정보 손실 불가피
• 번역 품질 저하

3. 주목 메커니즘(Attention Mechanism)

3.1 핵심 아이디어

# 주목 메커니즘 수식
eij = a(si-1, hj)  # 정렬 모델
αij = exp(eij) / Σk exp(eik)  # 정규화된 가중치
ci = Σj αij * hj  # 컨텍스트 벡터

3.2 장점

1. 가변 길이 컨텍스트 벡터
2. 선택적 정보 접근
3. 번역 과정의 해석 가능성

4. 모델 아키텍처

4.1 인코더

• 양방향 RNN 사용
• 순방향, 역방향 상태 결합

# 양방향 RNN 구현
h_forward = forward_rnn(x)
h_backward = backward_rnn(x)
h = concatenate([h_forward, h_backward])

 

4.2 디코더

• GRU(Gated Recurrent Unit) 사용
• 적응형 컨텍스트 벡터 계산

# 디코더 상태 갱신
s_t = GRU(s_t-1, y_t-1, c_t)
# 출력 확률 계산
p(y_t) = softmax(f(s_t, y_t-1, c_t))

 

4.3 정렬 모델

• 단일 층 피드포워드 신경망
• 소프트맥스 정규화
• 디코더 상태와 어노테이션 간 유사도 계산

5. 학습 방법

5.1 목적 함수

# 조건부 확률 최대화
max_θ Σ log p(y|x; θ)

5.2 최적화 세부사항

• 미니배치 크기: 80 문장
• 옵티마이저: SGD + Adadelta
• 그래디언트 클리핑: 임계값 1
• 파라미터 초기화:
  • 순환 가중치: 직교 행렬
  • 나머지 가중치: 가우시안 분포

5.3 하이퍼파라미터

• 은닉층 크기: 1000
• 단어 임베딩 차원: 620
• maxout 은닉층 크기: 500
• 정렬 모델 크기: 1000

6. 실험 결과

6.1 영어-프랑스어 번역 성능

1. BLEU 스코어 비교
   • 기존 모델(RNNenc): 17.82
   • 제안 모델(RNNsearch): 26.75
   • Moses(통계기반): 33.30
2. 문장 길이별 성능
   • 30단어 이하: 유사한 성능
   • 30단어 이상: 현저한 성능 차이
   • 50단어 이상: 기존 모델 성능 급감

6.2 정성적 분석

1. 정렬(Alignment) 시각화
   • 직관적으로 타당한 단어 정렬
   • 언어 간 어순 차이 처리 능력
2. 긴 문장 번역 예시
   • 문맥 유지 능력 향상
   • 일관된 번역 품질

7. 결론 및 향후 연구 방향

7.1 주요 성과

1. 고정 길이 벡터의 한계 극복
2. 긴 문장에서의 성능 개선
3. 해석 가능한 번역 과정

7.2 향후 연구 과제

1. 미등록어(Unknown words) 처리 개선
2. 계산 효율성 향상
3. 다국어 확장성 검증

7.3 시사점

1. 신경망 기계번역의 가능성 입증
2. 주목 메커니즘의 효과성 확인
3. End-to-End 학습의 장점 검증

구현 세부사항

모델 구현 코드

class AttentionNMT:
    def __init__(self, hidden_size=1000, embedding_size=620):
        self.hidden_size = hidden_size
        self.embedding_size = embedding_size
        
    def encode(self, source_sequence):
        # 양방향 RNN 인코더
        forward = self.forward_rnn(source_sequence)
        backward = self.backward_rnn(source_sequence)
        return concatenate([forward, backward])
        
    def attend(self, decoder_state, encoder_states):
        # 주목 가중치 계산
        weights = self.alignment_model(decoder_state, encoder_states)
        # 컨텍스트 벡터 계산
        return sum(weights * encoder_states)
        
    def decode(self, encoder_states, target_sequence):
        # 디코더 상태 초기화
        state = self.initialize_state()
        outputs = []
        
        for t in range(len(target_sequence)):
            # 주목 메커니즘 적용
            context = self.attend(state, encoder_states)
            # 다음 단어 예측
            output = self.predict_next_word(state, context)
            outputs.append(output)
            # 상태 갱신
            state = self.update_state(state, output, context)
            
        return outputs

 

 

Pointer Networks: 가변 길이 출력을 위한 신경망 구조

목차

1. 소개
2. 아키텍처
3. 응용 문제
4. 실험 결과
5. 구현 상세
6. 결론 및 향후 연구

1. 소개

1.1 연구 배경

Pointer Networks(Ptr-Nets)은 입력 시퀀스의 위치를 가리키는 이산 토큰들로 구성된 출력 시퀀스의 조건부 확률을 학습하기 위한 새로운 신경망 아키텍처입니다.

1.2 기존 접근 방식의 한계

• Sequence-to-Sequence 모델: 고정된 출력 사전 크기 필요
• Neural Turing Machines: 가변 출력 사전 크기 처리 불가
• 정렬, 조합 최적화 등의 문제에 적용 어려움

1.3 주요 혁신점

1. 가변 길이 출력 사전 처리 가능
2. "Pointer" 메커니즘을 통한 입력 참조
3. 기하학적 문제에 적용 가능
4. 학습 데이터만으로 근사 해결책 도출

2. 아키텍처

2.1 기본 구조

class PointerNetwork:
    def __init__(self, hidden_size):
        self.encoder = Encoder(hidden_size)
        self.decoder = Decoder(hidden_size)
        
    def forward(self, inputs):
        # 인코딩
        encoded_inputs = self.encoder(inputs)
        # 디코딩
        outputs = self.decoder(encoded_inputs)
        return outputs

2.2 주목 메커니즘

def attention(query, keys, values):
    # 에너지 계산
    scores = v.T * tanh(W1 * keys + W2 * query)
    # 확률 분포 계산
    weights = softmax(scores)
    # 포인터 출력
    return weights

2.3 차별점

1. 입력 시퀀스에 대한 직접적인 포인팅
2. 가변 길이 출력 사전 자연스러운 처리
3. End-to-End 학습 가능

3. 응용 문제

3.1 볼록 껍질(Convex Hull)

# 데이터 생성
def generate_convex_hull_data():
    points = np.random.uniform(0, 1, (n, 2))
    hull = ConvexHull(points)
    return points, hull.vertices

특징

• O(n log n) 복잡도의 문제
• 기하학적 특성 학습 필요
• 출력 순서 중요

3.2 Delaunay 삼각분할

# 삼각분할 출력 포맷
class DelaunayOutput:
    def __init__(self):
        self.triangles = []  # [(i,j,k), ...]
        self.incenter_order = True  # 삼각형 정렬 기준

주요 특성

• 평면 점집합의 삼각분할
• 빈 원 특성 만족
• O(n log n) 알고리즘 존재

3.3 외판원 문제(TSP)

class TSPSolver:
    def __init__(self, n_cities):
        self.ptr_net = PointerNetwork()
        
    def solve(self, cities):
        # 도시 좌표로부터 순회 경로 예측
        tour = self.ptr_net(cities)
        return self.validate_tour(tour)

문제 특성

• NP-hard 문제
• 근사 해법 학습 가능
• 실제 응용 가능성 높음

4. 실험 결과

4.1 볼록 껍질 성능

학습 크기테스트 크기정확도면적 커버리지

5-50	5	92.0%	99.6%
5-50	50	69.6%	99.9%
5-50	500	1.3%	99.2%

4.2 Delaunay 삼각분할 성능

• n=5: 정확도 80.7%, 삼각형 커버리지 93.0%
• n=50: 정확도 0%, 삼각형 커버리지 52.8%

4.3 TSP 결과

# 성능 비교 예시
test_results = {
    "n=20": {
        "optimal": 3.83,
        "ptr_net": 3.88,
        "baseline": 4.24
    }
}

5. 구현 상세

5.1 아키텍처 설정

• LSTM 단일 레이어
• 256/512 히든 유닛
• 배치 크기: 128

5.2 학습 파라미터

training_config = {
    "learning_rate": 1.0,
    "batch_size": 128,
    "weight_init_range": (-0.08, 0.08),
    "gradient_clip": 2.0,
    "training_examples": 1_000_000
}

5.3 데이터 생성

def generate_data(problem_type, n_points):
    if problem_type == "convex_hull":
        return generate_convex_hull_data(n_points)
    elif problem_type == "delaunay":
        return generate_delaunay_data(n_points)
    else:  # TSP
        return generate_tsp_data(n_points)

6. 결론 및 향후 연구

6.1 주요 성과

1. 가변 길이 출력 문제 해결
2. 기하학적 문제에 대한 적용 가능성 입증
3. NP-hard 문제에 대한 근사해 학습 가능

6.2 한계점

1. 매우 긴 시퀀스에서의 성능 저하
2. 계산 복잡도 O(n²)
3. 최적해 보장 불가

6.3 향후 연구 방향

1. 계산 효율성 개선
2. 다양한 조합 최적화 문제 적용
3. 더 복잡한 문제에 대한 확장

6.4 잠재적 응용 분야

• 경로 계획
• 레이아웃 최적화
• 스케줄링 문제
• 자원 할당 최적화