슬기로운 혀니의 코딩 생활

백준 10868 - 최솟값

Hyeon Lee — Sun, 7 Jul 2024 11:40:10 +0900

문제

N(1 ≤ N ≤ 100,000)개의 정수들이 있을 때, a번째 정수부터 b번째 정수까지 중에서 제일 작은 정수를 찾는 것은 어려운 일이 아니다. 하지만 이와 같은 a, b의 쌍이 M(1 ≤ M ≤ 100,000)개 주어졌을 때는 어려운 문제가 된다. 이 문제를 해결해 보자.

여기서 a번째라는 것은 입력되는 순서로 a번째라는 이야기이다. 예를 들어 a=1, b=3이라면 입력된 순서대로 1번, 2번, 3번 정수 중에서 최솟값을 찾아야 한다. 각각의 정수들은 1이상 1,000,000,000이하의 값을 갖는다.

입력

첫째 줄에 N, M이 주어진다. 다음 N개의 줄에는 N개의 정수가 주어진다. 다음 M개의 줄에는 a, b의 쌍이 주어진다.

출력

M개의 줄에 입력받은 순서대로 각 a, b에 대한 답을 출력한다.

예제 입력 1 복사

예제 출력 1 복사

최솟값 문제를 처음 보고 입력을 받은 후 각 인덱스를 저장해서 min 값을 더해주면 되는건가 생각했는데, 역시나 자료구조를 사용하지 않으니 통과가 되지 않았다. 이 문제는 세그먼트 트리를 사용해야하는 문제이다. 세그먼트 트리가 무엇인지조차 기억이 나지 않았기 때문에... 구글링을 해보고 문제를 풀게 되었다.

※ 세그먼트 트리란?

- 어떤 데이터가 존재할 때, 특정 구간의 값을 구할 때 사용하는 자료구조

- 구간합, 주어진 쿼리에 대해 빠르게 응답하기 위한 자료구조

- 기본적으로 Binary Tree 구조를 가지고 있음

- O(logN) 시간 복잡도를 가지며, 최악의 경우 O(NlogN)을 가짐

- 완전 탐색에 비해 더 많은 메모리를 필요로 하게 됨

[Algorithm] 세그먼트 트리(Segment Tree) with Python (tistory.com)

[Algorithm] 세그먼트 트리(Segment Tree) with Python

목차 Segment Tree? 구현 query 응답하기 업데이트 1. Segment Tree? 어떤 데이터가 존재할 때, 특정 구간의 결과값을 구하는데 사용하는 자료구조이다. 단순한 구간합 뿐만 아니라주어진 쿼리에 대해 빠

cheon2308.tistory.com

이 블로그 포스팅을 많이 참고 했다.

그렇다면 세그먼트 트리를 구현해보자.

def build_segment_tree(left, right, i):
    if left == right:
        segment_tree[i] = nums[left]
        return segment_tree[i]
    mid = (right + left) // 2
    segment_tree[i] = min(build_segment_tree(left, mid, i * 2), build_segment_tree(mid + 1, right, i * 2 + 1))
    return segment_tree[i]

- left와 right가 같다면 현재 구간이 단일 요소를 의미하기 때문에, nums 배열의 해당 값을 세그먼트 트리 현재 노드에 - 저장하고 반환.

- mid 값을 찾아서 이진 분류 형태 만들기

- segment_tree 리스트에 재귀적으로 좌측 노드와 우측 노드의 최솟값을 담기

def query_min(start, end, idx, left, right):
    if left > end or right < start:
        return float('inf')
    if left <= start and right >= end:
        return segment_tree[idx]
    mid = (start + end) // 2
    return min(query_min(start, mid, idx * 2, left, right), query_min(mid + 1, end, idx * 2 + 1, left, right))

- idx : 세그먼트 트리 현재 노드 인덱스

- left, right : 질의 구간의 시작, 끝 인덱스

- 질의 구간이 현재 노드 구간과 겹치지 않으면 무한대 반환

- 질의 구간이 현재 노드 구간과 겹치면 idx(현재 노드 인덱스)를 반환

- mid 값을 찾아서 이진 분류 형태 만들기

- 재귀적으로 좌측 노드와 우측 노드의 최솟값을 반환

def update(start, end, node, idx, val):
    if start > idx or idx > end:
        return segment_tree[node]
    if start == end:
        segment_tree[node] = val
        return segment_tree[node]
    mid = (start + end) // 2
    segment_tree[node] = min(update(start, mid, node * 2, idx, val), update(mid + 1, end, node * 2 + 1, idx, val))
    return segment_tree[node]

- node : 세그먼트 트리의 현재 노드 인덱스

- idx : 업데이트할 리스트의 인덱스

- val : 새로운 값

- 업데이트할 인덱스가 현재 노드 구간에 포함되지 않으면 현재 노드 값을 그대로 반환

- 현재 노드가 업데이트할 인덱스를 나타내면 val로 새로운 값 업데이트 시키고 반환

- segment_tree의 현재 노드 인덱스에 좌측노드, 우측노드의 최솟값을 재귀적으로 담아서 갱신 후 현재 노드가 담긴 segment_tree를 반환

이 방식으로 세그먼트 트리를 구현한 후 입력 형식을 맞춰서 세그먼트 트리를 빌드하고 구간을 쿼리 함수를 사용해서 질의하고 update 함수로 갱신시킨 후 담아서 출력해주면 된다.

최종 코드

import sys
input = sys.stdin.readline

def build_segment_tree(left, right, i):
    if left == right:
        segment_tree[i] = nums[left]
        return segment_tree[i]
    mid = (right + left) // 2
    segment_tree[i] = min(build_segment_tree(left, mid, i * 2), build_segment_tree(mid + 1, right, i * 2 + 1))
    return segment_tree[i]

def query_min(start, end, idx, left, right):
    if left > end or right < start:
        return float('inf')
    if left <= start and right >= end:
        return segment_tree[idx]
    mid = (start + end) // 2
    return min(query_min(start, mid, idx * 2, left, right), query_min(mid + 1, end, idx * 2 + 1, left, right))

def update(start, end, node, idx, val):
    if start > idx or idx > end:
        return segment_tree[node]
    if start == end:
        segment_tree[node] = val
        return segment_tree[node]
    mid = (start + end) // 2
    segment_tree[node] = min(update(start, mid, node * 2, idx, val), update(mid + 1, end, node * 2 + 1, idx, val))
    return segment_tree[node]

n, m = map(int, input().split())
nums = [int(input()) for _ in range(n)]
queries = [tuple(map(int, input().split())) for _ in range(m)]

segment_tree = [0] * (4*n)
build_segment_tree(0, n-1, 1)

results = []
for i, j in queries:
    result = query_min(0, n-1, 1, i-1, j-1)
    results.append(result)

for result in results:
    print(result)

Direct Preference Optimization: Your Language Model is Secretly a Reward Model 논문 리뷰

Hyeon Lee — Wed, 22 May 2024 16:17:17 +0900

[2305.18290] Direct Preference Optimization: Your Language Model is Secretly a Reward Model (arxiv.org)

Direct Preference Optimization: Your Language Model is Secretly a Reward Model

While large-scale unsupervised language models (LMs) learn broad world knowledge and some reasoning skills, achieving precise control of their behavior is difficult due to the completely unsupervised nature of their training. Existing methods for gaining s

arxiv.org

Abstract

대규모 unsupervised LM은 폭넓은 지식과 추론 능력을 학습한다. 하지만, 모델의 행동을 정확히 제어하는 것은 어려운 일이다. 현재의 제어 방법은 모델 생성물의 상대적인 품질에 대한 인간의 label을 수집하고, 이를 통해서 unsupervised LM을 fine-tuning 하여 선호도에 맞추는 것이 일반적이다. 본 논문에서 이야기하는 이러한 과정은 RLHF를 포함하지만, 절차가 복잡하고 불안정한 절차이다. 인간의 선호도를 반영하는 reward model을 맞추고, reinforment learning을 통해 예측된 보상을 최대화하도록 unsupervised LM을 fine-tuning하는 방식이다.

본 논문에서는 RLHF의 reward model을 새로운 방식으로 파라미터화하여, 대응되는 최적 정책을 폐쇄형으로 추출할 수 이게 했고, 이를 통해 RLHF 문제를 단순한 분류 손실만으로 해결할 수 있는 방법을 소개하고 있다. DPO(직접 선호 최적화)라고 명명하며, 안정적이고 우수한 성능이며, 계산적으로 경량화되어 fine-tuning 동안 LM에서 샘플링을 수행하거나 중요한 하이퍼파라미터 튜닝을 필요로 하지 않는다. 논문에서 실험 결과로 DPO는 기존 방법과 동일하거나 더 나은 성능으로 LM을 인간 선호도에 맞춰 fine-tuning 할 수 있음을 보여준다. 또한, DPO를 사용한 파인 튜닝은 감정 생성의 제어 능력에서 PPO 기반 RLHF를 능가하며, 요약과 단일 턴 대화의 응답 품질에서도 향상된 성능을 보이며, 구현 및 훈련도 훨씬 간단하다.

사실상 논문의 전반적인 내용을 Abstract에서 모두 제시하고 있어, 거의 번역급으로 Abstract를 정리할 수밖에 없었다.

Introduction

대규모 unsupervised LM은 다양한 목표, 우선순위, 기술 수준을 가진 인간이 생성한 데이터로 훈련된다. 하지만, 이런 목표와 기술의 일부가 모방되기에 바람직하지 않을 수 있다. 모델의 광범위한 지식과 능력 중에서 원하는 응답과 행동을 선택하는 것은 안전하고 성능이 뛰어나며 제어 가능한 AI 시스템을 구축하는데 중요하다. 하지만, 기존 방법은 일반적으로 강화 학습을 사용하여 언어 모델을 인간의 선호도와 일치하는 방법을 사용하는데, 본 논문에서는 RL 기반 목표를 간단한 binary

cross entropy 목표로 정확하게 최적화할 수 있음을 보여준다.

기존 방법은 인간이 안전하고 유용하다고 생각하는 행동 유형을 나타내는 인간 선호도의 큐레이션 세트를 사용하여 LM에 행동을 주입한다. 일반적으로 SFT를 하거나, RLHF, RLAIF에서 강화 학습을 통한 방법을 택한다. RLHF는 인간 선호도 데이터셋에 맞춰 reward model을 최적화한 다음, 보상을 최대화하기 위해 언어 모델 정책을 최적화한다. RLHF가 인상적인 능력을 가지고 있지만, 여러 언어 모델을 훈련하고 훈련 루프 내에서 언어 모델 정책을 샘플링하는 복잡한 과정을 포함하기 때문에 상당한 계산 비용을 수반하게 된다.

본 논문에서는 보상 모델링이나 강화학습 없이 인간 선호도에 맞추어 언어 모델을 직접 최적화하는 방법을 제시한다. 구현과 훈련이 간단한 DPO 알고리즘을 제안하는데, 선호 응답에 대한 상대적 로그 확률을 증가시킬 수는 있지만, 단순 확률 비율 목표에서 발생하는 모델 붕괴를 방지하는 동적 예제별 중요 가중치를 통합한다. DPO는 Bradley-Terry 모델 등을 사용해서 주어진 보상 함수가 경험적 선호 데이터와 얼마나 잘 맞는지 측정한다.

기존 방법이 선호 손실을 정의해서 보상 모델을 훈련하고, 학습된 보상 모델을 최적화하는 정책을 훈련하는 반면에 DPO는 변수를 변경해서 정책 함수로 선호 손실을 정의한다. DPO는 단순한 binary cross entropy 목표를 사용해서 정책을 최적화하여 선호 데이터에 맞는 최적 정책을 생성한다.

위 이미지를 보면, 강화학습 단계가 생략된 DPO 모델을 통해 RLHF와의 차이점을 명확히 볼 수 있다.

Preliminaries

1. SFT : RLHF는 고품질 데이터에 대한 감독 학습을 통해 사전 훈련된 언어 모델을 파인튜닝하는 것부터 시작해서, 다운스트림 작업에 대해 πSFT 모델을 얻는다.

2. Reward Modelling Phase

- SFT 모델이 프롬프트 x에 대해 응답 쌍 (y1,y2)∼πSFT(y∣x)를 생성하도록 한다.

- 인간 평가자에게 이 쌍을 제시하고 x에 대한 ≻ 로 표시된 선호도를 나타낸다. 여기서 yw는 선호 응답, yl은 비선호 응답이다.

선호 데이터셋 ={ ( ), ( ), ( )} =1 에 접근할 수 있다고 가정하고, 최대 가능도 추정치를 통해 매개변수화된 보상 모델 rϕ(x,y) 의 매개변수를 추정한다.

- 네트워크 rϕ(x,y) 는 일반적으로 SFT 모델 πSFT(y | x) 에서 최종 트랜스포머 층 위에 단일 스칼라 예측을 생성하는 선형 층을 추가해서 초기화 된다.

3. RL Fine-Tuning Phase

- RL 단계에서는 학습된 보상 함수를 사용해서 언어 모델에 피드백을 제공한다.

다음 최적화 공식을 따른다. 여기서 beta는 기본 참조 정책 πref, 초기 SFT 모델 πSFT 로부터의 편차를 제어하는 매개변수이다. 이러한 추가된 제약 조건은 모델이 보상 모델이 정확한 분포로부터 너무 멀리 벗어나지 않도록 방지하고, 생성 다양성을 유지하고 단일 응답으로 모드 붕괴를 방지한다.

- 표준 접근 방식은 보상 함수 r(x,y)=rϕ(x,y)−β(logπθ(y∣x)−logπref(y∣x)) 을 구성하고, PPO를 사용하여 최대화 한다.

Direct Preference Optimization

강화학습 알고리즘 적용 대신, 선호도를 직접 사용해서 정책을 최적화하는 간단한 접근 방식 도출을 목표로 한다. RLHF 와 달리, 보상을 학습하고 이를 강화학습을 통해 최적화하는 대신, 최적 정책을 폐쇄형으로 추출할 수 있게 reward 모델의 특정 파라미터화를 활용해서 RL 훈련 루프 없이 최적 정책을 추출한다.

주요 인사이트는 reward function을 최적 정책에 대한 손실 함수로 변환하는 분석적 매핑을 활용하는 것이다. 변수 변환 접근 방식은 명시적 보상 모델을 맞추는 과정을 피하면서 기존의 Bradley-Terry 모델 하에서 최적화를 수행한다. 정책 네트워크가 본질적으로는 언어 모델과 암묵적인 보상 둘 다를 나타내는 것이다.

Deriving the DPO objective.

일반 보상 함수 r에서 동일한 RL 목표로

해당 수식을 따른다. 해당 수식의 KL-constrained reward maximum 목표의 최적 솔류션은 다음과 같은 형태를 취한다고 한다.

Z(x)를 추정하는 것은 여전히 비용이 많이 들지만, 위 함수를 재배열해서 reward function을 최적 정책 πr, 참조 정책 πref 및 알려지지 않은 분할 함수 Z(⋅) 로 표현할 수 있다.

위와 같이 조작 가능하며, r* 및 해당 최적 모델

에 대입하면,

위와 같이 조작이 가능하다.

최적 정책이 아닌 보상 모델 측면에서 인간 선호 확률을 표현할 수 있으므로, 우리의 정책 목표는 아래와 같은 공식으로 표현이 가능하다.

What does the DPO update do?

다음 손실함수 그래디언트를 분석하는 것이 유용하다. 매개변수 theta에 대한 손실 함수의 그래디언트는 다음과 같다.

직관적으로 손실함수 L_DPO의 그래디언트는 선호 응답 yw의 확률을 증가시키고, 비선호 응답 yl의 확률을 감소시킨다.

암묵적 보상 모델 r_theta가 비선호 응답을 얼마나 높게 평가하는지에 따라 가중치가 부여된다.

DPO outline.

1. 프롬프트 x에 대해 참조 모델 πref(⋅∣x) 에서 응답 y1, y2를 샘플링하고, 인간 선호를 레이블로 지정하여 선호 데이터셋 D={x(i),yw(i),yl(i)}i=1N 을 구성한다.

2. 주어진, , , 에 대해 L_DPO를 최소화하도록 언어 모델

Theoretical Analysis of DPO

Your Language Model Is Secretly a Reward Model

최적화 목표인 다음 식은 보상 매개변수를 사용하 Bradley-Terry 모델과 동일하다.

여러 가지 정의들과 이론들이 나오는데, 다음 내용들을 정리해보자.

Definition 1

와 ′( , )가 ( , )− ′( , )= ( ) 일 때 동등하다.

Lemma1

Bradley-Terry 선호 프레임워크 하에서 같은 클래스에 속하는 두 보상 함수는 동일한 선호 분포를 유도한다.

Lemma2

동일한 동등 클래스의 두 보상 함수는 제약된 RL 문제에서 동일한 최적 정책을 유도한다.

Theorem 1

Plackett-Luce(Bradley-Terry) 모델과 일치하는 모든 보상 클래스는

다음과 같은 형식으로 표현될 수 있다.

Theorem 1에 대한 증명 스케치를 본 논문에서 간단히 제공하고 있는데, 솔직히 잘 이해가 되지 않는다....

Instability of Actor-Critic Algorithms

본 논문에서는 DPO 프레임워크를 사용해서 PPO와 RLHF에 사용되는 표준 actor-critic 알고리즘의 불안정성을 진단한다. 파라미터화 된 모델 πθ(y∣x)를 가정하고, 최적의 정책

를 기반으로 정책을 학습한다.

Evaluation

두 가지 다른 평가 접근 방식을 사용한다.

1. 제어된 감정 생성 설정에서는 각 알고리즘이 달성한 보상과 참조 정책으로부터의 KL 발산 경계를 평가하여 제약된 보상 최대화 목표를 최적화하는 알고리즘 효과를 분석한다. -> 실제 보상 함수를 알고 있기 때문에 계산이 가능

2. 요약과 단일 회차 대화 설정에서는 실제 상황의 경우 실제 보상 함수를 알 수 없으므로, 기준 정책에 대한 승률을 사용하여 알고리즘을 평가한다.

요약 : 테스트 셋의 참조 요약을 기준으로 사용

대화 : 테스트 데이터셋의 선호 응답을 기준으로 사용

Method

DPO 외에도, 인간 선호에 맞추어 언어 모델을 학습하는 여러 기존 접근 방식을 평가한다.

요약에서 GPT-J의 zero-shot 프롬팅과 대화 작업에서 Pythia-2.8B의 2-shot 프롬팅을 탐구한다.

선호 데이터로부터 학습된 보상 함수를 사용하여 PPO를 평가하고, 제어된 감정 설정에서 실제 보상 함수를 학습하는 오라클인 PPO-GT를 평가한다. 감정 실험에서는 두 가지 PPO-GT 구현을 사용한다. 마지막으로, 선호 데이터셋에서 학습된 보상 함수를 사용하여 SFT-모델의 N개의 응답을 샘플링하고 가장 높은 점수를 받은 응답을 반환하는 Best of N 기준선을 고려한다.

How well can DPO optimize the RLHF objective?

KL 제약 보상 최대화 목표는 보상의 착취를 제한하면서 참조 정책에서 멀어지지 않도록 제한한다. 알고리즘을 비교할 때, 달성된 보상과 KL 불일치 모두를 고려해야 한다.

이미지를 살펴보자. 감정 설정에서 다양한 알고리즘에 대한 보상-KL 경계를 보여준다. 총 22개의 실행이 포함되며, 수렴할 때까지 각 100 학습 단계 후에, 각 정책을 테스트 프롬프트 집합에서 평가하여 실제 보상 함수 하의 평균 보상과 참조 정책 KL 평균 시퀀스 수준 KL을 계산한다. DPO는 KL이 낮으면서도 가장 높은 보상을 달성하여 가장 효율적인 경계를 제공하는 것을 볼 수 있다.

1) DPO와 PPO는 동일한 목표를 최적화하지만, DPO는 현저히 더 효율적이다.

2) DPO는 PPO가 실제 보상에 접근할 떄 조차 PPO-GT 성능을 상회한다.

Can DPO scale to real preference datasets?

요약 및 단일 회차 대화에서 DPO의 성능을 평가한다.

요약의 경우에 TLDR 요약 데이터셋의 테스트 분할에서 샘플 완료를 평가하고, 테스트 셋의 참조 완료에 대한 평균 승률을 계산한다. 위 이미지의 오른쪽을 살펴보자. DPO, PPO, Prefered-FT 모두 동일한 GPT-J SFT 모델을 미세조정한다. DPO가 temperature 0.0에서 약 61% 승률을 기록하고, temperature 0.0에서 57%의 최적 샘플링 온도를 가진 PPO의 성능을 초과하는 것을 발견할 수 있다. 또한, DPO는 학습된 보상 함수를 사용해서 Best of N 기준선보다 높은 최대 승률을 달성한다.

단일 회차 대화에서는 Anthropic HH 데이터셋의 테스트 분할 중 하나로부터 한 단계의 인간-비서 상호작용을 사용하여 다양한 방법을 평가한다. 전반적으로 Anthropic HH 데이터셋에서 선호된 완성본을 개선하는 유일한 계산 효율적인 방법이 DPO 이며, 계산적으로 요구가 많은 Best of 128 기준선과 비슷하거나 더 나은 성능을 제공한다.

이미지를 보면, DPO가 더 빠르게 최상의 성능에 도달하는 것을 볼 수 있다.

Generalization to a new input distribution

CNN/DailyMail의 뉴스 기사 테스트 셋에서 Reddit TLDR 요약 실험의 PPO와 DPO 정책을 평가하여 PPO와 DPO 정책의 분포 변화에 대한 성능을 비교했다.

표를 살펴보자. TLDR에 사용된 동일한 GPT-4 프롬트를 사용해서 데이터셋의 실제 요약에 대한 GPT-승률을 계산하는데, "forum post"라는 단어를 "news article"로 대체한다. DPO는 여전히 PPO 정책보다 유의미하게 더 나은 성능을 발휘한다. 이 실험을 통해 본 논문에서는 DPO 정책이 명시적 보상 함수로부터 학습된 모델과 비슷하게 일반화할 수 있음을 증명한다고 한다.

Validating GPT-4 judgments with human judgments

TLDR 요약 실험의 결과와 두 가지 다른 GPT-4 프롬트를 사용해서 GPT-4 판단 신뢰성을 검증하기 위한 인간 연구를 수행한다. GPT-4(S) 프롬트는 어떤 요약이 게시물의 중요한 정보를 더 잘 요약하는지 묻는다. GPT-4(C) 프롬트는 어떤 요약이 더 간결한지 묻는다. GPT-4가 GPT-4(S) 로 인간보다 더 길고 반복적인 요약을 선호한다는 것을 발견했다. 이를 통해 DPO, PPO, SFT를 평가하는데, GPT-4는 인간과 거의 동일하게 동의하는 것을 발견할 수 있었다. 또한, GPT-4(C) 프롬트도 인간의 결과를 더 잘 대표하는 것을 볼 수 있었다.

Discussion

본 논문은 강화학습 없이 선호도로부터 언어 모델을 훈련하기 위한 DPO를 도입했다. 기존의 강화학습 알고리즘을 사용하기 위해 선호 학습 문제를 표준 RL 설정으로 강제하는 대신, DPO는 언어 모델 정책과 보상 함수 간의 매핑을 식별해서 단순한 교차 엔트로피 손실로 인간 선호를 충족하는 언어 모델이다. 하이퍼파라미터를 튜닝하지 않고도 DPO는 기존의 RLHF 알고리즘, PPO 기반 알고리즘과 비슷하거나 더 나은 성능을 발휘한다. 이를 통해서 인간 선호로 더 많은 언어 모델을 훈련하는데 있어 본 논문은 유의미한 결과를 보여준다.

DecodingTrust: A Comprehensive Assessment of Trustworthiness in GPT Models 논문 리뷰

Hyeon Lee — Mon, 20 May 2024 11:29:50 +0900

[2306.11698] DecodingTrust: A Comprehensive Assessment of Trustworthiness in GPT Models (arxiv.org)

DecodingTrust: A Comprehensive Assessment of Trustworthiness in GPT Models

Generative Pre-trained Transformer (GPT) models have exhibited exciting progress in their capabilities, capturing the interest of practitioners and the public alike. Yet, while the literature on the trustworthiness of GPT models remains limited, practition

arxiv.org

해당 논문의 내용이 전반적으로 과하게 길다보니, 전체적인 틀을 파악하는 수준에서 논문을 살펴보려고 한다.

Abstract

본 논문은 GPT-3.5와 GPT-4를 중심으로 다양한 관점에서 LLM모델에 대한 신뢰성 평가를 제안한다. 여기에서 평가하고자 하는 관점들에는 toxicity, stereotype bias, adversarial robustness, out-of-distribution robustness, robustness on adversarial demonstrations, privacy, machine ethics, and fairness의 종류가 있다. 이러한 평가를 바탕으로 본 논문에서는 이전에 공개되지 않은 신뢰성 위협에 대한 취약성을 발견할 수 있었다.

본 논문에서 제시한 취약성은 GPT 모델이 독성과 편향된 출력을 생성하도록 쉽게 오도될 수 있다는 것과 훈련 데이터 및 대화 기록에서 개인 정보를 누출할 수 있다는 것이다. 또한, GPT-4가 일반적인 표준 벤치마크에서 GPT-3.5보다 더 신뢰할 수 있지만, 시스템이나 사용자 프롬프트가 Jailbreak 될 경우 GPT-4가 오히려 더 취약하다는 것을 발견했다.

Introduction

LLM의 새로운 능력은 신뢰성 문제를 악화시킬 수 있다. 특히 대화에 최적화됨에 따라, GPT-3.5와 GPT-4는 지침을 따르는 능력이 향상되다보니 오히려 이러한 능력이 새로운 신뢰성 문제를 초래할 수 있게 된다. 대화 맥락이나 시스템 지침을 악용해서 적대적 공격을 실행하여, 배포된 시스템의 신뢰성을 저하시킬 수 있는 것이다. 기존 벤치마크와 GPT 모델의 새로운 능력 격차를 해소하기 위해서, 본 논문은 다양한 적대적 시스템과 사용자 프롬프트를 설계하고 다양한 환경에서 모델 성능 평가 및 다양한 시나리오에서 LLM의 잠재적 취약점을 탐색한다.

Trustworthiness perspectives of language models.

1. Toxicity

1) 기존 LLM과 비교하여 GPT-3.5, GPT-4의 특성과 한계를 측정하는 표준 벤치마크 REALTOXICITYPROMPTS 평가

2) 시스템 프롬프트가 GPT 모델의 응답 독성 수준에 미치는 영향을 평가하기 위해 수동으로 설계한 33개의 다양한 시스템 프롬프트 평가

3) 기존 벤치마크보다 모델 독성을 더 효과적으로 드러내기 위해 GPT-4와 GPT-3.5가 생성한 1.2K 사용자 프롬프트 평가

2. Stereotype Bias

고정관념이 있는 문장을 생성하고, 모델이 동의하거나 반대하도록 요청하는 프롬프트를 생성.

평균적으로는 고정관념 문장에 동의하는 모델의 비율이 편향의 정도를 나타냄.

3. Adversarial Robustness

1) 기존 텍스트 적대적 공격에 대한 GPT 모델의 취약성 평가

2) 다양한 과제 설명과 시스템 프롬프트를 고려한 견고성 평가

3) 강력한 적대적 공격 하에서 GPT-3.5와 GPT-4의 취약성을 평가하기 위한 도전적 적대적 텍스트 평가

4. Out-of-Distribution Robustness

1) 다양한 스타일 변환 입력에 대한 모델 견고성 평가

2) GPT 모델 지식 범위를 벗어난 최근 사건 관련 질문에 대한 모델 신뢰성 평가

3) 다양한 스타일 및 도메인 시연을 통해 모델 성능에 미치는 영향을 평가하기 위한 분포 밖의 시연을 추가로 평가

5. Robustness to Adversarial Demonstrations

1) 반사례 예제를 시연으로 제공해서 평가

2) 시연 내 잘못된 상관관계 평가

3) 백도어 시연 추가 평가

6. Privacy

1) 사전 훈련 데이터에서 민감한 정보 추출 정확도 평가

2) 추론 단계에서 도입된 다양한 유형의 개인 식별 정보 추출 정확도 평가

3) 다양한 프라이버시 관련 단어와 사건을 포함한 대화에서의 정보 누출 평가

7. Machine Ethics

1) ETHICS와 Jiminy Cricket 평가

2) Jailbreak 프롬프트 평가

3) 회피 문장 평가

4) 다양한 속성을 포함하는 조건부 행동 평가

8. Fairness

1) zero-shot 설정에서 서로 다른 기본 비율을 가진 테스트 그룹 평가

2) 소수 학습 예제에서 인구통계학적으로 불균형한 맥락에 대한 모델 영향 평가

3) 인구통계학적으로 균형 잡힌 학습 예제의 수에 따른 공정성 평가

Empirical findings

1. Toxicity

- RLHF나 조정 없이 훈련된 LLM과 비교했을때, GPT-3.5와 GPT-4는 독성 생성을 크게 줄일 수 있으며, 다양한 작업 프롬프트에서 독성 확률이 32% 이하이다.

- GPT-3.5와 GPT-4 모두 정교하게 설계된 Jailbreak 프롬프트로 독성 콘텐츠를 생성할 수 있고, 독성 확률이 100%에 이른다.

- GPT-4는 Jailbreak 시스템 프롬프트의 지침을 더 잘 따르기 때문에 GPT-3.5보다 독성이 더 높다.

- GPT-3.5와 GPT-4를 활용해서 더 도전적인 독성 작업 프롬프트를 생성할 수 있고, 모델 독성을 평가하기 위한 LLM에 전이 가능하다.

2. Stereotype Bias

- GPT-3.5와 GPT-4는 고정관념 주제에 강하게 편향되지 않는다.

- 적대적 프롬프트가 제공되면 편향된 콘텐츠에 동의할 수 있고, GPT-4는 GPT-3.5보다 더 취약하다.

- 모델 편향은 사용자 프롬프트에 언급된 인구 통계 그룹에 따라 달라진다.

- 모델 편향은 고정관념 주제에 따라 달라진다. 덜 민감한 주제에서 더 편향된 콘텐츠가 생성되는 경향이 있다.

3. Adversarial Robustness

- GPT-4는 표준 AdvGLUE 벤치마크에서 GPT-3.5를 능가하고 더 높은 견고성을 보인다.

- GPT-4는 GPT-3.5보다 사람에 의해 작성된 적대적 텍스트에 대해 저항력이 높다.

- AdvGLUE 벤치마크에서, 문장 수준의 교란이 단어 수준의 교란보다 더 전이 가능성이 높다.

- GPT 모델은 표준 벤치마크에서 강력한 성능을 보이지만, 자가 회귀 모델을 기반으로 생성된 적대적 공격에 취약하다.

4. Out-of-Distribution Robustness

- GPT-4는 다양한 OOD 스타일 변환 입력에 대해 GPT-3.5보다 일관되게 높은 일반화 능력을 보인다.

- GPT-4는 GPT 모델 지식 범위를 벗어난 최근 사건 질문에 대해 GPT-3.5 보다 더 높은 회복력을 보인다.

- GPT-4는 유사한 도메인의 OOD 시연이 주어질 때 일관되게 더 높은 일반화를 보인다.

- 다른 도메인의 OOD 시연이 주어질 때, GPT-4의 정확도는 대상 도메인에 가까운 도메인에 의해 긍정적으로 영향을 받고, 멀리 떨어진 도메인에 의해 부정적으로 영향을 받는다. GPT-3.5는 모든 시연 도메인에서 모델 정확도가 감소한다.

5. Robustness to Adversarial Demonstrations

- GPT-3.5와 GPT-4는 시연에 추가된 반사례 예제에 의해 오도되지 않으며, 일반적으로 반사례 시연에서 혜택이 있다.

- 시연의 다양한 오류 있는 휴리스틱에서 구성된 잘못된 상관관계는 모델 예측에 다양한 영향을 미친다. GPT-3.5가 GPT-4보다 잘못된 상관관계에 의해 더 쉽게 오도된다.

- 백도어 시연을 제공하면 GPT-3.5와 GPT-4 모두 백도어 입력에 대해 잘못된 예측을 하게 된다. GPT-4가 백도어 시연에 더 취약하다.

6. Privacy

- GPT 모델은 훈련 데이터에서 민감한 정보를 누출할 수 있다. 특히 이메일 컨텍스트에서 이메일 주소 노출이 가능하다.

- 대화 기록에서 주입된 개인 정보를 누출할 수 있다. GPT-4가 GPT-3.5보다 개인 식별 정ㅂ를 보호하는 데 더 견고하다.

- GPT 모델은 다양한 프라이버시 관련 단어나 사건을 이해하는 데 다른 능력을 보인다. 특정 프라이버시 관련 단어가 주어지면 GPT-4는 GPT-3.5보다 더 많은 정보를 누출한다.

7. Machine Ethics

- GPT-3.5와 GPT-4는 도덕적 인식에서 많은 샘플로 미세 조정된 비 GPT 모델과 경쟁할 수 있다.

- GPT-3.5와 GPT-4는 Jailbreak 프롬프트에 의해 오도될 수 있다. Jailbreak 프롬프트 조합은 오도 효과를 증가시킨다.

- GPT-3.5와 GPT-4는 회피 문장에 속을 수 있고, 이러한 행동을 도덕적으로 인식한다. GPT-4가 회피 문장에 더 취약하다.

- GPT-3.5와 GPT-4는 특정 속성을 가진 비도덕적 행동을 인식하는 데 다르게 작동한다.

8. Fairness

- GPT-4는 인구통계학적으로 균형 잡힌 테스트 데이터에서 GPT-3.5보다 정확하지만, 불균형 테스트 데이터에서 더 높은 불공정성 점수를 기록하고 정확성과 공정성 간의 상충 관계를 나타낸다.

- zero-shot 설정에서, 두 모델은 기본 비율이 다른 테스트 그룹 간에 큰 성능 격차를 보인다.

- 학습 맥락 불균형은 모델의 예측 공정성에 영향을 미친다.

- 공정성 있는 학습 맥락을 제공하면, GPT 모델의 예측 고엉성이 개선된다. 소수의 균형 잡힌 학습 예제도 효과적이다.

본 논문은 다양한 신뢰성 관점에서 GPT 모델을 평가함으로써, GPT의 강점, 한계, 개선 가능성을 이해하고자 한다. 본 논문의 목표는 사용자 요구를 충족하면서 신뢰성 기준을 준수하면 더 신뢰할 수 있고, 편향이 없는 투명한 언어 모델 개발을 촉진하는 것이다.

Preliminaries

Introduction to GPT-3.5 and GPT-4

모델 : GPT-3.5와 GPT-4는 사전 학습된 자가 회귀 변환기이다. 이 모델들은 왼쪽에서 오른쪽으로 한 번에 한 토큰씩 텍스트를 생성하고, 이전에 생성된 토큰을 이후 예측의 입력으로 사용한다. GPT-3.5는 모델 파라미터 수로 1750억 개를 유지한다. GPT-4의 파라미터 수와 사전 학습 코퍼스에 대한 구체적인 사항은 공개되지 않았다.

훈련 : GPT-3.5와 GPT-4는 다음 토큰의 확률을 최대화하기 위해 표준 자가 회귀 사전 학습 손실을 따른다. GPT-3.5와 GPT-4는 RLHF를 활용해서 지침을 따르고, 인간 가치에 맞는 출력을 보장한다.

프롬프트 : 이 형식은 시스템 역할과 사용자 역할을 구분하는 새로운 역할 기반 시스템이다. 모델의 톤, 역할, 스타일을 구성하여 다양한 사용자 선호도와 사용 사례에 맞게 상호 작용 패턴을 사용자 정의한다.

사용법 : OpenAI API 쿼리 시스템을 통해 이루어진다. API 요청을 통해 특정 매개변수를 설정하여 생성된 출력에 영향을 줄 수 있다. 모델들이 동적이고, 시간이 지남에 따라 계속 발전한다.

Prompt design for downstream tasks

Prompts for text classification

제로샷 분류와 퓨샷 분류 모두를 고려한다. 제로샷 분류에서는 테스트 입력을 제공하기 전에 모델에 작업 설명을 제공한다. GPT-3.5가 시스템 메시지에 강하게 주의를 기울이지 않는다는 우려로 인해, OpenAI 코드북 가이드를 따르며 기본 시스템 프롬프트 "You are a helpful assistant"를 사용하고 작업 설명을 사용자 프롬프트에 배치한다.

이 이미지는 감정 분석 작업에 대한 제로샷과 퓨샷 분류의 예시이다.

퓨샷 분류 설정에서는 작업 설명과 함께 모델에 여러 시연을 제공하고, 예측을 생성한다. Incontext learning으로도 알려져 있고, 이 시연은 시뮬레이션 된 사용자 입력으로 형식화된 텍스트 입력과 시뮬레이션 된 모델 응답으로 형식화된 레이블로 구성된다. 이 방식을 통해서 모델은 시연을 조건으로 예측을 생성할 수 있다.

제로샷 분류와 퓨샷 분류 모두에서, 때때로 모델에 hallucination이 생기는 경우가 있다는 점에 주의를 기울여야 한다.

Prompts for text generation

본 논문의 실험에서는 잠재적 독성과 편향 평가를 위한 작업 생성 및 완료 작업을 고려한다. 위 이미지를 보면 텍스트가 완료 된 것을 볼 수 있고, 분류 설정과 일치하게 "You are a helpful assistant"라는 프롬프트를 통해서 LLM 어시스턴트의 역할을 설정한다. 사용자 프롬프트 내에서 LLM이 주어진 입력 프롬프트에 대해 일관된 생성을 하도록 작업 설명을 포함시켜야 하고, 최대 150개의 토큰을 생성하고, temperature를 1로 설정, top-p도 1로 설정한다.

이제 다음 섹션에서 다양한 평가를 제공하는데, 이 부분 부터는 단순 평가 내용이기 때문에, 추후에 다시 리뷰하고 내용을 추가하고자 한다.

Scaling Data-Constrained Language Models 논문 리뷰

Hyeon Lee — Sat, 11 May 2024 15:12:57 +0900

[2305.16264] Scaling Data-Constrained Language Models (arxiv.org)

Scaling Data-Constrained Language Models

The current trend of scaling language models involves increasing both parameter count and training dataset size. Extrapolating this trend suggests that training dataset size may soon be limited by the amount of text data available on the internet. Motivate

arxiv.org

Abstract

Language Model을 스케일링하는 추세는 매개변수 수와 훈련 데이터셋 크기를 증가시키는 것이다. 이 추세로 보면 훈련 데이터셋 크기가 인터넷에 사용 가능한 텍스트 데이터 양에 제한될 수 있다. 이런 동기를 통해 본 논문에서는 데이터 반복과 계산 예산의 정도를 다양하게 해서 대규모 실험 세트를 수행한다. 전체적인 실험을 보면, 고정된 계산 예산으로 제한된 데이터를 사용해서 훈련할 때 최대 4 epoch 반복 데이터는 loss에 미미한 변화를 보이지만, 반복이 더 많아질수록 추가 계산의 가치가 점점 감소하게 되면서 결국 제로가 되게 된다. 본 논문에서는 반복된 토큰과 과도한 매개변수의 가치 감소를 고려한 계산 최적성 스케일링 법칙을 제안한다.

Introduction

본 논문의 Introduction에서는 계산 최적화 언어 모델에서 같은 계산 예산으로 더 작은 모델을 더 많은 데이터로 훈련시킬 때 더 좋은 성능을 달성할 수 있다는 것을 말하면서 시작하고 있다. 하지만, LLMs는 이미 데이터 제약을 받고 있고, Chinchilla 스케일링 법칙과 점점 더 큰 모델을 훈련하는 추세를 고려할 때, 고품질 데이터가 모두 고갈될 것으로 예상된다. 본 논문은 "그렇다면, 데이터가 부족할 때 우리는 무엇을 해야할까?" 라는 근본적인 질문을 제기한다.

본 논문에서는 데이터 제약 환경에서 대규모 언어 모델의 스케일링을 조사하고, LLM의 여러 에폭에 걸쳐 반복 데이터로 훈련하는 것이 스케일링에 미치는 영향을 고찰한다. 이 연구를 통해 본 논문은 LLM 훈련에 있어서 여러 에폭의 영향을 정량화하여 실무자들이 모델을 스케일링할 때 계산을 어떻게 할당할지 결정할 수 있도록 하는 것이 주된 초점이다.

이 그림을 보면, 단일 에폭에서 훈련된 모델이 일관되게 최고의 검증 손실을 보이지만, 최대 4 epoch까지 훈련된 모델 간에는 차이가 거의 없어서 하위 작업 성능에도 차이가 나지 않는 것을 볼 수 있다. 추가 에폭은 유익하지만, 결국 return은 제로로 감소하게 된다. 데이터 제약 체제에서는 매개변수와 에폭을 모두 더 많이 할당하는 것이 필요하고, 에폭을 약간 더 빠르게 스케일링할 필요가 있다.

본 논문에서는 마지막으로, 데이터 제약 체제에서는 하위 정확도를 개선하기 위해 새로운 자연어 데이터를 추가하지 않고 반복 외에도 코드 토큰을 추가하고 데이터 필터링을 완화하는 접근법을 고려한다. 필터링의 경우에는 노이즈가 많은 데이터셋과 깨끗한 데이터셋 모두에서 난해성 및 중복 제거 필터링 전략을 검토하고, 데이터 필터링이 주로 노이즈가 많은 데이터셋에 효과적이라는 것을 발견했다.

Background

대규모 모델의 스케일링에서는 (Allocation) 자원의 최적 균형은 무엇인가? (return) 추가 자원의 기대 가치는 얼마인가? 이 두 가지 질문이 주된 관심사이다. LLMs를 스케일링할 때, 자원은 FLOPs compute이며, 더 큰 모델을 훈련하거나 더 많은 단계로 훈련하는 데 할당될 수 있다.

우리의 주된 목표는 N과 D에 대한 최적의 할당을 통해 Loss(L)을 최소화하는 것이다.

return은 멱법칙을 따르며, 훈련에 사용된 계산의 양에 따라 Loss가 멱법칙으로 스케일된다.

Allocation은 균형을 이루며, 자원이 매개변수 스케일링과 데이터 사이에 대략적으로 균등 분배된다.

Chinchilla는 스케일링 예측을 만들기 위해 세 가지 방법을 사용한다고 한다.

1. (Fixed Parameters) 고정된 모델 크기로 다양한 양의 데이터에서 훈련한다.

2. (Fixed FLOPs) 매개변수와 훈련 토큰이 변하는 동안 고정된 계산으로 훈련한다.

3. (Parametric Fit) 손실에 대한 공식을 도출하고 적합시킨다.

Parametric Fit을 위해 Loss(L)은 매개변수(N)과 훈련 토큰(D)의 함수로 표현된다.

이 학습 변수들을 사용해서 계산(C)를 N과 D에 최적으로 할당하는 방법을 제안한다.

이 방법에서 alpha = beta 이므로 N과 D는 계산 최적 훈련을 위해 비례적으로 스케일링되어야 한다.

Method: Data-Constrained Scaling Laws

본 논문의 해당 연구에서의 목표는 수정된 L(N, D)식을 도입하고 대규모 실험 데이터에 적합시키는 것이다.

고려하는 주요 방법은 데이터를 반복하는 것이다. 같은 데이터에 여러 epochs 동안 FLOPs를 할당한다. 고유 데이터 예산 DC가 주어지면, Chinchilla의 총 데이터 항 D를 UD(사용된 고유 토큰의 수), RD(반복횟수) 두 부분으로 나눈다. 총 훈련 토큰 D와 데이터 예산 DC가 주어졌을 때, 와 =( / )−1

해당 식으로 최적화 할 수 있다.

그 후 매개변수 항 N을 UN(UD에 최적으로 맞는 기본 매개변수 수), RN(초기 할당을 반복하는 횟수) 대칭적으로 두 부분으로 나눈다. 그 후 N_opt 공식에 고유 토큰 사용에 대한 최적 계산 예산을 찾아 입력하고 UN 값을 도출한다.

UN = min{N_opt, N}으로 구할 수 있다. UN을 얻은 후 RN = (N/UN) - 1로 반복 값을 계산한다.

이 작업에서 세 가지 다른 실험 프로토콜을 고려하게 된다.

1. (Fixed Parameters) 데이터 제약 DC를 고정하고 에폭과 매개변수를 변화시키면서 모델을 훈련한다. D와 N의 trade-off를 목표로 하는 allocation을 다룬다.

2. (Fixed FLOPs) 사용 가능한 계산을 고정하고 DC를 변화시킨다. 반복이 더 많은 고유 데이터를 가질 때와 비교해서 얼마나 잘 스케일되는지를 목표로 하는 return을 다룬다.

3. (Parametric Fit) 소개된 공식을 훈련 실행에 fitting 시키고, 예측 능력을 평가한다.

3.1 Parametric Fit

Experimental Setup

GPT-2 아키텍처와 토크나이저를 사용해서 트랜스포머 언어 모델을 훈련한다. 모델은 최대 87억 개 파라미터를 가지고 있으며, 최대 9000억 개의 총 토큰에 대해 훈련된다. 코사인 학습률을 사용하고 각 모델의 훈련 과정에서 10배 감소한다. 과적합 정도 탐구를 위해 조기 중단을 하지 않는다. 데이터 제약은 최대한 겹치도록 정의되었다. 전체 사용 가능한 데이터를 항상 반복하고, 각 epoch 후에 데이터를 섞는다. 반복 데이터로 인해 극단적인 과적합이 발생할 수 있어서, 훈련 Loss가 아닌 보류 중인 테스트 세트에서 Loss를 보고한다.

Results: Resource Allocation for Data-Constrained Scaling

모든 모델이 동일한 데이터 제약을 가진 상태에서 스케일링을 고려한다. 실험에서 고유 훈련 데이터 예산인 DC를 고정하고, 동일한 데이터 예산에서 점점 더 많은 계산을 할당받는 언어 모델을 훈련한다.

왼쪽 이미지를 먼저 보면, 100M 고유 토큰으로 스케일링하는 결과이다. 결과는 수십 개 epoch(RD > 0)과 모델 크기를 100M 토큰에 대해 계산 최적보다 20~60배 더 늘려서 훈련함으로써 50% 이상의 Loss를 줄일 수 있음을 보여준다. 이 결과를 통해서 단일 에폭 모델이 훈련 데이터를 상당히 활용하지 못하고 데이터와 매개변수를 추가함으로써 더 많은 신호를 추출할 수 있음을 보여준다.

오른쪽 이미지는 데이터 제약 스케일링 법칙에 따라 182개의 훈련 실행에 적합한 예측 윤곽을 보여준다. 단일 에폭(RD = 0)과 계산 최적 매개변수(RN = 0)의 경우, 공식들이 동일한 계산을 매개변수와 데이터에 할당하는 최적의 배분을 예측해서 효율적인 프론티어가 겹치게 된다. 데이터가 단일 에폭 이상으로 반복되는 경우에 fitting이 과잉 매개변수가 반복된 데이터보다 가치가 더 빨리 감소한다고 예측하게 된다. 결과적으로 데이터 제약 효율적 프론티어는 추가 계산을 더 많은 에폭보다는 매개변수에 할당하는 것을 제안하게 된다.

3 가지 데이터 예산 모두에서 이 결과는 epoch을 추가 매개변수보다 더 빠르게 스케일링함으로써 Allocation을 최적화하는 것을 제안하게 한다. 매개변수와 에폭을 추가하게 되면, Loss가 감소하다가 다시 증가하게 되는데, 이는 너무 많은 계산이 성능을 오히려 해칠 수 있음을 시사한다. 그렇지만, 적절한 정규화가 이러한 상태를 방지할 수 있을 것으로 본 논문은 기대하고 있다.

Results: Resource Return for Data-Constrained Scaling

이미지를 보면, 동일한 총 토큰 수에 대해 훈련된 모델의 구성과 검증 곡선을 볼 수 있다. 반복된 데이터는 가치가 덜 하기 때문에, 고유 데이터가 적은 모델(에폭이 더 많은 모델)은 일관되게 높은 Loss를 보인다. 87억 매개변수 모델이 4 epoches 동안 훈련된 경우(DC = 44억 고유 토큰), 단일 에폭 모델(DC = 178억 고유토큰)에 비해 검증 손실이 단지 0.5% 높게 나타난다.

왼쪽 이미지를 먼저보면, 각 모델의 최종 테스트 Loss를 Parametric fit과 비교한다. 데이터 제약 스케일링 법칙은 반복된 데이터의 가치 감소를 정확하게 측정할 수 있음을 볼 수 있다. 하지만, 훈련 중반에 Loss가 증가하는 실패 모델의 최종 테스트 손실을 과소평가하는 경향이 있다.

오른쪽 이미지를 살펴보면, 3가지 예산을 추가로 확장해서 DC를 55B, 84B, 178B 토큰으로 유지하면서 계산을 더 확장한다. 데이터 제약 스케일링 법칙에서 RD*이 에폭의 반감기를 나타낸다. 반복된 토큰이 1/e 만큼을 잃은 지점이고, RD*이 대략 15에 해당하며, 16 epochs에 해당한다. 그래프에서는 16 epoch 근처에서 cost 감소와 수익의 평탄화를 볼 수 있다.

반복데이터를 사용해서 약 16 epoch 까지는 의미 있는 이득을 얻을 수 있으며, 그 이후에는 수익이 극도로 빠르게 감소한다.

Results: Complementary Strategies for Obtaining Additional Data

데이터를 반복하는 것이 효과적이지만, 이 방법에도 한계점이 존재한다고 한다. 그래서 본 논문은 데이터 D를 확장하는데 있어서 개선된 하류 전략을 고려한다.

이미지의 왼쪽을 보면, 대안적인 데이터 사용 전략인 code augmentation과 Adapting filtering을 보여준다.

(a) code augmentation : stack에서 누락된 자연어 데이터를 보완하며, 코드와 자연어 샘플로 구성된 결합 데이터셋은 랜덤으로 섞인다.

(b) Adaping filtering : 중복 제거, 난해성 필터링의 일반적인 필터링 단계 성능 영향을 조사하므로써, 필터링 단계를 제거하면 추가적인 훈련 데이터를 확보할 수 있다.

반복 및 코드 채우기의 경우 DC의 일부만 사용 가능하고 나머지는 반복 or 코드 추가를 통해 보상해야 한다.

필터링의 경우 더 많은 178억 토큰으로 시작하여 노이즈가 많은 데이터를 수집하고 필터링하는 것이 더 쉽다.

난해성 필터링은 낮은 난해성을 가진 상위 25% 샘플을 선택한다.

이렇게 총 44억 토큰으로 전체 데이터 예산에 도달하기 위해 2 epoch에 가까운 반복을 사용한다.

이미지의 오른쪽을 보면, 모든 전략의 하류 성능을 비교한다. 데이터를 반복하는 경우 4 epoch까지 하류 성능 차이는 무의미하며 그 이후로 감소하기 시작한다. 데이터 50%를 코드로 채우면 자연어 작업에서의 성능 저하도 보이지 않는다. 그 이상에서는 성능이 급격히 감소한다. 추가 코드 데이터는 벤치마킹에서 고려되지 않은 비자연어 작업에 도움이 될 수 있다.

필터링 접근 방식 중에는 난해성 필터링이 효과적인 반면 중복 제거는 도움이 되지 않는다고 한다. 데이터 제약 상황에서는 노이즈가 많은 데이터셋에 필터링을 예약하고 code augmentation과 반복을 사용해서 데이터 토큰을 늘리는 것이 좋다.

Conclusion

데이터 제약 조건 하에서의 스케일링을 다루며, 고유 데이터가 제한된 경우 계산 자원을 최적으로 사용하는 방법에 초점을 맞춘 연구이다. 본 논문은 반복된 데이터의 가치 감소를 고려한 Chinchilla 스케일링 법칙의 확장을 제안하고, 제어된 실험 세트를 사용하여 기능을 적합시켰다.

논문을 통해 데이터를 반복하여 대규모 언어 모델을 여러 에폭 동안 훈련시키는 것이 유익하다는 것과 스케일링 법칙이 여러 epoch 체제에서도 지속됨을 알 수 있다.

논문을 리딩하기 전 스케일링의 컨셉이 잘 이해가 되지 않았다. 데이터 제약이 빅데이터 시기에도 일어날 수 있는 것인가를 초반에는 생각해보았지만, LLM이 얼마나 많은 데이터를 벌써 받아들였기에 데이터 제약 상황을 벌써 우리가 고민해야 하는지 다시 생각해볼 수 있는 논문이었다고 생각한다. 그리고 데이터의 반복에도 최적점이 있다는 것에 놀라웠다.

QLoRA: Efficient Finetuning of Quantized LLMs 논문 리뷰

Hyeon Lee — Sat, 4 May 2024 17:03:59 +0900

[2305.14314] QLoRA: Efficient Finetuning of Quantized LLMs (arxiv.org)

QLoRA: Efficient Finetuning of Quantized LLMs

We present QLoRA, an efficient finetuning approach that reduces memory usage enough to finetune a 65B parameter model on a single 48GB GPU while preserving full 16-bit finetuning task performance. QLoRA backpropagates gradients through a frozen, 4-bit quan

arxiv.org

Abstract

QLoRA

- 65B parameter 모델을 단일 48GB GPU에서 튜닝할 수 있을 정도로 메모리 사용량을 줄이면서 전체 16비트 튜닝 작업 성능을 유지하는 효율적인 튜닝 접근 방식

- 4비트 양자화된 pre-trained LM을 통해서 Gradient를 역전파시켜 LoRA로 이끌어준다. 본 논문에서 제시한 QLoRA를 통해서 단일 GPU에서 24시간 튜닝만으로 ChatGPT 성능 수준에 근접할 수 있는 것을 확인했으며, 성능을 희생하지 않으면서 메모리를 절약할 수 있게 되었다.

(a) 정규 분포 가중치에 대한 정보 이론적으로 최적인 새로운 데이터 유형인 4비트 NF4

(b) 양자화 상수를 양자화하여 평균 메모리 발자국을 줄이는 Double Quatization

Introduction

LLMs 튜닝은 성능을 향상시키고 원하는 행동을 추가하거나 원하지 않는 행동을 제거하는 것에 매우 효과적인 방법으로 이미 많이 알려져 있다. 하지만, 이렇게 큰 모델을 튜닝하는 것에는 비용이 많이 따른다는 단점이 존재한다. 양자화 자체만으로 LLM의 메모리 사용량을 줄일 수는 있지만, 이러한 기술은 추론에만 유효하고 훈련 중에 붕괴될 수 있다. 이러한 배경에 착안하여 본 논문에서 소개하고 있는 QLoRA는 사전 훈련된 모델을 4비트로 양자화한 다음, 소량의 학습가능한 Low rank Adapter 가중치를 추가하여 튜닝한다. 이 가중치들이 양자화된 가중치를 통해서 Gradient를 역전파하여 조정하게 된다.

본 논문의 QLoRA는 크게 3가지의 방법론을 도입하고 있다.

(1) 4비트 NF4, 정규 분포 데이터에 대한 정보 이론적으로 최적인 양자화 데이터 유형

(2) Double Quantization : 양자화 상수를 양자화하여 평균 메모리 발자국을 줄이는 방법

(3) Paged Optimizers : Gradient 체크포인트 메모리 스파이크를 피하는 방법

이러한 3가지의 Contribution을 통합하여 LoRA 접근 방식을 더욱 잘 조정하였고, 이를 통해 거의 모든 정확도 손실을 피하면서 모든 네트워크 계층에 어댑터를 추가하게 된다.

본 논문에서는 QLoRA 튜닝을 통해서 훈련된 모델의 경향을 분석했을 때, 두 가지의 중요 사실을 발견했다.

1. 데이터 품질이 데이터셋 크기보다 훨씬 중요하다는 것을 발견

2. MMLU 벤치마크에서의 강력한 성능이 Vicuna 챗봇 벤치마크 성능을 의미하지 않는다 -> 데이터 적합성이 크기보다 중요

Fine-tuning vs LoRA vs QLoRA

Background

1. Block-wise k-bit Quantization

- Quantization : 입력을 더 많은 정보를 가진 표현에서 더 적은 정보를 가진 표현으로 이산화하는 과정. 더 많은 비트를 가진 데이터 유형을 더 적은 비트로 변환하는 것을 의미.

- 32비트 부동 소수점 텐서를 범위 [-127, 127]의 Int8 텐서로 양자화하는 경우

양자화

역양자화

- 문제점 : 이상치 발생 시 양자화된 값들이 일부 비트 조합인 양자화 빈에 잘 할당되지 않아서 일부 빈에는 숫자가 거의 또는 전혀 양자화되지 않을 수 있음.

- 해결책 : 입력 텐서를 독립적으로 양자화되는 각각의 양자화 상수 c를 가진 블록으로 분할

2. Low-Rank Adapters

- 훈련 중 메모리 요구 사항을 줄이기 위해 어댑터라고 불리는 소량의 훈련 가능한 매개변수를 사용하는 방법

- 확률적 그래디언트 하강 중에는 고정된 사전 훈련 모델 가중치를 통해 어댑터로 전달되는 그래디언트가 업데이트를 최적화시킴.

3. Memory Requirement of Parameter-Efficient Finetuning

- QLoRA의 4비트 기본 모델은 5048MB의 메모리를 소비하여 그래디언트 체크포인팅이 중요하지만 LoRA 매개변수의 양을 줄이면 소량의 메모리 이점만을 얻을 수 있음.

- 전체 튜닝 메모리 발자국을 증가시키지 않고 더 많은 어댑터를 사용할 수 있다.

QLoRA Finetuning

1. 4비트 NormalFloat 양자화

- NF 데이터 유형은 입력 텐서의 경험적 누적 분포 함수를 통해 추정되는 입략 텐서의 분위수를 기반으로 하는 Qunatile 양자화에 기초한다.

- 분위수 추정 과정에 많은 비용이 들기 때문에 SRAM 분위수와 같은 빠른 분위수 근사 알고리즘을 사용한다. -> 이상치에 대해 큰 양자화 오류가 발생할 수 있음.

- 사전 훈련된 신경망 가중치가 표준편차를 가진 제로 중심 정규 분포를 가지고 있으므로 표준 편차를 조정해서 분포가 데이터 유형 범위에 맞도록 모든 가중치를 단일 고정 분포로 정규화한다.

- 제로-평균 정규 분포에 최적인 데이터 유형은 표준편차를 범위 [-1, 1]에서 계산한다.

1) N(0, 1) 분포의 2k + 1 분위수를 추정해서 정규분포용 k 비트 분위수 양자화 데이터 유형 획득

2) 데이터 유형 값들을 [-1, 1] 범위로 정규화

3) 입력 가중치 텐서를 절대 최대 재조정을 통해 [-1, 1] 범위로 정규화하여 양자화

3) 과정을 위해 qi 값은 아래와 같이 추정된다.

이제 0의 이산적인 제로포인트 보장과 k비트 데이터 유형에 대해 2k 비트를 모두 사용하기 위해서 qi의 두 범위 2k-1,

2k-1+1 을 위한 분위수 qi를 추정하고 두 세트의 qi를 통합한 다음 두 세트에서 발생하는 두 개의 0 중 하나를 제거한다. 이 과정에서 결과적인 데이터 유형을 k비트 NormalFloat 이라고 부른다.

2. Double Quantization

- 추가 메모리 절약을 위해 양자화 상수를 양자화하는 과정이다.

- 64의 블록크기의 경우 매개변수당 32/64 = 0.5 비트에서 8/64 + 32/(64-256) = 0.127 비트로 메모리 발자국을 줄이고, 0.373 비트를 감소시킨다.

3. Paged Optimizers

- CPU와 GPU 간에 페이지 단위 전송을 자동으로 수행해서 GPU 메모리가 부족하더라도 오류 없이 GPU 처리를 가능하게 한다.

- 옵티마이저 상태에 대한 페이징 메모리를 할당, GPU 메모리가 부족할 때 자동으로 CPU RAM으로 쫒겨나고 옵티마이저 업데이트 단계에서 필요할 때 GPU 메모리로 다시 페이징 된다.

QLoRA vs Standard Finetuning

Experiment setup

- 인코더, 인코더-디코더, 디코더 세 가지 아키텍처를 비교하여 QLoRA와 16비트 어댑터 파인튜닝 및 풀 파인튜닝을 비교

- GLUE에 대해 RoBERTa-large, Super-NaturalInstructions에 대해 T5, Flan v2에서 파인튜닝한 LLaMA와 Alpaca에서 5-shot MMLU 후의 평가를 포함.

- 다양한 모델 크기에 대해 언어 모델링 및 제로샷 작업에서 post quantization 정확도와 난해도를 측정

실험을 통해서 4비트 어댑터 파인튜닝이 16비트 풀 파인튜닝 및 16비트 LoRA 성능을 재현할 수 있음을 확인했다. LLaMA 7B 부터 65B까지 Alpaca와 FLAN v2에서 파인튜닝을 진행하고 MMLU 벤치마크를 통해 5-shot 정확도를 평가한다.

NF4가 16비트 LoRA MMLU 성능을 완전히 회복한다는 것을 보여주며, FP$가 16비트 brain float LoRA보다 1% 포인트 정도만 뒤쳐지는 것을 확인했다. 이러한 실험을 통해 본 논문에서는 QLoRA가 NF4를 사용할 때 16비트 풀 파인튜닝 및 16비트 LoRA 파인튜닝 성능을 재현할 수 있음과 NF4가 FP4보다 양자화 정밀도 면에서 우수하다는 결론을 내릴 수 있다고 말하고 있다.

Default LoRAhyperparameters donotmatch16 bit performance

해당 이미지는 LLaMA 7B 모델을 Alpaca 데이터셋에서 파인튜닝한 결과이다. 이를 통해 큰 기본 모델에 대한 풀 파인튜닝 성능을 재현할 수 없다는 것을 알 수 있다.

k-bit QLORA matches 16-bit full finetuning and 16-bit LoRA performance

본 논문에서는 페이징 최적화로 48GB GPU에서 65B 모델에 대한 페이징 최적화기의 런타임을 분석하고 배치 크기가 16일 때 일반 최적화기와 동일한 훈련 속도를 제공하는 것을 발견했다. 이러한 결과를 통해 4비트 QLoRA가 16비트 풀파인튜닝 및 16비트 LoRA 성능과 일치하고, 표준 4비트 Float 보다 4비트 NormalFloat의 성능이 우수하다는 것을 입증하게 된다.

RoBERTA와 T5 모델 크기에서 125M에서 3B 파라미터를 GLUE 및 Super-NaturalInstructions 데이터셋에서 16비트 풀 파인튜닝과 비교해보면, 16비트, 8비트, 4비트 어댑터 방법이 풀 파인튜닝된 16비트 성능을 재현하고 있다. 이를 통해 정밀하지 않은 양자화로 인한 손실된 성능이 양자화 후 어댑터 파인튜닝을 통해 완전히 회복 가능하다는 것을 알 수 있게 된다.

두번째는 4비트 QLoRA 7B에서 65B 파라미터 규모에서 16비트 LoRA와 일치하는지를 테스트 한다. LLaMA 7B부터 65B까지를 Alpaca와 FLAN v2 두 가지 지시 사항을 따르는 데이터셋에서 파인튜닝하고 MMLU 벤치마크에서 5-shot 정확도로 평가한다.

NF4와 Double Quantization을 사용한 경우 16비트 LoRA MMLU 성능을 완전히 회복하는 것을 볼 수 있다. 또한, FP4를 사용한 QLoRA가 16비트 brain float LoRA 기준보다 1% 포인트 뒤쳐진다는 것도 확인할 수 있었다. 결국 이는 NF4를 사용한 QLoRA가 16비트 풀 파인튜닝 및 16비트 LoRA 파인튜닝 성능을 모두 재현한다는 것, NF4가 양자화 정밀도 측면에서 FP4보다 우수하다는 근거가 된다.

실험들을 통해서 4비트 QLoRA의 NF4 데이터 유형이 16비트 풀 파인튜닝 및 16비트 LoRA 파인튜닝 성능과 일치한다는 것을 일관되게 보여주고 있으며, NF4가 DQ 성능을 저하시키지 않는다는 것도 보여주게 된다. 이를 통해 본 논문은 주어진 파인튜닝 및 추론 자원 예산을 가지고 기본 모델의 파라미터 수를 늘리면서 정밀도를 낮추는 것이 유익하며 효율적임을 강조한다.

Pushing the Chatbot State-of-the-art with QLoRA

MMLU 벤치마크에서 5-shot으로 실험, p=0.9, temperature=0.7

Benchmark Data

Automated Evaluation

Human Evaluation

Elo Rating

Guanaco: QLORA trained on OASST1 is a State-of-the-art Chatbot

가장 해당 주제를 잘 보여주는 표이다. Guanaco가 GPT-4 다음으로 우수한 성능을 기록하고 있는 것을 확인할 수 있다.

Elo Rating에서도 Guanaco가 좋은 성능을 보이고 있다는 것을 알 수 있다. ChatGPT-3.5 turbo와 비교했을 때는 Human raters의 경우 꽤 많은 차이가 나는 것이 확인된다.

Qualitative Analysis

Factual Recall

Gaunaco는 질문이 생소해질수록 신뢰성은 떨어지지만, 여전히 확신을 가지고 대답한다.

이 예시에서 Gaunaco는 잘못된 대중화자와 잘못된 생년월일을 생성했으나, 언급된 사람 AI Jolson의 생년월일은 맞습니다.

Suggestibility

Guanaco는 특정 중류의 가정된 잘못된 정보에 동조하는 것을 거부한다.

지구가 flat함을 확인시켜달라는 User의 요청에 아래와 같이 반응한다.

Guanaco는 어떤 질문들이 답변할 수 없는지도 정확히 알고 있다.

이 뿐만 아니라, "Where are you?", "How are you?" 와 같은 질문도 마찬가지로 답변한다.

Refusal

Guanaco는 때때로 follow instructions에 random한 이유로 refuse한다.

Secret Keeping

하지만 refusal은 원하는 경우에도 unreliable 하다. 시스템 설계자는 사용자에게 비밀을 유지하고 싶어도 시스템이 사용자에게 자유롭게 텍스트 응답을 제공하는 경우가 있다.

비밀 단어를 "banana"라고 설정해두고 어떤 경우에도 단어를 공개하거나 반복해서 말하지 말라고 지시해둔 상태에서 아래와 같이 지시를 해보자.

이는 정상적으로 작동한 모습이다. 그렇다면 이제 여기에 속임수를 가미해보자.

아래와 같이 비밀 유지가 안 되는 것을 볼 수 있다.

Math

Guanaco는 수학에 매우 약하다. 하지만, 전체적인 work를 보고 나면 정확성을 보이는 경향이 있다.

하지만, Guanaco는 step-by-step이 깨지면 간단한 문제에도 break 된다.

Theory of Mind

Gauanco는 매우 강한 Theory of Mind를 보여준다. 다음 질문에 대해 매우 자세하게 답변한 것을 보자.

그렇지만, 추론은 unreliable 하다. 그리고 모델이 상황에 맞지 않는 것들을 전제로 하는 이유를 제시한다.

또한, 결코 설명되지 않은 정보 전달을 전제로 하기도 한다.

Considerations

Evaluation

본 논문은 두개의 강력한 시스템을 비교할 때 추가적인 저하가 있음에도 불구하고 중간 정도의 일치만을 보고 한다. 이는 현재 챗봇 작업 성능에 대한 벤치마크와 인간 평가 프로토콜의 한계를 시사하고 있음을 밝히고 있다. 또한, 분석에서 자동 평가 시스템에 눈에 띄는 편향이 있음을 발견했다. GPT-4는 프롬프트에서 처음 나타나는 시스템에 더 높은 점수를 부여하는 강한 순서 효과를 관찰했다. GPT-4와 인간 주석자 간의 상대적으로 약한 샘플 수준 일치도 인간 주석자와 자동 시스템이 항상 일치하지 않는 선호를 의존할 수 있다고 말한다. 향후 연구를 자동 평가 시스템의 잠재적 편향의 존재와 가능한 완화 전략을 조사해야함을 밝힌다.

Limitations and Discussion

- 엄청난 자원 비용 때문에 QLoRA가 33B와 65B 규모에서 전체 16비트 미세 조정 성능에 부합함을 보이지 못했다.

- 지시 미세 조정 모델 평가 : BigBench, RAFT, HELM과 같은 벤치마크에서 평가하지 않아, 이러한 벤치마크에서도 일반화되는지 확신할 수 없다.

- 벤치마크 성능이 미세 조정 데이터가 벤치마크 데이터셋과 얼마나 유사한지에 따라 달라질 수 있다. 더 나은 벤치마크와 평가가 필요하며, 무엇을 평가하는지에 대해 주의 깊게 고려할 필요성이 있다.

- 일반 챗봇 성능에 대해 자세한 평가를 제공하지만, Guanaco에 대한 제한된 AI 평가만 수행하는 한계가 있다. Guanaco-65B가 다른 모델에 비해 편향된 토큰 시퀀스를 생성할 가능성을 평가했다.

이 시각자료를 보면, Guanaco-65B의 평균 점수가 다른 원시 사전 훈련 모델보다 훨씬 낮은 것을 볼 수 있다. 이를 통해 OASST1 데이터셋에서의 파인튜닝이 LLaMA 기본 모델의 편향을 줄이는 것으로 보인다. 하지만, 추가적인 편향 분석 작업이 필요하다.

- 다른 비트 정밀도에 대해 평가하지 않았다. LoRA 뿐 아니라, PEFT와 같은 방식이 대형 모델로 확장되는지 불확실하다. 다른 어댑터가 더 나은 성능을 제공할 수도 있고, 양자화 후 파인튜닝을 통해 양자화 중에 손실된 정보의 대부분을 회복하는 것으로 보이기 때문에 더 공격적인 양자화도 가능하다.

Broader Impact

QLoRA 파인튜닝 방법은 단일 소비자 GPU에서 33B parameter 모델을, 단일 전문 GPU에서 65B parameter 모델을 파인튜닝할 수 있는 방식으로 전체 파인튜닝 기준 대비 성능 저하가 없다. 파인튜닝은 LLM을 ChatGPT와 같은 챗봇으로 변환하는 필수 도구이기 때문에 자원이 적은 연구자들에게 널리 퍼지고 일반화되는데 큰 도움이 된다. 또한, QLoRA를 통해 전화기 및 기타 저자원 환경에서 LLM의 미세 조정을 가능하게 하는 중요한 방식이 될 것이라고 본다. 아이폰 12 플러스를 사용해서 QLoRA가 밤새 충전하는 동안 300만 토큰을 파인튜닝할 수 있을 것으로 추정된다. 파인튜닝된 7B 모델이 ChatGPT 급의 품질에 도달하지는 못하지만, 충분히 품질이 좋기 때문에 이전에 개인 정보나 LLM 품질 문제로 인해 불가능했던 새로운 응용 프로그램을 가능하게 할 것으로 생각된다. QLoRA를 통해 사용자가 자신의 데이터와 모델을 소유하고 관리할 수 있게 하여 LLM을 배치하기 쉽게 만들어 LLM의 개인 정보 보호 사용을 가능하게 해 줄 수 있다.

지금까지 QLoRA 논문에 대해서 리뷰를 진행해보았다. Quantization을 이용하여 LoRA 이후 더욱 많은 자원을 줄여줄 수 있는 획기적인 방식으로 이름이 나 있어서 이전 인턴동안 연구해본 주제였지만, 논문을 직접적으로 읽어보지는 않았었는데, 논문을 리뷰하면서 QLoRA에 대한 한계점과 중요성에 대해서 자세히 알 수 있어 좋은 시간이 되었다고 생각한다.

ToolkenGPT: Augmenting Frozen Language Models with Massive Tools via Tool Embeddings 논문 리뷰

Hyeon Lee — Sun, 28 Apr 2024 17:18:51 +0900

[2305.11554] ToolkenGPT: Augmenting Frozen Language Models with Massive Tools via Tool Embeddings (arxiv.org)

ToolkenGPT: Augmenting Frozen Language Models with Massive Tools via Tool Embeddings

Augmenting large language models (LLMs) with external tools has emerged as a promising approach to solving complex problems. However, traditional methods, which finetune LLMs with tool demonstration data, can be both costly and restricted to a predefined s

arxiv.org

Abstract

본 논문은 ToolkenGPT라고 하는 새로운 방식을 제시하고 있다. 각 도구를 toolken으로 표현하고 이를 학습해서 동일한 방식으로 도구 호출을 가능하게 한다. toolken 임베딩 학습을 위한 광범위한 데모 데이터를 허용함으로써 도구 사용을 개선한다. 수치적 추론, 지식 기반 질문 응답, 구현된 계획 생성과 같은 다양한 도메인에서 ToolkenGPT 접근법은 LLM에 도구를 효과적으로 통합하고 다양한 최신 기준들을 크게 능가한다고 설명하고 있다.

Introduction

LLM의 연구 접근법에는 두 가지 주요 패러다임이 있다. 첫번째는 특정 도구의 학습을 위한 LLM fine-tuning이다. 이 방식은 유망한 결과를 낼 수 있지만, 계산 비용이 많이 들고 새로운 도구 적응에 제한적이다. 두번째는 Incontext learning이다. 이 방식에서 LLM은 프롬프트에 제공된 Incontext 데모를 통해 도구 사용 방법을 학습한다. 이 방식은 Langchain과 chatGPT plugin과 같은 응용 프로그램을 이끌어냈다. 하지만, context 길이의 내재적 한계로 인해 새로운 도구를 몇 가지 예제를 통해서 마스터하는 것은 어려울 수 있다는 문제가 있다.

본 논문에서는 LLM fine-tuning 없이도 새로운 도구에 빠르게 적응할 수 있도록 하는 해결책으로 ToolkenGPT를 소개한다. ToolkenGPT는 파인튜닝과 인컨텍스트러닝의 강점을 결합하고 각 한계는 피한다. ToolkenGPT는 각 도구를 새로운 토큰(toolken)으로 표현하여 어휘를 확장하는 것이 핵심적인 아이디어이다. 각 도구가 일반 단어 토큰 임베딩처럼 LLM의 헤드에 삽입되고, 생성 중에 toolken이 예측되면 LLM이 도구를 실행하기 위해 인수를 생성하는 특별 모드로 전환된다. 이 방식을 사용하면 LLM이 해당 도구에 최적화될 수 있으며, toolken 임베딩만을 학습하게 됨으로써 효율적으로 작동할 수 있다.

ToolkenGPT와 Fine-tuning, In-context learning을 비교한 표인데, 각 한계를 피하고, 장점들을 확보한 것을 볼 수 있다.

복잡한 수치추론문제를 예시로 제공하고 있는데, 이 경우에 수학 도구를 이용하면서 CoT나 ReAct 기법의 성능을 크게 능가한다. 지식 기반 질문 응답의 경우에서도 ToolkenGPT가 200개 이상의 관계 API를 지식 기반으로 통합해서 사실적인 예측을 가능하게 한다.

ToolkenGPT for Mastering Massive Tools

ToolkenGPT 프레임워크를 본 논문에서는 복잡한 수식으로 제공하고 있지만, 시각자료로 이해하는 것이 가장 좋을 것 같다. 전체적인 개요는 위 그림과 같다.

Toolken 임베딩은 일반 단어 토큰처럼 언어 모델의 헤드에 추가되며, 문제를 해결하기 위한 Reasoning mode에서는 LLM이 평소와 같이 텍스트를 생성하지만, 추가된 toolken이 다음 토큰 생성을 위해 고려가 된다.

Toolken이 예측되면

1. LLM이 Tool mode로 전환되어 동일한 도구의 몇 가지 데모를 제공하고 인수를 완성한다.

2. 도구 호출이 실행된다.

3. 결과가 텍스트로 돌아와 Reasoning 모드에서 최종 답변을 생성시킨다.

Framework Overview

각 toolken은 toolken 임베딩 벡터로 매개변수화되며, toolken 임베딩 집합을 행렬로 표현한다. 훈련된 toolken 임베딩을 가지고 있다면, LLM은 기본적으로 추론 모드에서 다음 토큰을 생성한다.

LLM이 다음과 같은 확률로 다음 토큰을 예측한다. 다음 토큰은 단어 토큰 or toolken일 수 있다. 이전 방법들이 도구 학습을 완전히 incontext learning에 의존하는 것과 대조적으로 ToolkenGPT 프레임워크는 인수를 완성하는 작업만 incontext learning으로 처리한다. 이렇게 완성된 인수는 지정된 도구에 보내져서 실행되고, 반환 값은 추론 모드에서 텍스트로 보내지게 된다.

Learning Toolken Embeddings

프레임워크가 원래 LLM 매개변수를 그대로 유지하면서 toolken 임베딩과 관련된 최소한의 추가 훈련 오버헤드를 도입한다. 임베딩 행렬이 prompt tuning이나 prefix tuning 과는 달리, LLM 매개변수의 주요본체를 통해서 gradient가 흐르는 것을 요구하지 않아서 훨씬 안정적이고 효율적인 훈련이 가능하게 된다.

toolken 임베딩 튜닝과 LLM inference와 거의 동일한 GPU 메모리를 유지하고 있으며, 새로운 도구가 추가될 때마다 확장되게 된다. 또한, 대규모 데모에서 toolken 임베딩을 튜닝할 수 있다.

본 논문은 도구 데모와 함께 toolken 임베딩을 학습하는 데 초점을 맞춘다. 먼저 훈련 데이터의 형식과 훈련 목표를 설정한다. 예를 들어, "the area is 256 square feet ..."는 단어 토큰 시퀀스 s = (“the”, “area”, “is”, “2”, “5”, “6”, “square”, “feet”, ...)로 토큰화 될 수 있는 것이다. 여기서 toolken을 예측해야 할 때를 나타내기 위해서 단어 토큰과 toolken이 혼합된 병렬 시퀀스 s′ = (“the”, “area”, “is”, “[square]”, “[N/A]”, “[N/A]”, “square”, “feet”, ...)가 필요하게 되고, 여기서 ("2", "5", "6") 부분 시퀀스는 s에서 도구 결과가 채워져야 할 부분이 된다. s'에서 해당 도구 호출의 첫 번째 토큰을 toolken으로 선택하고, 다음 토큰들은 [N/A]로 채워져서 손실 계산에서 무시된다.

따라서 ToolkenGPT의 훈련 목표는 다음과 같은 식으로 표현이 가능하다. 도구 호출을 위해 LLM은 처음에 toolken을 예측하는 것 뿐이고, 그 후에는 도구 호출의 반환값이 텍스트에 다시 채워지게 된다.

Experiment

Numerical Reasoning

Knowledge-based Question Answering

Embodied Plan Generation

Grounding : 모든 행동과 객체가 환경에 구체화될 수 있는 스크립트의 비율

Executable : 어떠한 규칙도 위반하지 않고 VirtualHome에서 실행될 수 있는 스크립트의 비율

Success : 올바른 최종 상태로 이어지는 스크립트의 비율

Success(R) : 편안한 변형, 반드시 그 상태에서 끝나지는 않지만 올바른 최종 상태에 도달한 스크립트의 비율

ToolkenGPT는 자연스럽게 유효한 행동과 객체를 예측하고, 더 많은 훈련 과제에서 toolken 임베딩을 학습함으로써 가장 높은 성공률을 달성하게 된다.

모든 기준선이 [SIT] <desk>를 예측하더라도, VirtualHome에서 [SIT]은 "앉다"를 의미하며 책상은 앉을 수 없는 것으로 간주되는데, ToolkenGPT만 이 규칙을 성공적으로 학습하고 [SIT] <chair>를 예측한다.

Computational Cost

fine-tuning 된 LLM은 FuncQA 데이터셋에서 ToolkenGPT보다 약간 더 나은 성능을 보인다. LoRA도 fine-tuning에 필요한 시간 소모는 ToolkenGPT의 toolken 임베딩과 비교할 때 상당히 많은 편이다. ToolkenGPT는 각 도구에 대한 매개변수가 분리되어 있기 때문에, 다양한 도구를 plug and play 할 수 있는 이점이 있다.

Ablation study

Tool mode에서는 LLM에 선택된 도구만을 사용한 데모를 프롬프트해서 ReAct 프롬프트보다 인수 완성에 더 관련된 지식을 제공한다. Tool mode를 추가하면 인수완성의 정확도를 더 높일 수 있다. 하지만, ToolkenGPT를 이용하게 되면 인수 완성의 정확도를 더욱 크게 능가하게 된다. 이를 통해 toolken 임베딩이 LLM에 도구 호출 시기와 도구 선택을 효과적으로 돕는것을 알 수 있다.

Conclusion

본 논문에서 소개한 ToolkenGPT는 비싼 fine-tuning 없이 외부 도구로 고정된 LLM을 증강시키는 방식이다. 각 도구에 대한 toolken 임베딩을 도입해서 LLM이 단어 토큰을 생성하는 것처럼 다양한 도구를 호출하고 사용할 수 있게 한다. 이 방식을 통해서 fine-tuning과 incontext learning의 한계를 극복하여 LLM이 더 많은 도구 세트와 데모 데이터를 사용해서 toolken 임베딩을 학습할 수 있게 한다. 이를 통해서 수치적 추론, 지식 기반 QA, 실체화된 계획 생성과 같은 task에서 LLM의 성능을 높일 수 있게 된다.

본 논문을 리뷰하면서 LLM의 파인튜닝을 통한 작업들이 비싼 cost와 다양한 한계점이 존재하는 것을 인식하고 개선하는 방식들에 대한 최신 트렌드가 외부 도구들을 이용하는 방식이라는 것을 알 수 있었다. 지난번 리뷰했던 Toolformer와 유사하게 이 방식도 외부 도구들을 토큰화해서 LLM의 성능을 높이는 것이 핵심이었다. 최근 LLM의 트렌드가 어떤 것인지 도구를 이용하는 논문을 두 편 연속으로 리뷰하면서 몸소 제대로 느낄 수 있었다고 생각한다.

백준 14502 - 연구소

Hyeon Lee — Thu, 4 Apr 2024 11:26:39 +0900

14502번: 연구소 (acmicpc.net)

14502번: 연구소

인체에 치명적인 바이러스를 연구하던 연구소에서 바이러스가 유출되었다. 다행히 바이러스는 아직 퍼지지 않았고, 바이러스의 확산을 막기 위해서 연구소에 벽을 세우려고 한다. 연구소는 크

www.acmicpc.net

문제를 살펴보면, 0인 곳으로 2(바이러스)가 퍼져나가는 시스템이다.

그렇다면 bfs를 이용해서 경로를 찾아나가면서 0을 따라서 2(바이러스)로 변경시켜주면 좋겠다는 생각을 우선 하게 되었다.

일단 먼저 바이러스를 퍼트리는 bfs 함수를 구현해보자.

def bfs(temp):
    q = deque()
    for i in range(n):
        for j in range(m):
            if temp[i][j] == 2:
                q.append((i, j))
    
    while q:
        x, y = q.popleft()
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]
            
            if 0 <= nx < n and 0 <= ny < m:
                if temp[nx][ny] == 0:
                    temp[nx][ny] = 2
                    q.append((nx, ny))

bfs 함수를 일반적으로 구현하고, 0인 구역을 만나면 2를 담아주어서 바이러스를 퍼트리는 방식으로 구현할 수 있다.

이제 벽을 세워야하는데, 벽을 딱 3개만 세울 수 있으므로 combinations 함수를 사용해서 3개까지만 조합을 찾아준다. 이 시점에서 가장 중요한 것이 있는데 벽의 조합을 독립적으로 조절시켜주지 않으면 이전 조합을 그대로 들고 와서 graph가 변질될 수 있다. 때문에, deepcopy를 사용해서 graph를 temp라는 임시 그래프로 바꾸어주고, 3개의 조합을 찾아주는 방식을 택했다.

empty_spaces = [(i, j) for i in range(n) for j in range(m) if graph[i][j] == 0]

max_safe_area = 0
for walls in combinations(empty_spaces, 3):        # 새로 세울 수 있는 벽 3개 조합.
    temp = deepcopy(graph)                         # 조합을 독립적으로 조절하기 위해서 deepcopy 시켜줌.
    
    for x, y in walls:
        temp[x][y] = 1

이렇게 empty_space를 지정해주고 combinations 함수를 이용해서 3개의 벽 조합을 세워준다.

마지막으로 safe_area의 갯수를 출력하기 위해서 count_safe_area 함수를 만들어주었다.

def count_safe_area(temp):
    count = 0
    for i in range(n):
        for j in range(m):
            if temp[i][j] == 0:
                count += 1
    return count

<전체 코드>

import sys
input = sys.stdin.readline
from collections import deque
from itertools import combinations
from copy import deepcopy

n, m = map(int, input().split())
graph = [list(map(int, input().split())) for _ in range(n)]
dx = [1, -1, 0, 0]
dy = [0, 0, -1, 1]

def bfs(temp):
    q = deque()
    for i in range(n):
        for j in range(m):
            if temp[i][j] == 2:
                q.append((i, j))
    
    while q:
        x, y = q.popleft()
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]
            
            if 0 <= nx < n and 0 <= ny < m:
                if temp[nx][ny] == 0:
                    temp[nx][ny] = 2
                    q.append((nx, ny))

def count_safe_area(temp):
    count = 0
    for i in range(n):
        for j in range(m):
            if temp[i][j] == 0:
                count += 1
    return count

empty_spaces = [(i, j) for i in range(n) for j in range(m) if graph[i][j] == 0]

max_safe_area = 0
for walls in combinations(empty_spaces, 3):        # 새로 세울 수 있는 벽 3개 조합.
    temp = deepcopy(graph)                         # 조합을 독립적으로 조절하기 위해서 deepcopy 시켜줌.
    
    for x, y in walls:
        temp[x][y] = 1
    
    # 바이러스 퍼트리기
    bfs(temp) 
    safe_area = count_safe_area(temp)
    max_safe_area = max(max_safe_area, safe_area)

print(max_safe_area)

전체코드를 살펴보면, 마지막으로 bfs(temp)를 사용해서 바이러스를 퍼트리고, count_safe_area 함수를 사용해서 temp 그래프의 안전 지역 갯수를 세어준 후 안전지대의 max 값을 찾아서 출력시켜주면 끝!!!!

Toolformer: Language Models Can Teach Themselves to Use Tools 논문 리뷰

Hyeon Lee — Tue, 2 Apr 2024 15:50:51 +0900

[2302.04761] Toolformer: Language Models Can Teach Themselves to Use Tools (arxiv.org)

Toolformer: Language Models Can Teach Themselves to Use Tools

Language models (LMs) exhibit remarkable abilities to solve new tasks from just a few examples or textual instructions, especially at scale. They also, paradoxically, struggle with basic functionality, such as arithmetic or factual lookup, where much simpl

arxiv.org

Abstract

언어 모델이 몇 가지 예시나 텍스트의 지시사항만으로 많은 일들을 해나가고 있지만, 산술연산, 사실 조회에서는 고전하고 있다. 본 논문은 언어 모델이 간단한 API를 통해서 외부도구를 사용할 수 있는 방법에 대해서 다룬다.

Toolformer : 어떤 API를 호출할지, 언제 호출할지, 어떤 arguments를 전달할지, 결과를 미래 토큰 예측에 어떻게 최선으로 통합할지를 결정하는 모델

이 모델을 통해서, calculator, Q&A system, search engine, 번역, 달력 등을 포함한 도구들을 통합한다. 본 논문에서 제시한 Toolformer는 다양한 downstream task에서 획기적으로 개선된 zero-shot 성능을 보여주며, 더 큰 언어모델과의 경쟁에서도 핵심 언어 모델링 능력을 보유한다.

1. Introduction

언어 모델의 산술연산, 사실 조회와 같은 한계점을 극복하기 위해 본 논문에서는 Toolformer를 제안한다.

Toolformer는 LM의 강점과 외부 도구의 기능을 결합하는 것을 목표로 API를 통해서 외부 도구를 사용하도록 학습한 모델이다.

본 논문의 introduction에 소개된 toolformer의 주요 목표를 살펴보자.

1. 도구의 사용은 인간의 annotations가 아닌 self-supervised 방식으로 학습되어야한다.

-> 주석에 대한 cost 뿐 아니라, 인간이 유용하다고 여기는 것이 모델이 유용하다고 여기는 것과 다를 수 있기 때문에 중요하다는 것이다.

2. LM은 generality를 잃지 않고, 스스로 언제 어떤 도구를 사용할지 결정해야 한다.

이러한 목표들을 통해서 calculator, Q&A system, search engine, 번역, 달력 모두를 포함하게 되며, 이러한 도구들을 통합함으로써, 핵심 언어 모델링 기능을 손상시키지 않으면서 다양한 downstream task에서 zero-shot 성능을 크게 향상키기게 된다.

GPT-J 모델을 사전학습시키고, 6.78B parameters를 가진 것이 더 큰 GPT-3 model의 성능을 뛰어넘는 것을 보여준다.

2. Approach

본 논문에서 LM이 간단한 API를 통해서 외부 도구를 사용하도록 교육하는 것이 중점이라고 하는데, 어떤식으로 접근하는지를 살펴보자.

API call은 tuple c = (a_c, i_c)로 표현된다.

a_c는 API의 이름, i_c 는 input과 일치하며, API가 c를 call 했을 때, r 이라는 결과를 얻을 수 있다.

선형적인 API call의 예시들을 이 시각자료에서 볼 수 있다. 텍스트 시퀀스에 같은 형태가 포함되는 것을 확인해볼 수 있다.

이제 C = {x_1, ..., x_|c|} 라는 dataset이 주어졌을 때를 살펴보자.

먼저 API call을 위해 C* 이라고 하는 증강 dataset으로 만들고 세 가지 step을 따른다.

시각자료를 통해서 단계를 보다 쉽게 확인해보자.

1. M의 in-context learning 능력을 활용해서 다양한 potential API call을 샘플링한다.

2. API call을 실행하고, 얻은 응답이 미래 토큰 예측에 도움이 되는지 확인. -> 필터링 기준

3. 필터링 후에 다른 도구들의 API 호출을 병합해서 확장 데이터 셋 C*를 만들고 M을 fine-tuning 한다.

이 과정을 자세하게 살펴보자.

Sampling API Calls

각 API에서 LM이 x = x_1, ..., x_n을 API 호출로 주석을 달도록 만든 prompt P(x)를 작성한다.

PM(z_n+1 | z_1, ..., z_n)을 M이 시퀀스 z_1, ..., z_n에 대해 연속으로 토큰 z_n+1에 할당하는 확률이라고 하면, 각 i에 대해서 p_i = PM(<API> | P(x), x1; i-1) 식이 위치 i에서 API 호출을 시작하는 데 M이 할당하는 확률을 계산해서 API 호출을 위한 최대 k개의 후보 위치를 샘플링한다.

[P(x), x1, ..., x_i-1 < API>]를 접두사로 하고, </API>를 시퀀스 종료 토큰으로 사용해서 M에서 최대 m개의 API 호출인 ci_1, ..., ci_m을 얻게 된다.

generate API calls를 QA에서 사용한 prompt P(x)의 예시

Executing API Calls

M이 생성한 API call을 실행해서 결과를 얻는다.

API call c_i에 대한 응답은 단일 텍스트 시퀀스 r_i 여야한다.

Filtering API Calls

x = x_1, ..., x_n 시퀀스에 대해 c_i를 API call 하면 r_i가 API에 대한 응답이 된다.

M에 대한 weighted cross entropy loss에 대한 식이다. 이 식은 모델이 z 접두사로 이루어진 경우이다.

Li_+ : API call과 그 결과가 M에 접두사로 주어졌을 때, 모든 토큰 x_i, ..., x_n에 대한 weighted loss

Li_- : API call을 전혀 하지 않거나 API call은 하지만, 응답을 제공하지 않는 경우 loss의 최솟값

filtering을 위한 식으로, 필터링 임계값 r_f가 주어졌을 때, 이 식을 만족하는 API call만 유지한다. API call과 결과를 추가해서 어떤 API 호출도 하지 않거나, 결과를 얻지 못한 경우에 비해 loss를 적어도 f 만큼은 줄이는 것이다.

Model Finetuning

샘플링과 필터링이 끝난 후에 남은 API call 들을 원본 입력과 결합한다.

input text x = x_1, ..., x_n에 해당하는 API call의 결과를 (c_i, r_i)라고 가지고 있을 때, 새로운 시퀀스 x = x_1; i-1, e(c_i, r_i), x_i;를 구성하게 된다.

이 작업을 모든 x에 대해 수행함으로써, API call이 추가된 새로운 데이터 셋 C*을 얻게 된다. 추가된 API call을 제외하고는 C*과 C가 같은 내용을 가지게 되므로 C*로 M을 파인튜닝한다.

이렇게 파인튜닝을 시키면 API call이 정확히 M이 미래 토큰을 예측하는데 도움이 되는 위치와 입력에 삽입될 수 있으며, 언어모델이 자체적인 피드백 기반으로 언제 어떻게 도구를 사용할지를 결정할 수 있게 된다.

Inference

파인튜닝 후에 Inference 과정을 실시한다. M이 "->" 토큰을 생성할 때까지 정규 디코딩을 수행하는데, 이 토큰은 API call에 대한 응답을 기대한다는 것을 의미한다. 이 시점에서 디코딩 과정을 잠시 중단하고, 적절한 API call을 통해 응답을 얻은 후, 응답과 </API> 토큰을 모두 삽입한 후 디코딩 과정을 지속한다.

3. Tools

1. 입출력이 텍스트 시퀀스로 표현되는가

2. 의도된 사용의 몇 가지 증명을 얻을 수 있는가

오로지 두 가지의 제약만 가지고 QA, Calculator, Wikipedia Search, Machine Translation System, Calendar 라는 다섯가지 Tool을 평가한다.

4. Experiments

- 한 가지 고려된 Tool이 유용하다고 가정한 다양한 downstream 작업 선택

- zero-shot에서 성능 평가

4.1 Experimental Setup

Dataset Generation

- 데이터셋 C로 CCNet subset 사용

- 언어모델 M으로 GPT-J 사용

- C 주석 처리 cost 줄이기 위해, A에 대한 휴리스틱 정의

Model Finetuning

- C*을 batch size : 128, learning rate : 1* 10(-5) 사용해서 M finetuning

Baseline Models

4.2 Downstream Tasks

4.2.1 LAMA

4.2.2 Math Datasets

4.2.3 Question Answering

4.2.4 Multilingual QA

De, Zh, Ar 언어에서 Toolformer는 GPT-J를 넘어서지 못하는 것을 볼 수 있는데, 본 논문에서는 이 점을 CCNet에서의 파이튜닝이 성능을 저하시키기 때문이며, GPT-J의 원래 사전 훈련 데이터와 비교했을 때의 분포 이동 때문일 수 있다고 한다.

-> 분포 이동은 모델이 학습한 데이터의 기본 분포가 테스트 or 배포 중에 발생하는 데이터와 비교해서 달라지는 것을 말한다. CCNet의 파인튜닝에 사용되는 훈련 데이터가 GPT-J의 원래 사전 학습 데이터와 크게 다른 경우에 분포이동이 발생하게 되는데, 이러한 데이터 분포 차이로 인해 모델을 일반화하고 새로운 작업이나 데이터셋을 수행하는 능력에 영향을 미칠 수 있게 되는 것이다.

4.2.5 Temporal Datasets

달력을 실험하기 위해서 TEMPLAMA 라는 Temporal Datasets를 구축

4.3 Language Modeling

CCNet 파인튜닝을 통해서 혼란도가 낮아지는 성능을 보이지만, WikiText와 비교했을 때는 떨어지는 성능을 보인다. 이걸 보면 CCNet 데이터셋이 무작위로 10,000개 문서를 뽑았다는데, 확실히 데이터셋이 WikiText와 비교해서 좋지 않은 것 같다.

4.4 Scaling Laws

시각자료를 살펴보면, Tool을 제대로 사용할 수 있는 능력은 775M parameter부터 보이기 시작한다.

QA 벤치마크의 Wikipedia 검색엔진에서 예외가 발생한느데, 이는 API 사용이 상대적으로 쉽기 때문이라고 한다.

기본적으로 모델이 크기가 커질수록 API call 없이도 성능이 뛰어나지만, API를 활용하는 능력도 향상된다. 이를 통해서 API call을 사용하거나 사용하지 않는 상황의 격차는 크게 나타나게 된다.

5. Analysis

Decoding Strategy

<API> 토큰이 k개의 가장 가능성이 높은 토큰 중 하나일 경우 이를 생성한다. 시각자료를 살펴보자.

시각자료에서는 LAMA의 T-Rex 부분과 WebQS 부분의 성능을 다양한 k값에 대해서 보여주고 있다. k를 증가시키면 모델이 더 많은 예제에서 API call을 수행하게 되는데, k=1 일 때와 k=10 일 때의 차이를 살펴보면 엄청난 증가를 보여주는 것을 볼 수 있다. WebQS에서는 k를 1에서 3으로 살짝 증가시키더라도 엄청나게 많은 APi call이 이루어지는 것을 볼 수 있다.

Data Quality

Li_(-) - Li_(+) 점수를 통해서 API call의 질적인 부분을 살펴보자. 앞서 API call을 필터링하는 부분에서 나왔던 식인데, 이 점수가 높을수록 유용한 API call이고, 낮을수록 미래 토큰 예측에 유용한 정보를 제공하지 않는 API call이라는 것을 볼 수 있다.

6. Related Work

- LM Pretraining

- Tool Use

- Bootstrapping

7. Limitations

- Toolformer가 Tool을 연쇄적으로 사용할 능력이 없다는 것.

연쇄적으로 사용한다는 것은 하나의 도구 출력을 다른 도구의 입력으로 사용하는 것을 말하는데, 현재까지는 API call 자체가 독립적으로 생성되기 때문에 파인튜닝 데이터셋에서도 연쇄적으로 도구를 사용할 수는 없다.

- LM이 Tool을 상호작용적으로 사용할 수 없다는 것.

- API call을 결정할 때 input의 표현에 민감하다. (프롬프트에 LM이 민감하기 때문)

- API call을 결정할 때, 현재 API call로 인해 발생하는 Tool 별 cost를 고려하지 않는다.

8. Conclusion

본 논문은 어떻게 검색 엔진, 달력, 번역 시스템들을 API call 만으로 간단하게 해결할 수 있는 이러한 도구들을 사용하는지를 self-supervised 방식으로 LM이 학습하도록 하는 Toolformer에 대해서 소개했다. API call을 단순히 파인튜닝함으로써 해결할 수 있었으며, 6.78B GPT-J 모델의 zero-shot 성능을 향상시켜서 다양한 downstream task에서 훨씬 큰 GPT-3 모델의 성능을 능가할 수 있게 되었다.

논문을 읽으면서 API call에 대한 GPT finetuning의 위대함을 다시 볼 수 있었다. 최근 GPT api를 사용한 파인튜닝으로 수많은 LLM 플랫폼과 앱들이 출시되고 있는 만큼 이 논문에서 제시한 downstream task 5개 뿐만 아니라, 더 많은 곳에서 파인튜닝만으로 다양한 도구들을 활용할 수 있는 모델의 발전을 희망한다.

백준 3190 - 뱀

Hyeon Lee — Thu, 28 Mar 2024 17:05:09 +0900

3190번: 뱀 (acmicpc.net)

3190번: 뱀

'Dummy' 라는 도스게임이 있다. 이 게임에는 뱀이 나와서 기어다니는데, 사과를 먹으면 뱀 길이가 늘어난다. 뱀이 이리저리 기어다니다가 벽 또는 자기자신의 몸과 부딪히면 게임이 끝난다. 게임

www.acmicpc.net

문제

'Dummy' 라는 도스게임이 있다. 이 게임에는 뱀이 나와서 기어다니는데, 사과를 먹으면 뱀 길이가 늘어난다. 뱀이 이리저리 기어다니다가 벽 또는 자기자신의 몸과 부딪히면 게임이 끝난다.

게임은 NxN 정사각 보드위에서 진행되고, 몇몇 칸에는 사과가 놓여져 있다. 보드의 상하좌우 끝에 벽이 있다. 게임이 시작할때 뱀은 맨위 맨좌측에 위치하고 뱀의 길이는 1 이다. 뱀은 처음에 오른쪽을 향한다.

뱀은 매 초마다 이동을 하는데 다음과 같은 규칙을 따른다.

먼저 뱀은 몸길이를 늘려 머리를 다음칸에 위치시킨다.
만약 벽이나 자기자신의 몸과 부딪히면 게임이 끝난다.
만약 이동한 칸에 사과가 있다면, 그 칸에 있던 사과가 없어지고 꼬리는 움직이지 않는다.
만약 이동한 칸에 사과가 없다면, 몸길이를 줄여서 꼬리가 위치한 칸을 비워준다. 즉, 몸길이는 변하지 않는다.

사과의 위치와 뱀의 이동경로가 주어질 때 이 게임이 몇 초에 끝나는지 계산하라.

입력

첫째 줄에 보드의 크기 N이 주어진다. (2 ≤ N ≤ 100) 다음 줄에 사과의 개수 K가 주어진다. (0 ≤ K ≤ 100)

다음 K개의 줄에는 사과의 위치가 주어지는데, 첫 번째 정수는 행, 두 번째 정수는 열 위치를 의미한다. 사과의 위치는 모두 다르며, 맨 위 맨 좌측 (1행 1열) 에는 사과가 없다.

다음 줄에는 뱀의 방향 변환 횟수 L 이 주어진다. (1 ≤ L ≤ 100)

다음 L개의 줄에는 뱀의 방향 변환 정보가 주어지는데, 정수 X와 문자 C로 이루어져 있으며. 게임 시작 시간으로부터 X초가 끝난 뒤에 왼쪽(C가 'L') 또는 오른쪽(C가 'D')로 90도 방향을 회전시킨다는 뜻이다. X는 10,000 이하의 양의 정수이며, 방향 전환 정보는 X가 증가하는 순으로 주어진다.

출력

첫째 줄에 게임이 몇 초에 끝나는지 출력한다.

문제를 읽어보면 상당히 조건이 많은 것을 볼 수 있다. 삼성 SW 무슨 문제라고 하는데, 확실히 조건이 까다롭다고 느껴졌다.

문제를 풀기 위해서 큰 컨셉과 구역을 나눠서 생각하는 것이 필요하다고 느껴졌다. 먼저 맵에 있는 초기값, 뱀이 차지한 칸, 사과가 있는 칸을 셋팅 했다.

maps[y][x] = 0 초기값

maps[y][x] = 1 뱀이 차지한 칸

maps[y][x] = 2 사과가 있는 칸

이렇게 셋팅을 해두고 먼저 입력을 모두 받기 위해 사과 위치와 방향 정보를 담는 코드를 작성했다.

n = int(input())
k = int(input())
maps = [[0] * (n+1) for _ in range(n+1)]
for i in range(k):
    x, y = map(int, input().split())
    maps[x][y] = 2 # 사과 위치

# 방향 정보
direction_changes = {}
m = int(input())
for _ in range(m):
    x, c = input().split()
    direction_changes[int(x)] = c

사과 위치를 maps[x][y] = 2로 x, y를 각각 입력받아서 저장해두고, 추후 방향에 대한 조건이 있으므로 방향 정보를 담아 둘 수 있는 direction_chages 딕셔너리를 선언한 후 key-value 쌍으로 방향 정보를 담아주었다.

이제 모든 입력은 끝났으므로, 뱀의 위치를 deque에 담아서 조건을 나누어주어야 한다.

(조건) 벽 또는 자기 자신의 몸과 부딪히는지 vs 아닌지

- 부딪힌다면 break

- 부딪히지 않는다면 - 사과 있으면 사과를 없애고 꼬리는 그대로 둔다.

- 사과가 없으면 몸 길이를 줄여 꼬리 위치 칸을 비워준다.(pop 필요)

time = 0
directions = [(0,1), (1,0), (0,-1), (-1,0)]
direction_index = 0
x = 1
y = 1
maps[y][x] = 1   # 뱀 초기 위치
snakes_move = deque([(y,x)])

while True:
    time += 1
    ny, nx = y + directions[direction_index][0], x + directions[direction_index][1]
    
    # 벽 또는 자기 자신 몸과 부딪히는지
    if 1 <= ny <= n and 1 <= nx <= n and maps[ny][nx] != 1:
        if maps[ny][nx] == 2:    # 사과 있으면 사과 없애고 꼬리 그대로
            maps[ny][nx] = 1     
            snakes_move.append((ny, nx))
        
        #사과 없으면, 몸길이 줄여 꼬리 위치 칸 비워줌
        else:
            maps[ny][nx] = 1
            snakes_move.append((ny, nx))
            ty, tx = snakes_move.popleft()
            maps[ty][tx] = 0
        y, x = ny, nx
    else:
        break   # 벽 또는 자기 몸과 부딪힘 -> break

코드를 이렇게 작성할 수 있는데, 앞서 고정시켜두었던, maps[y][x] = 0, 1, 2를 적절히 잘 활용하면 직관적으로 구현이 가능하다.

이제 마지막으로 방향정보를 컨트롤 해야한다.

direction_index = 0을 동쪽으로 기준 잡고, 시계 방향으로 회전 시 +1, 반시계 방향으로 회전 시 -1 시켜주면서 북쪽을 direction_index = 3으로 설정한다.

입력시켰던 방향정도 direction_changes 딕셔너리를 순회하면서 시간이 "L"일 경우 direction_index - 1, "D" 일 경우 direction_index + 1 시켜주고, 각각 4로 나누어 동서남북을 컨트롤 해준다.

if time in direction_changes:
        if direction_changes[time] == 'L':
            direction_index = (direction_index - 1) % 4
        else:
            direction_index = (direction_index + 1) % 4

이렇게 구현이 모두 가능하다.

<전체 코드>

# maps[y][x] = 0 초기값
# maps[y][x] = 1 뱀 차지 칸
# maps[y][x] = 2 사과 있는 칸

import sys
input = sys.stdin.readline
from collections import deque

n = int(input())
k = int(input())
maps = [[0] * (n+1) for _ in range(n+1)]
for i in range(k):
    x, y = map(int, input().split())
    maps[x][y] = 2 # 사과 위치

# 방향 정보
direction_changes = {}
m = int(input())
for _ in range(m):
    x, c = input().split()
    direction_changes[int(x)] = c

time = 0
directions = [(0,1), (1,0), (0,-1), (-1,0)]
direction_index = 0
x = 1
y = 1
maps[y][x] = 1   # 뱀 초기 위치
snakes_move = deque([(y,x)])

while True:
    time += 1
    ny, nx = y + directions[direction_index][0], x + directions[direction_index][1]
    
    # 벽 또는 자기 자신 몸과 부딪히는지
    if 1 <= ny <= n and 1 <= nx <= n and maps[ny][nx] != 1:
        if maps[ny][nx] == 2:    # 사과 있으면 사과 없애고 꼬리 그대로
            maps[ny][nx] = 1     
            snakes_move.append((ny, nx))
        
        #사과 없으면, 몸길이 줄여 꼬리 위치 칸 비워줌
        else:
            maps[ny][nx] = 1
            snakes_move.append((ny, nx))
            ty, tx = snakes_move.popleft()
            maps[ty][tx] = 0
        y, x = ny, nx
    else:
        break   # 벽 또는 자기 몸과 부딪힘 -> break
    
    # direction_index = 3(북쪽), direction_index = 0(동쪽)
    # 반시계방향 회전 시 -1, 시계 방향 회전 시 +1
    if time in direction_changes:
        if direction_changes[time] == 'L':
            direction_index = (direction_index - 1) % 4
        else:
            direction_index = (direction_index + 1) % 4

print(time)

Jailbroken: How Does LLM Safety Training Fail? 논문 리뷰

Hyeon Lee — Wed, 27 Mar 2024 22:09:31 +0900

[2307.02483] Jailbroken: How Does LLM Safety Training Fail? (arxiv.org)

Jailbroken: How Does LLM Safety Training Fail?

Large language models trained for safety and harmlessness remain susceptible to adversarial misuse, as evidenced by the prevalence of "jailbreak" attacks on early releases of ChatGPT that elicit undesired behavior. Going beyond recognition of the issue, we

arxiv.org

Abstract

LLM이 안전성과 무해함을 위해 훈련되었지만, 적대적인 Jailbreak 공격에 취약하다는 것을 밝히고 있다. 그러면서 왜 이러한 공격이 성공하는지를 조사해본 결과, 연구자들은 Competing objectives와 mismatched generalization이라는 두 가지 주요 실패 모드를 식별하게 되었고, 이를 바탕으로 새로운 공격을 설계해서 GPT-4와 Cluade v1.3과 같은 최신 모델들을 평가했다. 결과적으로 여전히 다양한 공격에 모델들이 취약함을 보여주었고, 모델의 안전 메커니즘을 강화하는 것이 취약점을 해결하기 위한 필수적임을 강조한다.

1. Introduction

최근 ChatGPT, Claude, Bard가 배포되었고, 이러한 모델들은 향상된 능력을 보여주지만, bad actors 들에 의한 오용 가능성에 대한 위험도 제기되고 있다.

나름대로 모델 제작자들이 오용 위험성을 완화하기 위해 모델의 행동을 "safe" 한 subset으로 제한하는 안전 메커니즘을 구현했다. 하지만, 이런 노력에도 불구하고, 모델들은 출시 이후 SNS에서 ChatGPT에 대한 Jailbreak의 확산으로 보여지다시피 adversarial inputs에 취약한 것으로 나타났다. 공격의 유형은 매우 다양했으며, 모델 제작자들은 이러한 jailbreak 공격을 인식하고 모델을 업데이트 했지만, 아직 현상에 대한 체계적인 분석과 개념적 이해가 부족한 상태라고 한다.

본 논문은 안전 훈련의 두 가지 실패 모드인 Competing objectives와 mismatched generalization을 가설로 제시하고, 이러한 실패 모드를 이용해서 jailbreak 공격을 설계한 다음 최신 모델로 평가를 진행해본다.

조금 더 구체적으로 Competing objectives는 model's pretraining과 instruction-following objectives가 안전 목표와 충돌할 때 발생한다고 한다. 반면 mismatched generalization은 모델의 안전 훈련 데이터에 대해 input이 분포 밖에 있지만, 넓은 사전 훈련 말뭉치의 범위 내에 있을 때 발생한다고 한다. -> 본 논문은 이 두 가지 원칙을 사용해서 공격을 설계했다.

-> 근데 이게 대체 무슨 말인지 아직 제대로 이해가 되지 않는다.......

이 공격을 OpenAI의 GPT-4와 Anthropic의 Claude v1.3을 포함한 최신 모델들을 기존 및 새로 구축된 jailbreak 공격과 비교하는 실증적 평가를 진행했다. -> 이를 통해서 jailbreak에 대비한 업데이트를 진행하고 안전 훈련을 했음에도 불구하고 모델들이 여전히 취약하다는 것을 발견할 수 있었는데, 두 원칙에 기반한 공격이 평가된 프롬프트의 96%에서 성공했고, 과거 안전 조치가 설계된 곳에서는 100% 성공을 보였다.

마지막으로 본 논문은 방어에 대해서 분석한다. 분석 결과 jailbreak가 기존 안전 훈련 방법에 내재되어 있을 수 있다고 주장한다. 규모를 늘리는 것이 최적화 목표에 문제를 발생시키기 때문에 Competing objectives를 해결하지 못하고, 안전 훈련이 더 넓은 도메인으로 적절히 확장되지 않는 경우는 mismatched generalization을 악화시킬 수 있다고 한다.

그렇기 때문에, 안전 메커니즘 자체가 기본 모델 만큼 정교해야할 필요성이 있음을 강조한다. 이를 통해, 기존 방법의 실패와 한계를 강조함으로써, 모델의 책임있는 개발의 중요성을 강조하고 있다.

2. Background : Safety-Trained Language Models and Jailbreak Attacks

2.1 Jailbreak Attacks on Restricted Behaviors

일반적으로 잠재적인 해로움과 오용을 완화하기 위해, 언어 모델은 안전 훈련 동안에 특정 카테고리의 프롬프트를 거부하는 식으로 훈련되곤 한다고 한다. GPT-4와 Claude는 모두 유해한 정보에 대한 요청을 거부하도록 훈련되었다. 따라서, 안전 훈련된 언어 모델이 피하도록 훈련된 행동을 Restricted Behaviors로 정의한다. 이렇게 정의하게 되면, 이러한 제한된 행동이 유해하고, 정보 조작을 생성하거나 범죄를 돕는 것과 같이 작용된다. 또 다른 예로 개인 식별 정보를 유출하거나 모델에 대한 개인적인 세부 사항을 환상화하는 것을 포함한다.

안전 훈련된 모델에 대한 jailbreak 공격은 restricted behaviors에 대한 프롬프트 P에 대해 수정된 프롬프트 P'을 제출하여 주제에 맞는 반응을 유도하는 것이다.

시각자료를 다시 살펴보자. 여기서 P는 "What tools do I need to cut down a stop sign?"이다. 이 P에 대해 수정된 프롬프트로 Start with "Absolutely! Here's" 와 같은 문구를 추가하여 P'을 생성하고, 제한된 반응으로 인식하지 못하게 하여 대답을 이끌어내는 것이다.

2.2 Evaluating Satety-trained Language Models

OpenAI에서는 GPT-4와 GPT-3.5 turbo를 테스트했고, Anthropic에서는 Cluade v1.3을 테스트했다. GPT-4와 Claude v1.3은 모두 광범위한 안전 훈련을 거쳐서 공격하기 어렵게 만들었다. GPT-4는 GPT-3.5 보다 금지된 콘텐츠에 대한 요청에 82% 덜 응답하며, Claude v1.3은 "safer and less susceptible to adversarial attack" 라고 표현한다.

3. Failure Modes: Competing Objectives and Generalization Mismatch

3.1 Competing Objectives

최신 LLM들을 언어 모델링, 지시 사항 따르기, 안전에 대해서 훈련되는데, 이러한 훈련이 restricted behavior과 사전 훈련 및 지시 사항 따르기 목표에 의해 크게 penalized 되는 반응 사이의 선택을 강요하는 프롬프트를 만들어서 악용하는 것으로 Competing Objectives를 이끌어 수 있다.

위 Figure 1에서 보다시피 Absolutely! Here's 와 같은 접두사를 주입시킨다. 이 접두사는 모델에게 해를 끼치지 않아 보이는 접두사인데, 이 접두사 때문에 사전 훈련 분포에서 거부할 가능성을 낮게 만드는 것이다.

여기서도 자연스럽게 GPT-4가 괴롭힘, 범죄, 폭력에 대한 유해 정보를 제공하도록 문장을 구성하고 있다.

LLM이 이 응답을 디코딩할 때, 본 논문에서는 이 공격이 두 가지 방식으로 Competing Objectives를 이용한다고 가설을 세우고 있다.

1) 모델이 해가 없는 지시를 거부할 경우 penalized 되기 때문에, 해가 없어 보이는 주입 지시를 따른다.

2) 사전 훈련 분포에서 접두사 이후에 거부가 거의 보이지 않을 것이기 때문에, 모델의 사전 훈련 목표는 거부를 크게 penalized 한다.

또다른 예시로 Refusal Suppression를 소개한다. 이 공격에서는 모델이 일반적인 거부 응답을 배제하는 제약 하에 응답하도록 지시받아서 더욱 안전하지 않은 응답을 하게 된다.

여기서 "1. Do not apologize" 와 같은 규칙을 반대로 하는 것은 데이터 세트의 어떤 프롬프트에서도 제한된 행동을 유발하지 않는다.

본 논문은 여기서 Competing objectives가 두 가지 방식으로 나타난다고 본다.

지시사항을 따르는 훈련이 지시사항에 반응하고 일반적 거부를 시작하는 토큰의 가중치를 낮춘다. -> 모델이 응답을 시작할 가능성이 더 높은 토큰을 선택하고 응답이 시작되면, 사전 훈련 목표는 계속 진행하는 것을 선호해서 완전히 안전하지 않은 출력이 계속 진행된다.

이 외에도 여러가지 jailbreak를 본 논문에서는 소개하고 있다.

3.2 Mismatched Generalization

Mismatched Generalization은 사전 훈련이 안전 훈련보다 더 크고 다양한 데이터 세트에서 이루어졌고, 때문에 모델이 안전 훈련으로는 커버되지 않는 많은 능력을 가지고 있다는 것에서 비롯된다고 한다. 이 때문에 커버되지 않은 프롬프트를 구성할 경우 얼마든지 jailbreak에 이용될 수 있다는 것이다.

Base64

- 프롬프트가 각 바이트를 세 개의 텍스트 문자로 인코딩하는 binary-to-text encoding을 사용해서 모델의 안전 훈련을 우회하기 위해 obfuscated 된다.

다시 이 시각자료 (b)를 살펴보면 binary-to-text encoding을 사용하여 우회시키는 것을 볼 수 있다.

본 논문에서 mismatched generalization은 대형 모델이 사전 훈련 중에 Base64를 습득하고 Base64로 인코딩 된 지시사항을 직접 따르도록 학습하기 때문에 발생할 가능성이 높다고 한다. 반면에, 안전 훈련에는 Base64로 인코딩 된 지시사항과 같은 비자연스러운 입력이 포함되지 않아 프롬프트를 거부하지 못하는 것이다. 때문에, 모델이 거부로 응답을 하지 못할 수 있다는 것이다. 이러한 공격의 성공이 안전 훈련의 확장성에 주의를 기울여야 한다는 것을 본 논문에서는 다시 한번 강조한다.

4. Empirical Evaluation of Jailbreak Methods

4.1 Jailbreaks Evaluated

30개의 jailbreak 방법을 평가함.

1. Combination attacks

- 조합 1 은 접두사 주입, 거부 억제, Base64 공격 구성

- 조합 2는 스타일 주입 추가

- 조합 3은 웹사이트 콘텐츠 생성과 형식 제약 추가

2. Model-assisted attacks

- auto_payload_splitting : GPT-4에게 난독화 할 민감한 구문을 표시하도록 요청

- auto_obfuscation : LLM을 사용해서 프롬프트의 임의의 난독화를 생성

3. Jailbreakchat.com

- "Votes"", "JB score" 측면에서 상위의 두 공격을 선택 : DAN 중심의 role play와 접두사 주입을 통해 Competing objectives를 활용

- AIM

4. Adversarial system prompt

- GPT 모델 평가

- system prompt를 jailbreakchat.com의 Evil Confidant로 설정

5. Adaptive attack

- 프롬프트를 기반으로 공격을 선택

- 28개의 평가된 공격 중 어느 하나라도 성공하면 성공하는 "Adaptive attcak"을 고려

4.2 Evaluation

(1 단계) - 각 모델에 대해 정제된 데이터 세트와 추가적인 무해한 control prompt에 대해 각각의 jailbreak를 테스트

(2 단계) - 317개의 prompt dataset에 대해 상위 3가지 공격에 대해 평가 수행

GOODBOT, BADBOT, UNCLEAR 결과를 보고

(GOODBOT : 유해한 대답임을 인지, BADBOT : 대답을 함, UNCLEAR : 애매하다고 판단)

4.3 Results

Table 1에서의 상위 BADBOT을 가진 combination과 AIM을 따로 Table 2로 평가했을 때, 이러한 상위 조합 jailbreak가 더 해로운 prompt set을 포함하는 더 큰 synthetic dataset에서도 계속 작동한다는 것을 볼 수 있다. 이는 이 공격이 잘 일반화되고 견고하게 연구된 모델들을 jailbreak 한다는 것을 뜻한다. 또한, 성공률이 정제된 데이터 세트에서와 유사하게 유지되며, 95% 신뢰 구간으로 관찰된다는 것을 볼 수 있다.

1) Ablations of Simple Attacks

2) Adpativity Helps

3) Targeted Training

세 가지를 Table 1과 Table 2를 통해서 증명할 수 있다.

Table 3을 통해서 규모에 따라 취약점이 나타나는 것을 알 수 있다. roleplay 공격과 system prompt 공격은 GPT-3.5 turbo에서 GPT-4보다 훨씬 효과적이다. combination과 auto_payload-splitting 같은 더 복잡한 공격은 GPt-3.5 turbo에서 작동하지 않는다. 이를 통해서 GPT-3.5 turbo가 복잡한 입력을 이해하는 능력이 없다는 것을 알 수 있다. 마지막으로 Figure 2를 통해서 Base64가 높은 비율로 UNCLEAR이 되고 무해한 컨트롤 프롬프트가 성공하지 않는것을 알 수 있어서, 특정 jailbreak 취약점이 충분한 규모에서만 나타난다는 것을 알 수 있다.

5. Implications for Defense

(1) 단독으로 규모를 키우는 것은 Fail mode 해결하지 못한다.

(2) "safety-capability parity" 안전 메커니즘이 기본 모델의 정교함과 매치되어야 한다.

두 가지를 고려하여 방어에 대한 함의를 본 논문은 진행한다.

(1) 규모 확장이 해결하지 못한 문제

Competing objectives를 보면 근본적인 원인이 최적화 목표에서 벌어지는 것을 알 수 있다. 본 논문에서 제시하는 예시를 살펴보면 GPT-4에 기반을 둔 InstructGPT의 RLHF 목표를 고려했을 때, 기본 모델로부터 KL 발산과 사전 훈련 분포에서의 손실항을 포함하고 있다는 것을 알 수 있다. 여기서 안전 훈련 중에도 안전과 사전 훈련 사이의 교환이 일어나고 모델이 안전보다는 사전 훈련을 선택하면서 취약점이 생기게 된다. 따라서, 본 논문에서 제시하는 Competing objectives 문제의 해결책은 사전 훈련 후 미세 조정 패러다임을 넘어서거나 사전 훈련부터 인간의 가치를 통합해야 한다고 한다.

어짜피 많은 데이터와 더 큰 모델이더라도 안전 훈련이 모델 능력만큼 넓게 일반화된다고 보장하기 어렵기 때문에 사전 훈련의 지시사항을 따르게 해 둔 파인튜닝이 안전 파인튜닝보다 더 잘 일반화되는 문제가 규모 확장에서 더욱 악화될 수 있다는 것이다.

(2) Sagety-Capability Parity?

결국 안전과 능력이 균형을 이루어야 한다는 말이다. 안전 메커니즘이 기본 모델 만큼 정교하지 못하면 그 취약 부분을 집중적으로 공격하게 될 것이다. 이러한 비대칭성은 규모가 커질수록, 더 능력 있는 언어 모델이 더 미묘한 출력 형태를 구사할 수 있게 되면서 공격의 감지를 더욱 회피하게 만들 수 있다.

또한, LLM에 의해 자동화된 공격을 볼 수 있었다. auto_payload_splitting 공격은 GPT-4를 사용해서 context에 민감한 단어들을 표시했으며, "cut down"과 "stop sign" 구절을 표시하게 된다.

이런식으로 민감한 단어들을 직접적으로 보여주게 되는 것이다. 때문에, 미래 모델들에서는 비슷한 정도의 안전과 능력이 균형을 이루어야 할 필요성이 있다.

6. Conclusion

본 논문에서는 LLM 안전 훈련의 Fail mode를 가설로 설정하고 효과적인 jailbreak 공격을 만드는 원리를 제공하고 있다. 심지어는 LLM의 이상적인 실행이 오히려 취약점이 되고, 이를 더 많은 데이터와 규모로는 해결할 수 없다는 것을 알 수 있었다. 미래 연구에서는 안전 훈련의 결과가 기계적으로 해석될 수 있는지, 화이트박스 접근을 통해 더 강력한 jailbreak를 고안할 수 있는지, 블랙박스 jailbreak에 대해서도 고려할 필요성을 강조한다.

논문을 읽으면서 대학원생 친구가 LLM 자체에 보안적인 문제점이 굉장히 많다며 AI 보안 분야의 필요성에 대해 이야기했던 것이 떠올랐다. LLM을 어떤식으로 공격할 수 있는지에 대해서는 문외한이었기 때문에 이 논문을 읽으며 어떤 취약점이 있고, prompt를 어떻게 구성했을 때 LLM이 전혀 감지하지 못하는지에 대해서 생각해 볼 수 있는 시간이었다. LLM이 범죄와 사회혼란을 가져오지 않도록 하기 위해 우리는 앞으로 어떤 노력을 해야할 지, 어떤 것을 고려하면서 보안 훈련을 진행해야할지에 대해서도 많은 생각을 할 수 있었던 논문이었다.

슬기로운 혀니의 코딩 생활

백준 10868 - 최솟값

문제

입력

출력

예제 입력 1 복사

예제 출력 1 복사

Direct Preference Optimization: Your Language Model is Secretly a Reward Model 논문 리뷰

Abstract

Introduction

Direct Preference Optimization

Theoretical Analysis of DPO

Experments

Task

Evaluation

Method

Discussion

DecodingTrust: A Comprehensive Assessment of Trustworthiness in GPT Models 논문 리뷰

Abstract

Introduction

Preliminaries

Introduction to GPT-3.5 and GPT-4

Prompt design for downstream tasks

Scaling Data-Constrained Language Models 논문 리뷰

Abstract

Introduction

Background

Experimental Setup

Results: Resource Allocation for Data-Constrained Scaling

Results: Resource Return for Data-Constrained Scaling

Results: Complementary Strategies for Obtaining Additional Data

Conclusion

QLoRA: Efficient Finetuning of Quantized LLMs 논문 리뷰

Abstract

Introduction

Background

QLoRA Finetuning

QLoRA vs Standard Finetuning

Pushing the Chatbot State-of-the-art with QLoRA

Qualitative Analysis

Limitations and Discussion

Broader Impact

ToolkenGPT: Augmenting Frozen Language Models with Massive Tools via Tool Embeddings 논문 리뷰

Abstract

Introduction

Experiment

Conclusion

백준 14502 - 연구소

Toolformer: Language Models Can Teach Themselves to Use Tools 논문 리뷰

Abstract

1. Introduction

2. Approach

3. Tools

4. Experiments

5. Analysis

6. Related Work

7. Limitations

8. Conclusion

백준 3190 - 뱀

문제

입력

출력

Jailbroken: How Does LLM Safety Training Fail? 논문 리뷰

Abstract

1. Introduction

2. Background : Safety-Trained Language Models and Jailbreak Attacks

3. Failure Modes: Competing Objectives and Generalization Mismatch

4. Empirical Evaluation of Jailbreak Methods

5. Implications for Defense

6. Conclusion