본 포스트는 1, 2편에 걸쳐 Data-Centric NLP와 관련된 최근 연구 동향을 체계적으로 설명합니다. 데이터 증강, 필터링, 합성 데이터 생성, 데이터 품질 측정 등 다양한 주제를 다루며, 각각의 연구 방향과 방법론을 설명합니다.

1. 데이터 증강 (Data Augmentation)

데이터 증강은 주어진 데이터셋을 확장하여 모델의 성능을 높이기 위한 다양한 방법을 포함합니다.

1.1 반복적 역번역 (Iterative Back-Translation)

• Iterative Back-Translation for Neural Machine Translation (Hoang et al., 2018): 이 연구에서는 기계 번역에서 데이터 증강을 위해 반복적 역번역을 사용하는 방법을 제안합니다. 역번역(back-translation)은 원본 텍스트를 타 언어로 번역한 후, 다시 원본 언어로 번역하는 과정을 반복함으로써 새로운 데이터 샘플을 생성합니다. 이를 통해 모델이 다양한 문장 구조에 대해 학습할 수 있도록 하여 번역 성능을 향상시킵니다.

1.2 태스크-비특이적 데이터 증강 (Task-Agnostic Data Augmentation)

• How Effective is Task-Agnostic Data Augmentation for Pretrained Transformers (Longpre et al., 2020): 이 연구는 사전 학습된 트랜스포머 모델에서 태스크-비특이적 데이터 증강의 효과를 평가합니다. 태스크에 상관없이 데이터셋을 확장하는 접근 방식이 다양한 자연어 처리(NLP) 작업에서 성능을 향상시킬 수 있음을 보여줍니다.

1.3 ChatGPT를 활용한 데이터 증강 (ChatAug)

• ChatAug: Leveraging ChatGPT for Text Data Augmentation (Dai et al., 2023): ChatGPT를 이용해 대화 기반 텍스트 데이터를 증강하는 방법을 제안합니다. 이 방법은 ChatGPT를 사용하여 새로운 문장을 생성하거나 기존 문장을 변형함으로써 데이터셋의 다양성을 높이고, 모델 학습을 위한 질 높은 데이터를 확보할 수 있습니다.

2. 데이터 필터링 (Data Filtering)

데이터 필터링은 노이즈가 있는 데이터를 제거하여 데이터 품질을 개선하는 방법입니다.

2.1 병렬 말뭉치 필터링 (Parallel Corpus Filtering)

• Parallel Corpus Filtering (PCF): 병렬 말뭉치 필터링은 번역 작업에서 데이터 품질을 높이기 위해 사용됩니다. WAT 2022에서는 PCF를 주요 주제로 선정하여, 병렬 말뭉치에서 노이즈가 포함된 데이터를 필터링하는 다양한 접근법을 논의했습니다. 이를 통해 번역 모델의 성능을 크게 개선할 수 있었습니다.
  • Rule Based Approaches: 너무 짧거나 긴 문장(문자 또는 토큰 수준), 특수 토큰만 포함된 단어, 길이가 일치하지 않는 쌍, 특수 엔티티(이름, 숫자, 날짜, 이메일, URL 등)의 불일치, 복사된 문장 쌍, 요구된 언어를 감지하지 못하는 경우 등의 규칙에 따라 필터링합니다.
  • Statistic Based Approaches: 기계 번역 필터링(Machine Translation Filtering)에서는 특정 단어 선택에 기반한 규칙 기반 방법과 재정렬 부족을 기반으로 하는 통계적 방법을 사용합니다. 또한, 이상치(outlier) 탐지, 단어 정렬(word alignment), N-그램 기반 언어 모델, 언어 모델 확률, NMT 모델 확률을 이용한 모델 확률 계산 방법을 포함합니다.
  • NMT Based Approaches: 문장 임베딩(sentence embedding)을 사용하며, LM 기반, NMT 기반, LASER 등의 임베딩 방식을 포함합니다. 또한, LM/NMT 모델을 기반으로 한 크로스 엔트로피(model cross entropy)와 가짜 부정 샘플(pseudo-negative sample)을 이용해 문장 쌍의 품질을 판단하는 문장 분류기(sentence classifier)를 사용합니다.

3. 합성 데이터 (Synthetic Data)

합성 데이터는 모델 학습을 위해 인공적으로 생성된 데이터로, 기존 데이터의 부족함을 보완하고 학습 성능을 개선하는 데 사용됩니다.

3.1 프롬프트를 활용한 합성 데이터 생성

• PromptBase: PromptBase는 효과적인 Generative AI 사용을 위해 프롬프트를 사고파는 웹 사이트로, 사용자들이 다양한 프롬프트를 쉽게 공유하고 거래할 수 있는 플랫폼입니다.

• Pre-train, Prompt, and Predict: A Systematic Survey of Prompting Methods in NLP (Liu et al., 2023): 이 연구는 자연어 처리에서 프롬프트(prompt)를 활용하여 합성 데이터를 생성하는 다양한 방법을 조사합니다. 프롬프트는 언어 모델에게 입력으로 주어지는 텍스트 템플릿으로, 이를 사용해 모델의 출력을 유도하여 다양한 태스크에 맞는 데이터를 생성할 수 있습니다.

• Prompt Programming for Large Language Models (Reynolds and McDonell, 2021): 메타 프롬프트(Meta Prompt)라는 개념을 도입하여, 프롬프트를 생성하기 위한 프롬프트를 제안합니다. 이는 프롬프트 기반 모델의 유연성을 높이고, 보다 복잡한 응답을 생성하도록 돕습니다.

3.2 음성 인식 후처리를 위한 합성 데이터

• BTS: Back TranScription for Speech-to-Text Post-Processor using Text-to-Speech-to-Text (Park et al., 2021): 음성 인식 후처리기 연구를 위해 텍스트-음성-텍스트 변환을 사용하여 합성 데이터를 생성하는 방법을 제안합니다. 이를 통해 음성 인식 후처리 과정에서의 성능을 향상시킬 수 있습니다.

4. 데이터 측정 (Data Measurement)

데이터 품질 측정은 데이터셋의 품질을 평가하고, 모델 학습에 적합한 데이터를 선택하는 데 중요한 역할을 합니다.

4.1 어노테이터 일치도 측정 (Annotator Agreement)

• Measuring Annotator Agreement Generally across Complex Annotation Tasks (Braylan et al., 2022): 이 연구는 복잡하고 다양한 구조의 주석 작업에 대해 어노테이터 간의 일치도를 측정하는 새로운 방법을 제안합니다. 기존의 주요 지표인 Cohen’s Kappa, Fleiss’ Kappa, Krippendorff’s Alpha 외에도, 이 연구는 복잡한 태스크에 적합한 개선된 지표를 개발하여 어노테이션 품질을 평가합니다. 이러한 지표는 어노테이터 간의 일관성을 더 정교하게 측정하고, 주석 작업의 복잡성과 다면성을 반영할 수 있습니다.
  • Kolmogorov-Smirnov (KS) Statistic: KS 통계는 두 확률 분포 간의 최대 차이를 측정하는 지표로, 누적 분포 함수(CDF)를 사용하여 계산됩니다. 이 연구에서는 실제 어노테이션 분포와 기대되는 어노테이션 분포 간의 최대 차이를 계산하여 어노테이터 간의 불일치 정도를 평가합니다.

4.2 어노테이션 불일치 분석 (Annotation Disagreement)

• Everyone’s Voice Matters: Quantifying Annotation Disagreement Using Demographic Information (Wan et al., 2023): 이 연구는 주석 작업자 간의 불일치 정도를 예측하기 위해 인구통계학적 정보를 사용합니다. RoBERTa-base 모델을 사용해 데이터를 학습하며, 주석 작업자의 다양성을 고려하여 불일치 패턴을 분석합니다.

5. 그 외

이 문서에서 다루지 않은 추가적인 Data-Centric AI 주제는 다음과 같습니다:

• 레이블 오류 (Label Errors): 데이터셋에서 잘못된 레이블을 찾아내고 수정하는 방법.
• 기계 학습 모델의 데이터 중심 평가 (Data-centric Evaluation of ML Models): 모델의 성능을 데이터 품질과 연결 지어 평가하는 방법.
• 클래스 불균형, 이상치, 분포 변화 (Class Imbalance, Outliers, and Distribution Shift): 데이터셋의 클래스 불균형, 이상치 문제, 그리고 데이터 분포 변화에 대응하는 전략.
• 데이터 프라이버시와 보안 (Data Privacy and Security): 데이터 사용에 있어 프라이버시와 보안을 보장하는 방법.
• 훈련 전략 (Training Strategies): 데이터의 효율적인 활용을 위한 다양한 훈련 전략.
• Cross-Lingual Transfer Learning: 사전 학습된 언어 모델에서 다국어 전이 학습을 탐구하는 방법.

모델을 수정하지 않고 데이터 중심 접근 방식으로 NLP 모델의 성능을 향상시키는 다양한 방법들이 존재합니다. 대표적인 방법으로는 서브워드 토큰화(Subword Tokenization), 데이터 증강(Data Augmentation), 데이터 필터링(Data Filtering), 합성 데이터(Synthetic Data), 훈련 전략(Training Strategies) 등이 있습니다.

1.1 서브워드 토큰화 (Subword Tokenization)

서브워드 토큰화는 OOV(Out-Of-Vocabulary) 문제, 희귀 단어, 신조어 등으로 인해 발생하는 어려움을 해결하는 데 유용합니다. 한국어처럼 교착어의 특성을 가진 언어에서 형태소 기반 서브워드 토큰화가 효과적입니다.

• BPE(Byte Pair Encoding): 가장 빈도 높은 유니그램 쌍을 하나의 유니그램으로 통합하는 방식으로, 바텀업(bottom-up) 접근법을 사용해 딕셔너리를 생성합니다. 이를 통해 자주 사용되는 단어 조합을 효과적으로 표현할 수 있습니다.
• 형태소 기반 서브워드 토큰화: 한국어와 같이 교착어를 위한 토큰화 방식으로, 형태소 분석기(Mecab-ko) 등을 이용해 BPE를 적용하여 어휘 집합(vocab)을 구성합니다. 예를 들어 KLUE(Korean Language Understanding Evaluation)에서는 32K의 어휘 집합을 생성해 사용합니다.

1.2 데이터 증강 (Data Augmentation)

데이터 증강은 데이터의 다양성을 높이고 오버피팅을 방지하기 위해 원본 데이터를 변형하거나 새로운 데이터를 추가하는 기법입니다.

Rule-Based Techniques: 사전에 정의된 변형 방식을 이용해 데이터를 쉽게 증강합니다.

• Easy Data Augmentation(EDA)

  • SR(Synonym Replacement): 동의어로 치환
  • RI(Random Insertion): 임의 삽입
  • RS(Random Swap): 임의 교환
  • RD(Random Deletion): 임의 삭제

• Unsupervised Data Augmentation(UDA): UDA는 레이블이 없는 데이터를 활용해 모델의 성능을 향상시키는 기법입니다. 원본 데이터에 무작위 변형을 가해 모델이 다양한 데이터 변형에 대해 일관된 예측을 하도록 훈련함으로써 일반화 능력을 향상시킵니다. 이를 통해 레이블이 부족한 상황에서도 높은 성능을 유지할 수 있으며, 텍스트와 이미지 분류 등 다양한 분야에서 활용됩니다.

Example Interpolation Techniques: 여러 예시 데이터를 보간하여 새로운 데이터를 생성합니다.

• MixUp: 두 개 이상의 예시의 입력값과 레이블을 혼합하여 새로운 데이터를 생성하는 기법입니다.

• Mixed Sample Data Augmentation(MSDA): MSDA는 여러 샘플의 데이터를 혼합하여 새로운 샘플을 생성하는 데이터 증강 기법입니다. 이를 통해 데이터의 다양성을 증가시키고, 모델이 더욱 일반화된 성능을 보일 수 있도록 돕습니다. MixUp과 유사하게 여러 입력과 레이블을 혼합하여 학습 데이터를 생성함으로써, 모델이 다양한 데이터 조합에 대해 더 잘 대응하도록 합니다.

Model-Based Techniques: Seq2seq 모델이나 언어 모델을 사용해 데이터를 증강하는 방식입니다.

• Back-Translation (BT): 문장을 다른 언어로 번역한 후, 다시 원래 언어로 번역하여 새로운 데이터를 생성하는 방법입니다.

• Fine-Tuning GPT for Paraphrasing: GPT-3 등 대규모 생성 모델을 미세 조정하여 문장을 바꿔 쓰는 기법입니다. 이 방식은 대규모 언어 모델을 이용해 입력 문장을 다양한 방식으로 재구성하거나 의미를 유지하면서도 표현을 다양화하는 데 사용됩니다. 이를 통해 모델이 문장 표현의 다양성을 학습하고, 텍스트 생성이나 요약, 문장 유사도 측정과 같은 작업에서 더 나은 성능을 발휘할 수 있습니다.

1.3 데이터 필터링 (Data Filtering) vs. 데이터 클리닝 (Data Cleaning)

데이터 필터링과 데이터 클리닝은 데이터 품질을 개선하는 과정에서 각각 다른 목적과 역할을 수행합니다.

• 데이터 필터링: 데이터의 질을 높이기 위해 불필요하거나 부적절한 데이터를 제거하는 과정입니다. 병렬 말뭉치를 필터링하거나 특정 기준에 따라 데이터를 걸러내는 방식으로, 주로 데이터의 유효성과 일관성을 확보하는 데 초점을 둡니다. 예를 들어, 잘못된 번역이나 부적합한 문장을 제거하여 데이터의 품질을 높입니다.

• 데이터 클리닝: 데이터의 전처리 과정으로, 불용어 제거, 오탈자 수정, 중복 데이터 제거 등 데이터를 정제하여 품질을 향상시키는 작업입니다. 데이터 클리닝은 모델이 학습할 수 있도록 데이터를 정제하고 일관되게 만들어 사용하는 과정에 초점을 맞춥니다.

따라서 데이터 필터링은 데이터의 불필요한 부분을 제거해 데이터의 유효성과 일관성을 확보하는 데 중점을 두는 반면, 데이터 클리닝은 데이터를 정제하여 모델 학습에 적합한 상태로 만드는 데 중점을 둡니다.

병렬 말뭉치 필터링 (Parallel Corpus Filtering)

• 언어 감지 필터: 문장 쌍이 원하는 언어로 되어 있는지 확인합니다.
• 수용 가능성 필터: 문장 쌍의 내용이 서로 유사하여 의미적으로 수용 가능한지 확인합니다.
• 도메인 필터: 문장이 원하는 주제 범위 내에 있는지 확인하여, 범위를 벗어난(out-of-domain) 문장을 걸러냅니다.

1.4 합성 데이터 (Synthetic Data)

합성 데이터는 실제 크롤링, 크라우드소싱 등으로 수집한 데이터가 아닌 통계적, 전산학적 기법으로 생성한 데이터를 의미합니다. 최근에는 GPT-3와 같은 대규모 언어 모델을 이용해 생성된 합성 데이터가 많이 사용되고 있으며, 합성 데이터는 레이블링 비용을 줄이고 모델 학습에 필요한 데이터 양을 보충하는 데 유용합니다.

1.5 훈련 전략 (Training Strategies)

훈련 전략은 모델 학습의 효과를 높이기 위해 데이터를 처리하고 모델을 학습시키는 방법을 다룹니다. 대표적인 전략으로는 커리큘럼 학습(Curriculum Learning)이 있습니다. 커리큘럼 학습은 쉬운 내용부터 어려운 내용으로 단계적으로 모델을 학습시켜 모델의 학습 효율을 높이고 성능을 개선합니다. 이러한 전략은 모델이 점진적으로 더 복잡한 문제를 다룰 수 있도록 돕습니다.

2. 데이터 측정 (Data Measurement)

데이터의 품질을 측정하기 위해서는 Inter-Annotator Agreement(IAA)를 이용해 어노테이터 간 일관성을 평가합니다. 주요 메트릭으로 Cohen’s Kappa, Fleiss’ Kappa, Krippendorff’s Alpha가 사용됩니다. 이 지표들은 어노테이터들이 생성한 레이블이 얼마나 일관성 있는지를 수치화하여 데이터 품질을 평가하는 데 도움을 줍니다.

• Cohen’s Kappa: 두 명의 어노테이터 간 일치도를 평가합니다. 0.6 이상일 경우 높은 일치도를 나타냅니다.
• Fleiss’ Kappa: 세 명 이상의 어노테이터 간 일치도를 평가합니다. Cohen’s Kappa와 비슷한 기준으로 평가됩니다.
• Krippendorff’s Alpha: 다수의 어노테이터 간 일치도를 평가하며, 0.8 이상일 경우 신뢰할 수 있는 데이터로 판단합니다.

3. 인간-컴퓨터 상호작용 (HCI) 및 좋은 데이터의 특성

데이터의 품질은 AI 모델의 성능에 직접적인 영향을 미치며, 이를 위해 데이터 캐스케이드(Data Cascade)와 같은 개념이 중요합니다. 데이터 캐스케이드는 데이터의 품질 저하가 모델의 성능 저하로 이어지는 복합적인 문제를 의미합니다.

좋은 데이터의 특성은 다음과 같습니다:

• 일관성: 동일한 데이터가 일관성 있게 라벨링되어야 함
• 다양성: 예상치 못한 케이스를 포함한 데이터를 수집해야 함
• 적절한 크기: 모델 학습에 충분한 양의 데이터를 제공해야 함

좋은 데이터를 유지하기 위한 라이프사이클은 데이터의 구성, 수집, 전처리, 클리닝, 라벨링 등 여러 단계로 이루어지며, Datasheets for Datasets와 같은 체계적인 관리 방식을 도입해 데이터를 관리하는 것이 중요합니다.

References

• GPT3Mix:LeveragingLarge-scaleLanguageModelsforTextAugmentation(Yooetal.,2021
• “Everyonewantstodothemodelwork,notthedatawork”:DataCascadesinHigh-StakesAI(Nithyaetal.,2021)

규칙 기반 NLP는 언어 처리 작업을 위해 전문가가 직접 정의한 규칙을 이용해 시스템을 구성하는 방식입니다. 이 접근법은 언어학적 지식에 대한 깊은 이해를 바탕으로, 형태소 분석, 구문 분석, 의미 분석 등 다양한 언어 처리 작업을 수행합니다.

특징:

• 전문가 의존성: Task를 수행하기 위해서는 언어에 대한 깊은 전문 지식이 필요하며, 규칙을 구성하는 데 많은 시간이 소요됩니다.
• 기계 번역: 규칙기반 기계번역(Rule-Based Machine Translation) 시스템은 두 언어의 문법적, 어휘적 규칙을 바탕으로 번역을 수행합니다.

규칙 기반 NLP의 주요 한계는 새로운 언어적 변형에 대한 유연성이 떨어진다는 점입니다. 규칙을 모두 정의하기 어려운 복잡한 언어적 상황에서 한계가 명확하게 드러났습니다.

통계 기반 NLP (Statistical NLP) – 모두의 시대

통계 기반 NLP는 대규모 텍스트 데이터(빅데이터)를 이용해 언어를 모델링하는 방식입니다. 대량의 데이터를 활용해 단어 간의 동시 발생 빈도를 기반으로 언어의 의미를 추론합니다.

$$P(\text{is} | \text{An adorable little boy}) = \frac{\text{count(An adorable little boy is)}}{\text{count(An adorable little boy)}}$$

특징:

• 빅데이터 활용: 통계 기반 접근법은 "모두(군중)"가 무의식적으로 생성한 데이터를 활용하여 모델을 학습합니다.
• Sparsity 문제: 데이터의 부족으로 인해 모델링에 한계가 발생하는 'Sparsity Problem'이 주요 이슈로 등장했습니다.
• 전문가의 중요성 감소: 통계 기반 NLP는 규칙 기반 NLP에 비해 전문가의 중요성이 감소되었습니다.
• 더 많은 데이터 필요: 규칙 기반 접근법보다 더 많은 데이터가 필요합니다.
• 개발 용이성: 통계적 접근법은 규칙 기반 접근법에 비해 개발이 쉽고 빠릅니다.

Statistical Machine Translation (SMT): 두 언어의 평행 코퍼스(Parallel Corpus)를 이용해 번역을 수행하는 방식입니다. 단어 단위에서 시작해 구(Phrase) 단위로, 이후에는 구문 구조를 고려한 번역 방식으로 발전했습니다.

Statistical Machine Translation의 발전 과정

1. 단어 단위 번역: 초기에는 단어(word) 단위로 번역을 수행했습니다.
2. 구 단위 번역: 2003년에는 여러 개의 단어로 이루어진 구(Phrase) 단위로 번역하는 방식이 제안되었습니다.
3. Hierarchical Phrase-Based SMT: 구 내에 변수 개념을 도입한 Hierarchical Phrase-Based SMT 방식이 제안되었습니다. 예를 들어, "eat an apple -> 사과를 먹다" 대신 "eat X -> X"로 문장을 표현하여, X에 apple, banana 등 다양한 단어를 수용할 수 있는 유연성을 갖추게 되었습니다.
4. Prereordering-based SMT: 번역하기 전에 어순을 바꾸어 성능을 향상시키는 Prereordering-based SMT 방식이 도입되었습니다.
5. Syntax-Based SMT: Hierarchical Phrase-Based SMT에서 "eat X"를 "eat NP(명사구)"로 변경하여, 모든 구가 올 수 있는 것이 아닌 명사구만 올 수 있도록 한정하여 불필요한 번역 후보를 사전에 제거했습니다.

머신러닝 및 딥러닝 기반 NLP – 전문가와 군중의 공존

머신러닝 및 딥러닝 기반의 NLP는 규칙 기반 접근법과 달리 데이터로부터 직접 학습하는 방식입니다. 이 접근법은 데이터를 직접 전문적으로 생산하는 전문가의 역할과 우리 모두(군중)로 부터 생성되는 빅데이터의 결합을 통해 발전해 왔습니다.

특징:

• 데이터의 질과 양: 학습에 사용되는 데이터의 질과 양이 충분하다면, 인간의 능력을 초월할 수 있습니다. 예를 들어, 알파고와 이세돌의 대결에서 보듯이 딥러닝 모델은 새로운 방식의 문제 해결을 보여줄 수 있습니다.
• Neural Machine Translation (NMT): 신경망 기반 기계 번역은 SMT의 한계를 극복하고자 등장했으며, 번역 품질이 크게 향상되었습니다.

지도학습 데이터(전문가) vs 비지도학습 데이터(군중)

• 지도학습 데이터(Supervised Learning Approach):

  • 정답(레이블)을 필요로 하는 데이터
    • Named-Entity Recognition(NER), Relation Extraction(RE), Sentiment analysis 등
  • 데이터 구축에 시간 및 금전적 비용이 발생
  • 대량으로 구축하기 어려움
  • 대부분의 딥러닝 시스템 구축에는 지도학습 과정이 필요하며, 이를 위한 데이터 확보 방법에 대한 계획이 중요합니다.

• 비지도학습 데이터(Unsupervised Learning Approach):

  • 정답(레이블)이 필요하지 않은 데이터 (예: 입력과 출력이 동일한 Auto-Encoder 학습 방법)
  • 손쉽게 대량으로 구축할 수 있음. 이 후 대규모 말뭉치를 통해 언어모델을 학습 (빅데이터)

• 일부 예외적인 경우를 제외하고는 실제 사용 가능한 수준의 성능을 낼 수 있음
• 지도학습을 보완하여 성능을 더욱 향상시키는 방법으로 사용됨 (예: BERT, GPT-3와 같은 Pretrain 언어 모델)

Pre-training & Fine-tuning 기반 NLP – 대중과 전문가의 협력

Pre-training & Fine-tuning 접근법은 대규모 말뭉치를 사용해 사전 학습(Pre-training)한 후, 특정 작업에 맞게 미세 조정(Fine-tuning)하는 방식입니다. 이는 대중이 만든 데이터(Pre-train)와 전문가가 만든 데이터(Fine-tune)을 결합하여 하나의 고성능 모델을 만드는 방식입니다.

Transformer 모델

• Pre-training & Fine-tuning 기반 NLP 접근법의 핵심은 Transformer 아키텍처입니다. Transformer는 이후 다양한 변형 모델(BERT, GPT 등)의 기반이 되었으며, NLP 연구의 주요 트렌드로 자리 잡았습니다.

벤치마크의 등장

• Task-specific benchmark dataset의 대량 등장: 특정 작업에 맞춘 벤치마크 데이터셋들이 대량으로 등장했습니다.
• Leaderboard에서의 성능 경쟁: 다양한 모델들이 벤치마크 데이터셋을 활용해 성능을 경쟁하며, 리더보드에서의 순위를 겨루는 경쟁이 시작되었습니다.

Neural Symbolic NLP – 전문가의 데이터 활용

Neural Symbolic NLP는 딥러닝 모델의 한계를 보완하기 위해 상식 정보와 추론 능력을 도입한 방식입니다. 전문가의 데이터를 전면활용하여 구축한 지식 그래프(knowledge graph)를 이용해 추론을 수행하며, 딥러닝의 학습된 패턴과 결합해 더 나은 결과를 도출합니다.

• Knowledge Base(KB)에서의 정보(지식 그래프)를 바탕으로 질문에 대답하는 Knowledge Base Question Answering

대규모 언어 모델 (Large Language Models) – 모두의 시대

대규모 언어 모델(LLM)은 대량의 데이터를 바탕으로 학습된 거대한 신경망 모델입니다. 대표적인 예로 OpenAI의 GPT-3, Google의 PaLM 등이 있으며, 이들은 수많은 파라미터를 통해 다양한 언어 작업을 수행할 수 있습니다.

특징:

• 무의식적 데이터 생성: LLM은 대중이 생성한 방대한 데이터를 활용해 학습되며, 학습된 내용을 바탕으로 인간처럼 언어를 생성할 수 있습니다.
• Few-shot Learning: LLM은 적은 수의 예제만으로도 특정 작업을 수행할 수 있는 능력을 가지고 있습니다.

Foundation Models와 In-Context Few-Shot Learning & Prompt Engineering

• Foundation Models는 대규모 데이터로 학습된 범용 인공지능 모델을 의미합니다. 이 모델들은 다양한 Task에 걸쳐 활용될 수 있는 공통된 기반을 제공하며, NLP뿐만 아니라 컴퓨터 비전 등 여러 분야에서 사용됩니다. 대표적인 예로 BERT, GPT-3, PaLM 등이 있으며, 이들은 사전 학습(Pre-training) 과정을 거쳐 이후 특정 작업에 맞게 미세 조정(Fine-tuning)됩니다.

• In-Context Few-Shot Learning은 AI 모델이 새로운 작업을 학습할 때, 특정 작업에 대한 예제 몇 개를 "문맥 내(in-context)"에 제공함으로써 적은 데이터로 학습할 수 있는 능력을 의미합니다. 이 방법에서는 모델을 재훈련하지 않고도 입력 데이터에 포함된 예제들을 기반으로 모델이 주어진 작업을 수행할 수 있도록 합니다. 새로운 작업을 위한 몇 가지 예시를 Prompt와 함께 제공하여 모델이 그 패턴을 학습하여 이후 입력에 맞는 답변을 생성하는 방식입니다.

• Prompt Engineering은 대규모 언어 모델이 특정 작업을 수행하도록 유도하기 위해 입력 프롬프트를 설계하고 최적화하는 과정입니다. 이를 통해 모델이 적절한 답변을 생성하도록 하며, 학습된 내용을 최대한 효과적으로 활용할 수 있도록 돕습니다. 예를 들어, OpenAI의 GPT-3와 같은 모델은 주어진 프롬프트에 따라 다양한 형태의 언어 생성 작업을 수행할 수 있습니다.

즉, LLM(대형 언어 모델)과 같은 Foundation Models은 학습된 범용 지식을 바탕으로, In-Context Few-Shot Learning과 Prompt Engineering을 통해 재학습 없이도 특정 작업을 수행할 수 있도록 유도할 수 있습니다.

Human Feedback Data 기반 NLP – 의식적 데이터 생성

Human Feedback Data 기반 NLP는 모델이 더 나은 성능을 낼 수 있도록 인간이 직접 피드백을 제공하는 방식입니다. 대표적인 예로 ChatGPT가 있으며, 이는 인간의 피드백을 반영해 성능을 향상시킵니다.

Reinforcement Learning: 이러한 피드백 기반 접근법은 강화 학습(Reinforcement Learning)을 통해 모델의 성능을 지속적으로 개선합니다.

References

• OntheOpportunitiesandRisksofFoundationModels(Bommasanietal.,2021)
• ComplexKnowledgeBaseQuestionAnswering:ASurvey(Lanetal.,2021)

1.1 혐오 발언 탐지 (Hate Speech Detection)

혐오 발언(Hate Speech)은 인종, 성별, 성적 지향, 종교 등 개인의 특성을 바탕으로 특정 집단이나 개인을 비하하거나 공격하는 언어를 의미합니다. 이러한 혐오 발언은 인터넷상에서 다양한 형태로 퍼지며, 이를 방지하기 위해 자동화된 혐오 발언 탐지 모델이 요구됩니다. 혐오 발언 탐지 모델은 학습된 데이터를 기반으로 혐오적 또는 공격적인 언어와 그렇지 않은 언어를 자동으로 분류하며, 이를 통해 인터넷에서의 부정적인 대화를 줄이는 데 기여합니다.

• 대표적인 데이터셋: HateXplain HateXplain은 설명 가능한 혐오 발언 탐지를 위해 개발된 데이터셋으로, 각 게시물에 대해 다음 세 가지 정보를 제공합니다: (1) 혐오/공격/일반으로의 3분류, (2) 혐오 발언의 타깃이 되는 커뮤니티 식별, (3) 해당 발언이 특정 라벨을 가지게 된 근거를 제공하는 부분. 이러한 데이터셋은 혐오 발언 탐지의 투명성을 높이고 모델이 어떻게 결정을 내리는지 이해할 수 있도록 돕습니다.

1.2 반대 발언 생성 (Counter Speech Generation)

Counter Speech Generation은 혐오 발언에 대해 사실 기반의 반박 발언을 생성하여 발화자의 인식을 교정하고 혐오 발언을 억제하려는 작업입니다. 이 작업은 혐오 발언에 대한 대화형 대응을 자동화하여, 사람들에게 혐오 발언의 문제점을 깨닫게 하고 대화의 건전성을 유지하려는 목적을 가지고 있습니다.

• 대표적인 방법론: Generate, Prune, Select 이 방법론은 혐오 발언에 대한 반박을 생성하는 파이프라인을 제시합니다. 먼저 혐오 발언에 대해 다양한 반박 발언을 생성(Generate)하고, 불필요하거나 덜 효과적인 발언을 제거(Prune)한 후, 가장 적절한 반박을 선택(Select)합니다. 이를 통해 모델이 신뢰성 있고 설득력 있는 발화를 하도록 돕습니다.

• 대표적인 데이터셋: ProsocialDialog ProsocialDialog는 대화 시스템이 사회 규범을 준수하면서 비윤리적이거나 편향된 발화에 대응할 수 있도록 돕는 데이터셋입니다. 이를 통해 모델이 다양한 부적절한 발언에 적절히 대응하고 대화 상대를 설득하거나 교화하는 데 도움을 줍니다.

1.3 풍자 탐지 (Sarcasm Detection)

Sarcasm Detection은 텍스트에서 풍자적 의미나 반어법을 감지하고 인식하는 작업입니다. 인간은 일상 대화에서 종종 비꼬거나 반어법을 사용하여 의도를 전달합니다. 이러한 언어는 텍스트의 표면적인 의미와 실제 의도가 다르기 때문에 인공지능 모델이 이해하기 어렵습니다. 풍자 탐지는 특히 소셜 미디어나 온라인 커뮤니티에서의 대화 내용을 정확히 이해하는 데 필수적입니다.

• 대표적인 데이터셋: iSarcasm iSarcasm 데이터셋은 풍자적 발언을 포함한 트윗 데이터를 수집하여, 각 트윗이 풍자를 포함하는지 여부를 라벨링하고, 풍자의 유형(예: 아이러니, 과장 등)을 제공합니다. 이 데이터셋을 통해 모델은 풍자적 표현을 학습하고, 텍스트 내에서의 풍자 여부를 더 잘 파악할 수 있습니다.

2. 기만 감지 (Deception Detection)

2.1 가짜 뉴스 탐지 (Fake News Detection)

Fake News Detection은 인터넷에서 유포되는 허위 정보를 식별하고 분류하는 작업입니다. 가짜 뉴스는 일반적으로 극적인 제목과 과장된 내용을 포함하며, 이러한 정보를 걸러내기 위해 Fake News Detection 모델이 필요합니다. 이 작업은 SNS와 같은 인터넷 플랫폼에서 신뢰할 수 있는 정보만이 유통되도록 보장하는 데 중요한 역할을 합니다.

• 대표적인 데이터셋: LIAR LIAR는 ACL 2017에서 발표된 데이터셋으로, 다양한 종류의 뉴스 기사의 진실 여부를 평가하기 위해 사용됩니다. 이 데이터셋은 각 뉴스 기사에 대해 그 신뢰도를 판단할 수 있는 다양한 주석(annotation)을 제공합니다.

2.2 사실 확인 (Fact Checking)

Fact Checking은 주어진 정보의 진실성을 검토하여 허위 정보를 바로잡는 작업입니다. 가짜 뉴스의 확산을 막기 위해서는 사실 확인이 필수적이며, 이를 통해 사용자는 신뢰할 수 있는 정보를 얻게 됩니다.

• 대표적인 데이터셋: FEVER FEVER는 대규모 사실 검증을 위한 데이터셋으로, 뉴스 기사나 텍스트의 진실 여부를 확인하기 위해 구축되었습니다. 이 데이터셋은 수많은 문장에 대한 진실성 평가를 제공하여, 모델이 다양한 문맥에서의 진실 여부를 판단할 수 있도록 돕습니다.

3. 기계 번역 (Machine Translation)

3.1 품질 예측 (Quality Estimation)

Quality Estimation(QE)은 기계 번역(MT)의 품질을 예측하는 작업입니다. 번역된 문장이 원문의 의미를 얼마나 정확하고 자연스럽게 전달하는지를 평가하는 것이 목적입니다. 번역 품질을 평가하는 모델은 기계 번역 시스템이 생성한 결과물의 오류를 예측하고, 이를 개선할 수 있도록 돕습니다.

• 대표적인 데이터셋: QUAK QUAK은 한국어와 영어 간의 기계 번역 품질을 평가하기 위한 데이터셋입니다. 이 데이터셋은 번역된 문장이 얼마나 원문과 잘 맞아떨어지는지를 평가하며, 번역 시스템의 품질 개선에 기여합니다.

3.2 자동 후편집 (Automatic Post Editing)

Automatic Post Editing(APE)은 기계 번역의 결과물에서 발생하는 오류를 자동으로 수정하는 작업입니다. 이는 번역의 문법적 오류, 어휘 선택의 부정확성, 의미의 일관성 부족 등을 수정하여 번역 품질을 높이는 데 기여합니다.

• 대표적인 데이터셋: SubEdits SubEdits는 APE 작업을 위해 설계된 데이터셋으로, 번역된 문장들에서의 일반적인 오류를 수정하는 방법을 제공합니다. 이 데이터셋을 통해 기계 번역 시스템은 더 높은 품질의 번역 결과를 제공할 수 있습니다.

4. 대화 관련 작업 (Dialogue)

4.1 Persona-grounded Dialogue

Persona-grounded Dialogue는 대화 참여자의 개인적인 특성, 즉 직업, 성격, 취미 등을 반영하여 대화를 생성하는 작업입니다. 기존의 대화 시스템은 대화의 내용이나 주제만을 고려하는 반면, Persona-grounded Dialogue는 대화 상대의 개인적 정보를 고려하여 더 자연스럽고 인간적인 대화를 가능하게 합니다.

• 대표적인 데이터셋: PersonaChat PersonaChat은 각 대화 참여자에게 고유의 "Persona"를 부여하여, 모델이 대화 상대의 성격이나 취향을 반영한 대화를 생성할 수 있도록 돕습니다. 이를 통해 인간과 비슷한 대화 경험을 제공하는 것이 가능합니다.
• 대표적인 데이터셋: BSBT BSBT(BotsTalk)는 자동화된 대규모 다기능 대화 데이터셋 수집을 위한 머신 소스 프레임워크입니다. 이 데이터셋은 다양한 대화 기술을 통합하여 대화 시스템이 여러 상황에서 적절한 반응을 생성할 수 있도록 돕습니다. BSBT는 대화의 다양성과 질을 높이는 데 중요한 역할을 하며, 특히 여러 대화 기술을 동시에 테스트하고 평가하는 데 유용합니다.

4.2 설득 대화 (Persuasive Dialogue)

Persuasive Dialogue는 상대방을 설득하기 위한 목적의 대화를 의미합니다. 이러한 대화는 광고, 마케팅, 정치, 교육 등 다양한 분야에서 사용될 수 있으며, 대화 시스템이 상대방을 설득하고 자신의 주장을 전달하기 위해 응답 발화를 생성하는 것이 목표입니다. 설득 대화는 대화 시스템의 상호작용 능력을 높이고, 대화 상대에게 더욱 설득력 있는 정보를 전달하는 데 유용합니다.

• 대표적인 데이터셋: Persuasion for Good (P4G) P4G 데이터셋은 주어진 상황에서 대화 모델이 사용자를 설득하는 능력을 평가하기 위한 다양한 작업(Task)을 포함하고 있습니다. 예를 들어, 사용자가 건강 목표를 달성하도록 설득하거나 환경 보호를 위해 재활용을 독려하는 등 여러 설득 작업을 포함합니다. 이 데이터셋은 대화 시스템이 사람들에게 긍정적인 영향을 미칠 수 있도록 설득력 있는 대화를 생성하는 데 도움을 줍니다.

4.3 대화 요약 (Dialogue Summarization)

Dialogue Summarization은 대화의 기록이나 대화 데이터를 요약하는 작업입니다. 이는 긴 대화 내용을 간결하게 정리하여 중요한 정보만을 제공하는 데 목적이 있습니다. 대화 요약 기술은 고객 상담, 의료 기록, 회의록 등 대화의 효율성을 높이고 중요한 내용을 빠르게 파악해야 하는 다양한 분야에서 사용됩니다. 이러한 작업은 대화 데이터를 처리하고 분석하는 데 있어 매우 유용하며, 챗봇의 long-term memory를 향상시키기 위해서도 활용될 수 있습니다.

• 대표적인 데이터셋: DialogSum, SAMSum DialogSum 데이터셋은 일상적인 대화 시나리오를 기반으로 하여 대화 내용을 요약하는 데 사용됩니다. SAMSum 데이터셋은 사람에 의해 주석이 달린 대화 데이터셋으로, 추상적인 요약을 위해 사용됩니다. 이러한 데이터셋은 모델이 대화 내용을 효과적으로 요약하고, 중요한 정보를 추출하는 능력을 향상시키는 데 도움을 줍니다.

4.4 지식 기반 대화 (Knowledge-grounded Dialogue)

Knowledge-grounded Dialogue는 외부 지식을 활용하여 대화를 진행하는 작업입니다. 기존의 사전 학습된 모델이 가지고 있는 일반적인 지식 외에도, 대화 중 특정 도메인이나 주제에 관한 추가적인 정보를 바탕으로 대화를 이어나가게 됩니다. 이를 통해 대화의 정확성과 관련성을 높일 수 있으며, 사용자가 질문하는 특정 주제에 대해 더 깊이 있는 답변을 제공할 수 있습니다. Knowledge-grounded Dialogue는 정보 제공형 챗봇, 고객 지원 시스템, 교육용 대화 에이전트 등에 활용될 수 있습니다.

• 대표적인 데이터셋: Wizard of Wikipedia Wizard of Wikipedia 데이터셋은 대화 모델이 특정 주제에 대해 심도 있는 대화를 할 수 있도록 위키피디아의 지식을 바탕으로 구축된 데이터셋입니다. 이 데이터셋은 대화 중 다양한 주제에 대한 지식을 참조하여 대화의 질과 정보의 정확성을 향상시키는 데 도움을 줍니다.

• 대표적인 데이터셋: Wizard of Internet Wizard of Internet 데이터셋은 인터넷에서 얻은 최신 정보를 바탕으로 대화를 진행하도록 설계된 데이터셋입니다. 이 데이터셋을 사용하여 모델은 최신 뉴스나 트렌드에 대한 정보까지 반영한 대화를 생성할 수 있습니다.

4.5 캐릭터 대화 (Dialogue for Characters)

Dialogue for Characters는 스토리나 특정 컨텍스트 내에서 캐릭터의 특성, 관계, 감정을 반영한 대화를 생성하는 작업입니다. 각 대화 세션에는 캐릭터의 속성이나 그들 간의 관계 같은 풍부한 컨텍스트 정보가 제공되며, 이를 통해 대화 모델은 이야기 속 캐릭터의 성격과 상황에 맞는 대화를 생성할 수 있습니다. 이러한 기술은 소설, 영화, 게임 등의 미디어에서 캐릭터 간의 자연스러운 상호작용을 만들어내는 데 활용됩니다.

• 대표적인 데이터셋: Harry Potter Dialogue (HPD) Harry Potter Dialogue 데이터셋은 '해리 포터' 시리즈에 등장하는 캐릭터들 간의 대화를 기반으로 하여 구축되었습니다. 이 데이터셋을 통해 모델은 각 캐릭터의 독특한 성격과 대화 스타일을 학습하고, 이야기 속에서 캐릭터들이 자연스럽게 상호작용할 수 있는 대화를 생성할 수 있습니다.

4.6 공감 대화 (Empathetic Dialogue)

Empathetic Dialogue는 대화 상대방의 감정을 인지하고 공감하는 반응을 생성하는 작업입니다. 인간은 일상 대화에서 상대방의 감정을 이해하고 이에 맞게 반응하는 경향이 있으며, 이러한 공감 능력은 대화 시스템에도 중요하게 적용됩니다. 공감 대화 모델은 사용자의 감정을 이해하고 이에 적절하게 반응함으로써 더 나은 상호작용을 제공합니다.

• 대표적인 데이터셋: EmpatheticDialogues EmpatheticDialogues 데이터셋은 대화 참여자의 감정 상태에 따라 공감적 반응을 생성하도록 학습된 데이터셋입니다. 이 데이터셋을 사용한 대화 시스템은 더 감정적으로 민감한 반응을 생성할 수 있습니다.

5. 기타 특이한 Task 및 데이터

5.1 ImageNet-X

ImageNet-X는 컴퓨터 비전 분야에서 널리 사용되는 데이터셋인 ImageNet을 확장한 데이터셋으로, 실제 환경에서 발생하는 다양한 왜곡 요소(예: 회전, 크기 변화, 노이즈, 블러 등)를 추가하여 구축되었습니다. 이를 통해 이미지 분류 모델의 강인성과 일반화 능력을 평가할 수 있습니다. ImageNet-X는 이미지 분류 모델이 현실 세계에서 발생하는 다양한 왜곡에 강하게 대처할 수 있는지를 평가하기 위해 사용됩니다.

5.2 Question Generation

Question Generation은 주어진 텍스트와 목표 답변을 바탕으로 유효하고 유창한 질문을 자동으로 생성하는 작업입니다. 이 작업은 특히 교육 분야에서 학생들의 이해도를 높이거나 질문 응답(QA) 시스템에서 사용자와의 상호작용을 풍부하게 만드는 데 중요합니다. Question Generation은 사용자가 텍스트를 더 잘 이해할 수 있도록 돕고, 자연어 이해(NLU) 모델의 성능을 향상시키는 역할도 합니다.

5.3 Document-level Relation Extraction

Document-level Relation Extraction은 문서 전체에서 개체(Entity)와 그들 간의 관계를 추출하는 작업입니다. 예를 들어, 긴 텍스트에서 "Barack Obama was born in Honolulu, Hawaii."라는 문장이 포함되어 있을 때, 이 문장은 "Barack Obama"와 "Honolulu" 간의 관계인 "born in"을 나타냅니다. 문서 수준의 관계 추출은 문장 수준의 관계 추출보다 더 넓은 범위의 정보를 다룰 수 있으며, 의료나 법률과 같은 특정 도메인에서의 관계를 식별하고 지식 그래프를 구축하는 데 유용합니다.

6. 한국어 관련 특이한 작업 및 데이터

6.1 혐오 발언 탐지

한국어에서도 혐오 발언 탐지를 위한 다양한 데이터셋이 존재합니다. 이러한 데이터셋은 한국어로 작성된 혐오 발언을 탐지하여, 인터넷 환경의 안전성을 확보하는 데 기여합니다.

• 대표적인 데이터셋: BEEP! BEEP! 데이터셋은 한국어 뉴스 댓글에서 혐오 발언을 탐지하기 위한 데이터셋으로, 온라인 커뮤니티에서의 유해한 발언을 효과적으로 탐지하고 필터링할 수 있도록 돕습니다.

• KOLD: Korean Offensive Language Dataset KOLD는 한국어에서의 공격적 언어를 탐지하기 위해 구축된 데이터셋입니다. 이 데이터셋은 다양한 형태의 한국어 공격적 발언을 학습하여 이를 탐지하는 모델을 훈련하는 데 사용됩니다.

• 대표적인 데이터셋: APEACH APEACH는 한국어 혐오 발언 탐지를 위한 데이터셋으로, 카카오에서 제공하는 한국어 SNS 데이터에서 수집된 공격적 언어와 혐오 발언을 포함하고 있습니다. 이 데이터셋은 다양한 형태의 한국어 공격적 발언을 학습하여 혐오 발언을 효과적으로 탐지하는 모델을 구축하는 데 사용됩니다.

6.2 고전 한국어 번역 및 이해

한국어 관련 특이한 작업 중 하나로 고전 한국어 문서를 현대 한국어나 영어로 번역하는 작업이 있습니다. 이러한 작업은 역사적 기록을 현대적으로 해석하고 보존하는 데 중요한 역할을 합니다.

• 대표적인 데이터셋: HUE HUE는 조선왕조실록과 일성록 같은 고전 문서를 번역하고 해석하기 위한 데이터셋입니다. 이 데이터셋을 사용하여 고전 문서의 내용을 현대적으로 해석하거나 외국어로 번역할 수 있습니다.

국내 NLP 데이터 구축 프로젝트는 크게 국가 기관 주도, 기업 주도, 개인 및 학계 주도로 나뉩니다. 각 주체가 기여한 주요 프로젝트들을 상세히 살펴보겠습니다.

1.1 국가 기관 주도

1.1.1 21세기 세종 계획 (1997-2007, 국립국어원)

21세기 세종 계획은 현대 국어, 역사 자료, 북한어 등 다양한 분야의 말뭉치 2억 어절을 구축한 대규모 국어 정보화 프로젝트입니다. 이 계획은 한국어의 디지털화와 NLP 연구를 위한 기초 데이터를 제공하기 위해 1997년부터 2007년까지 진행되었습니다. 주요 성과로는 다음과 같은 내용이 포함됩니다:

• 현대 국어와 역사 자료 구축: 총 2억 어절에 달하는 방대한 양의 데이터가 XML 형식으로 구축되어 국어 정보나눔터를 통해 공개되었습니다. 이는 한국어의 기초 자료로 활용되었으며, 이후 DVD로도 배포되었습니다.
• 언어 규범 및 검색 시스템 개발: 맞춤법, 표준어 규정, 외래어/로마자 표기법 등의 검색 시스템이 개발되어 국어 어휘의 역사적 발전과 남북한 방언 비교 연구에 활용되었습니다.
• 전자사전 개발: 체언, 용언, 고유명사 등 약 57만 항목을 구축한 전자사전이 포함되어 있으며, 지능형 형태소 분석기 등의 활용 도구도 개발되었습니다.

1.1.2 KAIST Corpus (1997-2005, KAIST)

KAIST는 1997년부터 2005년까지 순차적으로 한국어와 다국어 코퍼스를 공개하였습니다. 이 데이터셋은 Semantic Web Research Center를 통해 제공되었으며, 한국어와 다양한 언어 간의 비교 연구 및 멀티모달 언어 데이터 연구를 위해 활용되었습니다.

1.1.3 엑소브레인 (2013-2023, ETRI)

엑소브레인 프로젝트는 한국전자통신연구원(ETRI)에서 진행한 프로젝트로, 언어를 이해하고 지식을 학습하여 전문가 수준의 지식을 서비스하는 언어 지능 소프트웨어(SW)를 개발하기 위한 목표를 가지고 있습니다. 프로젝트는 3단계로 나누어 진행되었습니다:

• 1단계: 일반 분야 대상 분석형 엑소브레인 SW 기반 기술 개발
• 2단계: 전문 분야 대상 응용 기술 개발
• 3단계: 설명 가능한 심층 질의응답 엑소브레인 SW 상용화 기술 개발

엑소브레인은 AI API 형태로 공개되어 NLP 연구자들에게 큰 도움이 되고 있습니다.

1.1.4 모두의 말뭉치 (2016~, 국립국어원)

모두의 말뭉치는 인공지능의 한국어 처리 능력 향상을 위한 한국어 학습 자료 공개 플랫폼입니다. 기존 21세기 세종 계획에 비해 일상 대화, 메신저, 웹 문서 등 구어체 자료의 비중을 높였습니다. 다층위 주석이 포함된 말뭉치를 제공하며, 형태, 구문, 어휘 의미, 의미역, 개체명, 상호 참조 등의 다양한 주석을 JSON 형식으로 포함하고 있습니다.

1.1.5 우리말샘 (2016~, 국립국어원)

우리말샘은 누구나 자유롭게 제작하고 이용할 수 있는 국어사전 프로젝트입니다. 오픈 API를 제공하며, GitHub에서 관련 코드를 활용하여 다양한 응용 프로그램에서 국어 데이터를 사용할 수 있습니다.

1.1.6 AI 허브 (2016~, NIA)

AI 허브는 한국정보화진흥원(NIA)에서 운영하는 플랫폼으로, AI 기술 및 제품 개발에 필요한 다양한 데이터를 제공하는 역할을 합니다. AI 허브는 이미지, 음성, 언어, 헬스케어 등 여러 분야에 걸쳐 다양한 데이터셋을 제공하며, 특히 한국어 처리 능력을 향상시키기 위한 대규모 언어 데이터도 포함하고 있습니다. JSON, 엑셀 등 다양한 형식으로 데이터를 제공하며, 실제 산업계의 수요를 반영한 자원을 구축하여 AI 연구자와 기업들이 쉽게 접근하고 활용할 수 있도록 하고 있습니다.

1.2 기업 주도

1.2.1 KorQuAD (2019, LG CNS)

KorQuAD는 스탠포드 대학교의 SQuAD를 벤치마킹하여 개발된 한국어 기계 독해(Machine Reading Comprehension) 데이터셋입니다. KorQuAD 1.0은 약 7만 쌍의 질의응답 데이터를 포함하고 있으며, 2.0 버전은 이보다 확장된 10만 쌍 이상의 데이터를 포함합니다. 이는 웹 문서 기반의 질의응답 모델 학습에 필수적인 자원을 제공합니다.

1.2.2 KLUE (2021~, Upstage)

KLUE(Korean Language Understanding Evaluation)는 한국어 이해 능력을 평가하기 위한 벤치마크 데이터셋입니다. 주요 Task는 다음과 같습니다:

• 주제 분류 (Topic Classification): 뉴스 헤드라인을 정치, 경제, 사회 등으로 분류합니다.
• 의존 구문 분석 (Dependency Parsing): 문장 내의 단어들 간의 의존 관계를 분석합니다.
• 자연어 추론 (Natural Language Inference, NLI): 두 문장의 유사도를 평가하여 참, 거짓, 중립을 결정합니다.
• 개체명 인식 (Named Entity Recognition, NER): 문장에서 사람, 장소, 단체의 이름 등 개체명을 추출합니다.

1.2.3 KorNLI & KorSTS (2020, Kakao Brain)

KorNLI와 KorSTS는 카카오브레인에서 개발한 한국어 자연어 추론(NLI)과 문장 의미 유사도(STS) 벤치마크 데이터셋입니다.

• KorNLI: 영어로 된 자연어 추론 데이터셋을 기계 번역하여 한국어로 공개한 것으로, 주어진 전제와 가설 간의 관계를 판단합니다. 관계는 참(entailment), 중립(neutral), 거짓(contradiction) 중 하나로 결정됩니다.
• KorSTS: 문장 간의 의미적 유사성을 평가하기 위한 데이터셋으로, 영어 STS 데이터를 한국어로 번역하여 제작되었습니다. 이 데이터는 문장 쌍의 유사도를 0에서 5까지 점수로 평가합니다.

1.2.4 KOBEST (2022, SKT)

KOBEST는 한국어 이해 능력 평가를 위한 벤치마크로, 다양한 Task를 포함하고 있습니다.

• KoBEST-BoolQ: 주어진 문단을 바탕으로 질문이 참인지 거짓인지 판단하는 Task입니다.
• KoBEST-COPA: 주어진 전제에 대한 원인이나 결과를 선택하는 Task입니다.
• KoBEST-WiC: 두 문맥에서 동일한 단어가 같은 의미로 사용되는지 판별하는 Task입니다.
• KoBEST-HellaSwag: 주어진 문맥 뒤에 나타날 문장을 선택하는 Task입니다.
• KoBEST-SentiNeg: 부정문의 polarity(긍정/부정)를 예측하는 Task입니다.

1.3 개인 및 학계 주도

1.3.1 NSMC (2016, 개인)

NSMC(Naver Sentiment Movie Corpus)는 네이버 영화에서 크롤링한 리뷰 데이터를 기반으로 제작된 감정 분석 데이터셋입니다. 데이터는 긍정과 부정을 라벨로 제공하며, 감성 분석 연구에 많이 활용됩니다. 이 데이터셋은 한국어 텍스트 감성 분석 모델의 학습 및 평가에 중요한 역할을 하고 있습니다.

1.3.2 Korean Hate Speech - BEEP (2020, 개인)

Korean Hate Speech - BEEP 데이터셋은 한국 연예 뉴스 플랫폼의 댓글을 수집하여 구축된 혐오 표현 데이터셋입니다. 라벨이 지정된 버전과 그렇지 않은 버전이 있으며, 혐오 표현, 성별 편향, 공격성 등 다양한 요소를 분석할 수 있도록 데이터가 구성되어 있습니다.

1.3.3 KorLex (부산대학교)

KorLex는 WordNet의 구조를 한국어로 확장한 데이터베이스로, 부산대학교 권혁철 교수와 윤애선 교수가 주도하여 개발했습니다. WordNet과 유사하게 단어를 유의어 집단으로 분류하며, 각 단어들 간의 다양한 의미 관계를 기록하여 NLP 연구에 유용한 자원을 제공합니다.

2. 해외 NLP Benchmark 데이터 소개

해외에서도 다양한 NLP 벤치마크 데이터셋이 개발되어 연구에 활용되고 있습니다. 데이터셋은 Natural Language Understanding (NLU), Natural Language Generation (NLG), 그리고 NLU + NLG를 모두 포함하는 데이터셋으로 나뉩니다.

2.1 Natural Language Understanding (NLU)

2.1.1 SNLI (Stanford Natural Language Inference)

SNLI는 주어진 문장들의 관계를 **모순 (contradiction), 중립 (neutral), 함의 (entailment)**로 구분하는 데이터셋으로, 자연어 추론 모델의 학습 및 평가에 사용됩니다.

2.1.2 CoNLL-2003 Named Entity Recognition (NER)

CoNLL-2003 NER 데이터셋은 영어와 독일어로 구성된 개체명 인식 데이터셋으로, 사람, 장소, 단체 등의 이름을 추출하는 Task를 수행하기 위해 사용됩니다.

2.1.3 TACRED (Relation Extraction)

TACRED는 문장의 주어(subject, head entity)와 목적어(object, tail entity) 사이의 관계를 추출하는 Task를 위한 데이터셋으로, 뉴스 및 웹 포럼 문서에서 추출된 문장들을 활용하여 구성되었습니다.

2.2 Natural Language Generation (NLG)

2.2.1 WMT (Workshop on Machine Translation)

WMT는 2014년부터 매년 개최된 기계 번역 학회에서 공개한 다국어 번역 데이터셋으로, 뉴스, 바이오, 멀티모달 데이터 등 다양한 분야의 병렬 말뭉치로 구성되어 있습니다.

2.2.2 CNN/Daily Mail (Text Summarization)

CNN/Daily Mail 데이터셋은 뉴스 기사와 해당 기사의 요약문이 쌍을 이루는 데이터셋으로, 문서 요약 모델 학습에 사용됩니다. 약 28만 건의 학습 데이터와 1만여 건의 검증 및 평가 데이터로 구성되어 있습니다.\

2.2.3 SQuAD (Stanford Question Answering Dataset)

SQuAD는 스탠포드 대학교에서 개발한 기계 독해(Machine Reading Comprehension) 벤치마크 데이터셋입니다. 문서에서 특정 질문에 대한 답을 찾는 Task로 구성되어 있으며, 이는 자연어 이해와 질의응답 시스템의 학습 및 평가에 널리 사용됩니다. SQuAD 1.1은 약 10만 개의 질의응답 쌍으로 구성되어 있으며, SQuAD 2.0은 이를 확장하여 일부 질문에는 답변이 없는 경우도 포함하여 모델이 답이 없는 질문도 구분할 수 있도록 했습니다.

2.2.4 GLUE (General Language Understanding Evaluation)

GLUE는 다양한 자연어 이해 Task를 포함하는 벤치마크 데이터셋으로, 자연어 추론, 문장 유사도, 텍스트 분류 등의 과제를 포함하고 있습니다. 이는 자연어 처리 모델의 일반적인 이해 능력을 평가하기 위한 표준 벤치마크로 사용됩니다. GLUE는 이후 SuperGLUE로 확장되어 더 어려운 Task를 포함하게 되었으며, 최신 모델의 성능을 평가하는 데 활용되고 있습니다.

2.2.5 Big Bench (BIG-bench)

Big Bench는 대규모 언어 모델의 능력을 평가하기 위해 다양한 자연어 처리(NLP) 과제를 포함한 벤치마크입니다. 연구자와 엔지니어들이 협력하여 200개 이상의 Task를 개발하였으며, 일반적인 자연어 이해뿐만 아니라 창의성, 논리적 사고, 수학적 추론 등 다양한 능력을 측정하는 과제를 포함하고 있습니다. 이는 언어 모델이 인간과 유사한 수준의 이해와 문제 해결 능력을 갖추었는지 평가하는 데 사용됩니다.

2.2.6 MMLU (Massive Multitask Language Understanding)

MMLU는 대규모 멀티태스크 언어 이해 벤치마크로, 다양한 학문 분야와 수준의 57개 과제를 포함하고 있습니다. 이 데이터셋은 역사, 과학, 수학, 경제학, 의학 등 여러 주제에 걸쳐 언어 모델의 능력을 평가합니다. 특히, 인간의 지식 수준에 근접한 성과를 내는지를 평가하는 데 중점을 두고 있어, 모델의 전반적인 이해 능력을 측정하는 데 중요한 역할을 하고 있습니다.

2.3 NLU + NLG

2.3.1 Wizard-of-Oz Dialogue System

Wizard-of-Oz 데이터셋은 대화 시스템의 데이터를 수집하기 위해 고안된 방식으로, 사용자가 AI 시스템과 대화하는 것처럼 유도하여 데이터를 수집합니다. 이 방식은 대화 상태 추적(Dialogue State Tracking) 연구에 많이 사용됩니다.

2.3.2 DSTC (Dialog System Technology Challenges)

DSTC는 대화 시스템의 성능을 평가하기 위한 챌린지로, 버스 시간표, 레스토랑 정보, 관광 정보 등 다양한 도메인의 대화 데이터를 포함합니다. DSTC1부터 DSTC10까지 다양한 주제로 진행되고 있습니다.

3. 다국어 벤치마크 데이터

다국어 벤치마크 데이터는 Low Resource 언어부터 High Resource 언어까지 다양한 언어를 대상으로 합니다. 이들 데이터셋은 다국어 언어 모델의 성능을 높이는 데 중요한 역할을 하고 있습니다.

3.1 LASER (2019)

LASER는 50개 언어를 대상으로 한 문장 표현(embedding) 생성 프로젝트로, 다국어 연구의 기반이 되는 데이터셋을 제공합니다. 2022년에는 200개의 언어로 확장되었습니다.

3.2 M2M-100 (2020)

M2M-100은 영어에 의존하지 않는 최초의 다국어 기계 번역 모델로, 2200개의 언어 쌍을 지원합니다. 이는 영어 이외의 언어 간 번역 성능을 대폭 개선하였습니다.

3.3 Flores-101 & Flores-200

Flores-101은 Low Resource 언어 간의 기계 번역 성능을 평가하기 위한 데이터셋으로, 101개 언어를 포함하고 있습니다. Flores-200은 이를 200개 언어로 확장하여 더 많은 언어 쌍에 대한 번역 성능을 평가할 수 있도록 했습니다.

3.4 NLLB (No Language Left Behind, 2022)

NLLB 프로젝트는 Low Resource 언어의 번역 성능을 개선하여 정보 접근성을 높이고 디지털 격차를 해소하기 위한 목표로 진행되었습니다. 200개 이상의 언어를 지원하는 모델과 데이터셋이 공개되었으며, 다양한 언어 간의 번역 성능 향상에 기여하고 있습니다.

개요

DMOps는 데이터 관리 작업과 절차(Data Management Operation and Recipes)를 의미합니다. AI 모델의 성능을 높이기 위해 데이터셋의 품질을 유지하고 관리하는 일련의 단계로 구성됩니다.

주요 목적

• NLP 데이터 제작의 중요성: 고품질의 데이터셋을 통해 AI 모델의 신뢰성과 일관성을 유지하며, 서비스 요구 사항을 충족하도록 설계된 데이터 관리 절차를 제안합니다.
• 효율적 가이드라인 제공: 데이터 관리의 모든 과정을 체계적으로 설명하고 실행할 수 있도록 단계별 지침을 제공합니다.

데이터 구축 및 관리 절차

데이터 구축을 위한 단계

1. 프로젝트 목표 설정:

   • 데이터 구축의 목적과 요구 사항을 이해하고, 해당 프로젝트에 필요한 데이터의 종류와 분량을 정의합니다.

2. 원시 데이터 확보:

   • 크롤링, 공공 데이터 활용, 크라우드소싱 등 다양한 출처에서 원시 데이터를 수집합니다.
   • 데이터 수집 시, 개인정보와 법적 제약사항을 준수합니다.
   • 원시 데이터 수집 시 고려해야 할 주요 사항

   1. 신뢰성: 신뢰할 수 있는 출처에서 데이터를 수집해야 합니다. 신뢰성 높은 데이터를 확보함으로써 AI 모델이 정확하고 일관된 학습을 할 수 있도록 돕습니다.

   2. 다양성: 데이터의 다양성을 확보하여 AI 모델이 여러 경우에 대해 일반화할 수 있도록 합니다. 특정 환경이나 조건에 편중되지 않도록 다양한 출처, 상황, 인구 그룹 등의 데이터를 포함하는 것이 중요합니다. 수집된 데이터는 실제 세상의 특성과 변동성을 반영해야 합니다. 이를 통해 AI 모델이 다양한 상황을 처리할 수 있는 유연성을 갖출 수 있습니다.

   3. 획득 가능성: 데이터가 쉽게 획득되고 가공할 수 있는지를 고려합니다. 이는 수집 및 처리에 필요한 시간과 비용을 줄이는 데 중요합니다.

4. 법적 및 제도적 준수: 개인정보가 포함된 데이터를 수집할 때는 법적 요구 사항을 준수해야 하며, 필요한 경우 데이터 수집과 활용에 대한 동의를 받아야 합니다.

3. 데이터 전처리:

   • 데이터의 품질을 높이기 위해 중복 제거, 비식별화, 개인정보 필터링 등의 작업을 수행합니다.
   • 비윤리적 데이터나 노이즈 데이터를 필터링하여 데이터의 정확성을 보장합니다.

4. 데이터 스키마 설계:

   • AI 모델의 학습에 필요한 주석 체계를 정의합니다. 이를 통해 데이터가 모델의 요구 사항에 부합하는지 확인합니다.

5. 가이드라인 준비:

   • 작업자나 크라우드소싱 참여자에게 제공할 작업 지침서를 작성합니다. 명확하고 체계적인 지침을 통해 엣지 케이스에 대비할 수 있습니다.

6. 작업자 모집:

   • 데이터셋의 품질을 유지할 수 있도록 적절한 경험을 가진 작업자를 모집합니다. 작업자의 보상과 작업 환경 또한 고려해야 합니다.

7. 작업자 교육:

   • 작성된 가이드라인을 바탕으로 작업자와의 양방향 소통을 통해 교육을 실시합니다. 질문을 유도하여 가이드라인에 대한 이해도를 높입니다.

8. 데이터 주석:

   • 주석 작업을 통해 실제 데이터를 구축하며, 작업자의 언어적/시각적 직관을 활용하여 데이터의 품질을 관리합니다.

9. 데이터 검수:

   • 작업의 일관성과 신뢰성을 위해 내부 및 외부 요인을 점검하며, IAA(Inter-annotator Agreement) 등의 방법을 통해 데이터를 검수합니다.

10. 모델을 통한 데이터 평가:

    • 모델을 이용해 데이터의 품질을 평가하고, 데이터의 효율성과 일관성을 검증합니다.

11. 데이터 전달물 작성:

    • 최종 데이터와 분석 보고서를 유관 부서에 전달하고, 데이터셋의 버저닝과 라벨 분포를 명시하여 관리합니다.

데이터 주석 도구 및 소프트웨어

주석 도구

• Doccano: 텍스트 분류와 시퀀스 라벨링을 지원하는 오픈소스 주석 도구로, NLP 데이터 주석에 자주 사용됩니다.
• Brat: 개체 간 관계 주석에 적합한 도구로, 외부 데이터베이스(Wikipedia, Freebase 등)를 활용할 수 있습니다.
• TagEditor: 텍스트에 빠른 주석을 달 수 있도록 설계된 도구로, 데스크톱 애플리케이션 형태로 제공됩니다.
• LightTag, Tagtog 등: 작업자의 효율을 높이고, 데이터의 일관성과 정확성을 보장하기 위해 사용됩니다.
• Label-Studio: 사용자 친화적인 인터페이스와 강력한 기능을 갖춘 주석 도구로, 다양한 데이터 작업에 효율적으로 활용될 수 있습니다.

데이터 소프트웨어 도구

• CleanLab: 데이터셋 내 오류를 감지하고 데이터를 정리하여 신뢰할 수 있는 학습 데이터를 제공합니다.
• Snorkel: 약한 감독 학습을 통해 데이터의 품질을 높이며, 프로그램을 통한 데이터 라벨링을 지원합니다.
• Great Expectations: 데이터 품질 테스트 및 문서화를 통해 데이터팀이 데이터의 신뢰성과 일관성을 확보하도록 돕습니다.

크라우드소싱 기반 데이터 수집 및 가공

크라우드소싱을 통해 대규모 데이터셋을 수집하고, 가공할 수 있습니다. 대표적인 크라우드소싱 플랫폼으로는 Crowdworks, Appen, Scale.ai 등이 있습니다. 이들 플랫폼은 전 세계 다양한 작업자를 대상으로 데이터 수집 및 가공 작업을 수행하며, AI 모델의 성능을 높이기 위한 고품질 데이터를 제공합니다.

데이터 품질 관리 및 윤리적 고려사항

• 품질 관리: 일관성, 다양성, 신뢰성, 프라이버시, 보안, 윤리적 적합성 등을 평가하여 데이터를 검수합니다.
• 윤리적 고려: 데이터 수집과 주석 작업 시 프라이버시 보호와 윤리적 책임을 고려해야 합니다.

AI서비스의 개발 사이클

$$AI_System = Code(model/algorithm) + Data$$

AI 시스템(서비스)은 데이터를 처리하는 코드(모델/알고리즘)와 학습을 위한 정보(데이터)가 함께 작용해 결과를 도출하는 구조로 이루어집니다.

Data-Centric AI란 무엇인가?

Data-Centric AI는 기존의 Model-Centric 접근과는 반대되는 개념으로, 모델링을 통한 성능 향상이 아닌 데이터를 통한 성능 향상을 도모합니다. 즉, 모델을 고정하고 데이터의 품질을 향상시키는 데 중점을 둔 AI 개발 방법입니다. 이 접근법은 데이터 관리(Data Management), 데이터 증강(Data Augmentation), 데이터 필터링(Data Filtering), 합성 데이터(Synthetic Data) 생성 및 라벨 일관성(Label Consistency) 확보 등을 통해 AI 모델의 성능을 높이는 데 주안점을 둡니다.

• 목표: 데이터의 일관성을 확보하고, 데이터 내의 노이즈를 줄이며, 적절한 데이터 라벨링을 통해 모델이 학습할 데이터의 질을 높이는 것이 목표입니다.
• 핵심 질문: "모델을 변경하지 않고 성능을 어떻게 향상시킬 수 있을까?"라는 질문을 바탕으로 데이터 품질 관리(Data Quality Control)와 증강(Augmentation), 데이터 평가(Data Evaluation) 등을 통해 성능을 최적화하는 방법을 모색합니다.

Data-Centric AI의 주요 접근법

DCAI의 주요 접근법은 데이터 관리에 대한 다양한 방법론을 포함합니다:

• 이상치(outlier) 탐지 및 제거: 데이터셋 내 비정상적인 샘플을 식별하여 제거함으로써 모델의 안정성을 높입니다.
• 오류 탐지 및 수정: 잘못된 값이나 라벨을 찾아 수정하여 데이터의 신뢰도를 높입니다.
• 데이터 증강: 데이터를 추가하여 학습에서 사전 지식을 더 많이 반영할 수 있도록 합니다.
• 피처 엔지니어링 및 선택: 데이터가 표현되는 방식을 조정하여 모델이 더 효율적으로 학습할 수 있게 합니다.
• Establishing Consensus Labels: 여러 사람의 라벨링 결과를 바탕으로 가장 신뢰성 있는 라벨을 결정하는 방식 정합니다.
• Active Learning: 모델에게 가장 도움이 될 데이터를 선택적으로 라벨링하는 방식입니다.
• 커리큘럼 학습(Curriculum Learning): 쉬운 예제부터 어려운 예제 순으로 학습을 진행하여 모델의 학습 효율을 높입니다.

Model-Centric vs. Data-Centric AI

Model-Centric 접근법과 Data-Centric 접근법은 AI 성능 개선을 위한 접근방식이 근본적으로 다릅니다:

• Model-Centric: 가능한 많은 데이터를 수집하고, 이를 바탕으로 새로운 모델 구조를 제안하거나 모델의 복잡성을 증가시켜 성능을 높입니다.
• Data-Centric: 모델을 고정하고 데이터의 품질을 개선하여 성능을 높이는 방법으로, 모델의 성능 향상에 필요한 데이터를 정제하고, 일관성을 확보하며, 노이즈를 제거하는 등의 과정을 통해 최적의 성능을 추구합니다.

Data-Centric AI의 실제 적용사례

DCAI는 AI 서비스의 성능을 높이기 위한 데이터 관리 및 개선 작업을 통해 산업계와 실생활에 폭넓게 적용됩니다. 대표적인 사례로는 ChatGPT와 Tesla의 데이터 관리가 있습니다:

• ChatGPT: OpenAI는 ChatGPT의 성능을 개선하기 위해 데이터의 질을 엄격히 관리하였습니다. 인적 평가를 통해 부적절한 데이터에 낮은 가중치를 부여함으로써, 유해하거나 비진실적인 출력을 최소화하고 데이터 일관성을 높였습니다.
• Tesla: Tesla는 자율주행 시스템에서 모델 출력을 활용하여 훈련 데이터셋을 향상시키고 있습니다. 이를 통해 모델이 예측에 실패하는 사례를 분석하고, 이러한 케이스에 대한 데이터를 추가로 수집 및 라벨링하여 성능을 높이고 있습니다.

산업계의 DCAI 운영 방식

업계에서는 Data Flywheel과 DMOps와 같은 개념을 통해 데이터의 지속적인 품질 향상과 업데이트를 수행하고 있습니다.

• Data Flywheel: AI 모델의 학습 및 개선 과정에서 반복적으로 데이터의 품질을 높여가는 선순환 구조를 의미합니다.
• Data Labeling Tool: AI 학습을 위해 데이터에 빠르고 정확하게 라벨을 붙이는 과정을 지원하는 도구입니다.
• DMOps: Data Management Operation and Recipes로, 데이터 관리와 개선을 위한 일련의 프로세스를 구축하고, 데이터 라벨링 툴 등을 통해 자동화 및 효율화를 도모합니다.

AI 서비스에서의 데이터 팀, 모델 팀, 서빙 팀의역할

• 데이터 팀: 모델 학습에 필요한 데이터를 수집, 정제, 라벨링하고 품질을 관리합니다. 이들은 데이터의 일관성과 정확성을 유지하여, 모델이 최상의 데이터로 학습될 수 있도록 지원합니다.

• 모델 팀: 데이터 팀이 준비한 데이터를 기반으로 모델을 개발하고, 최적의 성능을 내도록 하이퍼파라미터 튜닝 및 모델 아키텍처를 개선합니다. 이 팀은 모델의 성능을 지속적으로 모니터링하고, 필요시 모델을 업데이트하여 최신 데이터를 반영합니다.

• 서빙 팀: 학습된 모델을 실제 사용자에게 제공하기 위한 시스템을 개발하고 운영합니다. 서빙 팀은 모델이 안정적이고 신속하게 응답할 수 있도록 배포 전략을 설계하고, 서비스 중 발생하는 문제를 해결하여 모델의 지속 가능한 운영을 보장합니다.

학계에서의 Data-Centric AI 연구

학계에서도 데이터 중심 AI 연구가 활발히 진행되고 있지만, 몇 가지 어려움이 존재합니다. 주요 도전 과제는 다음과 같습니다:

• 데이터 품질의 중요성: 데이터의 양보다는 질이 중요하다는 인식이 확산되고 있으며, 특히 높은 품질의 데이터 확보가 어려운 점이 학계에서도 큰 도전 과제임을 의미합니다.
• 라벨링 비용: 정확한 라벨링을 위해서는 많은 시간과 비용이 필요하며, 라벨링의 정답이 명확하지 않은 경우도 많습니다.
• 정해진 데이터셋 내에서의 경쟁: 학계에서는 보통 데이터셋이 갖춰진 상태에서 모델의 개선을 위한 연구들이 많습니다. 그러나 실제 서비스 환경에서는 주어진 서비스의 요구사항에 맞는 데이터셋이 필요합니다.

좋은 데이터를 만들려면?

데이터의 질은 양보다 중요합니다. 아래의 그림에서 처럼 데이터가 적더라도 높은 질의 데이터는 올바른 학습을 유도할 수 있습니다.

• 데이터 균형: 데이터셋의 불균형 문제는 모델의 학습 결과에 부정적인 영향을 줄 수 있어, 다양한 케이스가 균형 잡히게 포함된 데이터셋이 요구됩니다.

이를 해결하기 위해 DataPerf와 같은 벤치마크 시스템이 도입되어 데이터 품질을 평가하고 개선하기 위한 다양한 지표와 방법론을 제공합니다.

DataPerf

• ML 데이터 품질 향상을 위해 Data-Centric 파이프라인의 주요 단계를 벤치마크

• 데이터셋을 쉽고 반복 가능하게 유지 관리 및 평가

• 모델은 고정하고, 데이터셋만 개선하여 정확도를 향상시킬 수 있는 벤치마크 태스크를 정함.

  DCAI의 발전 방향과 학계-산업 협력

  Data-Centric AI는 산업과 학계에서 점차 중요한 연구 분야로 자리 잡고 있으며, 데이터 품질 개선을 위한 다양한 연구 및 협력 프로젝트가 진행 중입니다. 여러 기관과 기업에서 데이터 중심 AI 개발의 가이드라인 및 벤치마크를 제공하여 학계와 산업계 간의 간극을 줄이려는 노력을 기울이고 있습니다.

• 논문: 비공개 (마이크로소프트와 NVIDIA의 협업)
• 요약: Megatron-Turing NLG는 5300억 개의 매개변수를 가진 초대형 언어 모델로, 매우 큰 모델을 사용해 자연어 생성 태스크에서 최고의 성능을 낸다. 주로 대화형 AI와 텍스트 생성에 활용된다.

32. PaLM (2022)

• 논문: "PaLM: Scaling Language Modeling with Pathways"
• 요약: PaLM은 구글에서 개발한 대규모 언어 모델로, 다양한 태스크에서 최첨단 성능을 달성하도록 설계되었다. Pathways 시스템을 통해 효율적으로 학습하며, 많은 데이터에서 뛰어난 일반화 성능을 발휘한다.

33. Chinchilla (2022)

• 논문: "Training Compute-Optimal Large Language Models"
• 요약: Chinchilla는 DeepMind가 개발한 대규모 언어 모델로, 모델 크기와 학습 데이터를 최적화한 연구 결과에 기반하여 설계되었다. 특히, 동일한 계산량으로 더 나은 성능을 내는 데 중점을 둔다.

34. BigScience BLOOM (2022)

• 논문: "BLOOM: A 176B-Parameter Open-Access Multilingual Language Model"
• 요약: BLOOM은 공개 접근이 가능한 다국어 초대형 언어 모델로, 1760억 개의 파라미터를 가지고 있다. 다양한 언어를 지원하며, 공공 자원으로 개발된 최초의 초대형 언어 모델이다.

35. OPT (2022)

• 논문: "OPT: Open Pre-trained Transformer Language Models"
• 요약: OPT는 Meta에서 개발한 공개 사전 학습된 트랜스포머 모델로, 1750억 개의 매개변수를 가지고 있다. GPT-3와 유사한 구조를 가지며, 실험과 연구에서 학습된 대형 모델에 대한 액세스를 제공한다.

36. Flan-T5 (2022)

• 논문: "Scaling Instruction-Finetuned Language Models"
• 요약: Flan-T5는 구글에서 개발한 T5 모델의 변형으로, 인스트럭션 기반 미세 조정을 통해 다양한 태스크에 적응할 수 있도록 설계되었다. 다양한 NLP 태스크에 적용 가능하며, 명령어 학습 능력이 뛰어나다.

37. GLaM (2022)

• 논문: "GLaM: Efficient Scaling of Language Models with Mixture-of-Experts"
• 요약: GLaM은 구글에서 개발한 'Mixture of Experts' 모델로, 특정 태스크에 적합한 전문가들을 활성화시켜 효율성을 높인다. 매우 큰 모델이지만 희소한 활성화 방식으로 메모리와 계산 비용을 줄였다.

38. Galactica (2022)

• 논문: "Galactica: A Large Language Model for Science"
• 요약: Galactica는 과학 관련 지식을 담고 있는 대형 언어 모델로, 논문 작성, 데이터 분석 등 과학 분야에서 활용될 수 있도록 설계되었다. 과학 문서와 데이터를 기반으로 훈련되었다.

39. Gato (2022)

• 논문: "A Generalist Agent"
• 요약: Gato는 DeepMind에서 개발한 범용 인공지능 에이전트로, 다양한 태스크를 단일 모델로 수행할 수 있도록 설계되었다. 이미지, 텍스트, 조작 작업 등 여러 형태의 데이터를 처리하고 학습할 수 있다.

40. Claude (2023)

• 논문: 없음 (Anthropic에서 비공개로 개발됨)
• 요약: Claude는 Anthropic에서 개발한 대화형 언어 모델로, 윤리적 인공지능과 안전성을 강조한 설계가 특징이다. 특히 사용자의 의도를 보다 신중하게 이해하고, 부적절한 응답을 방지하는 데 중점을 둔다.

41. Gemini (2023)

• 논문: 없음 (Google DeepMind에서 개발)
• 요약: Gemini는 Google DeepMind에서 개발한 경량화된 대형 언어 모델로, 다양한 태스크에서 효율적으로 작동하도록 설계되었다. 특히 자원의 효율성을 극대화하면서도 뛰어난 성능을 제공하는 것이 목표이다.

42 LLaMA (2023)

• 논문: "LLaMA: Open and Efficient Foundation Language Models"
• 요약: LLaMA는 Meta에서 개발한 경량 대형 언어 모델로, 파라미터 수가 적음에도 뛰어난 성능을 발휘한다. 다양한 크기의 모델이 제공되며, 연구자들에게 개방되어 실험적으로 활용되고 있다.

43. Mistral (2023)

• 논문: "Efficient Scaling of Language Models with MoE"
• 요약: Mistral은 효율적인 확장을 목표로 하는 대규모 언어 모델로, Mixture of Experts(MoE) 방식을 사용하여 모델 성능과 효율성을 극대화한다. 높은 성능을 유지하면서도 모델의 자원 사용량을 줄이는 데 중점을 두고 있다.

44. Falcon (2023)

• 논문: "Falcon: High-Performance Language Models Based on Transformers"
• 요약: Falcon은 매우 대규모의 트랜스포머 기반 언어 모델로, 특히 자연어 생성 및 이해에서 높은 성능을 발휘한다. 대규모 데이터셋과 강력한 인프라를 통해 훈련된 모델로, 다양한 태스크에서 사용 가능하다.

45. Grok (2023)

• 논문: 없음 (X, 전 Google X의 연구)
• 요약: Grok은 트위터가 출시한 대화형 AI 챗봇으로, Elon Musk의 비전을 반영해 만들어졌다. 다양한 정보 제공, 사용자와의 상호작용을 통해 질문에 답변하며 트위터 플랫폼에서 활용될 수 있는 AI 도구이다.

46 RetNet (2023)

• 논문: "Retentive Network: A Successor to Transformers for Large Language Models"
• 요약: RetNet은 트랜스포머의 대안으로 설계된 모델로, 기존 트랜스포머의 제한점을 해결하기 위해 개발되었다. 장기 기억에 더 효율적으로 접근할 수 있도록 하며, 확장성이 뛰어나 대규모 언어 모델 학습에 적합하다.

47. SPAR (2023)

• 논문: "SPAR: Scalable Passage Retrieval with Efficient Context Aggregation"
• 요약: SPAR는 대규모 텍스트에서 효과적인 문서 검색을 위해 설계된 모델로, 효율적인 문맥 집합체계를 사용하여 빠르고 정확한 검색 성능을 제공한다. 주로 정보 검색 및 질문 답변 시스템에 사용된다.

48. MPT (2023)

• 논문: "MPT: A Modular and Scalable Pre-training Transformer"
• 요약: MPT는 모듈식 트랜스포머로, 다양한 NLP 작업에 맞게 쉽게 조정할 수 있는 특징을 가진다. 확장 가능한 구조로 구성되어 대규모 데이터 처리 및 다양한 태스크에서 우수한 성능을 발휘한다.

49. GPT-4 (2023)

• 논문: 비공개 (OpenAI의 발표)
• 요약: GPT-4는 GPT-3의 후속 모델로, 더욱 정교한 언어 생성 및 이해 능력을 갖춘 초대형 언어 모델이다. 멀티모달 기능을 통해 텍스트뿐 아니라 이미지도 처리할 수 있으며, 다양한 언어와 태스크에서 뛰어난 성능을 보인다.

50. LLaMA 2 (2023)

• 논문: "LLaMA 2: Open Foundation and Fine-Tuned Chat Models"
• 요약: LLaMA 2는 Meta에서 발표한 경량화된 대형 언어 모델의 두 번째 버전으로, 개선된 성능과 더 큰 유연성을 제공한다. 연구와 실험에 개방된 모델로, 자연어 처리 및 생성 작업에서 높은 성능을 발휘한다.

51. ChatGPT (2023)

• 논문: 비공개 (GPT-4 기반)
• 요약: ChatGPT는 GPT-4를 기반으로 한 대화형 언어 모델로, OpenAI가 제공하는 챗봇이다. 사용자와 자연스럽게 대화하며 질문에 답하거나 다양한 텍스트 생성 작업을 수행할 수 있다. GPT-3.5부터 시작하여, 2023년에 GPT-4 기반으로 업그레이드되었다.

52. Gemma (2023)

• 논문: 없음 (Google DeepMind에서 비공개로 개발)
• 요약: Gemma는 Google DeepMind에서 개발한 경량화된 대형 언어 모델로, 자원 효율성과 성능을 동시에 고려한 설계가 특징이다. 특히 다양한 NLP 작업에서 신속하고 효과적인 처리 능력을 보여주며, 최적화된 모델 아키텍처로 더욱 빠르고 정확한 결과를 제공하는 것이 목표이다.

53. Flamingo (2023)

• 논문: "Flamingo: A Visual Language Model for Few-Shot Learning"
• 요약: Flamingo는 이미지와 텍스트를 동시에 처리할 수 있는 멀티모달 언어 모델로, 적은 예시만으로도 고성능 결과를 낼 수 있는 'few-shot' 학습 능력을 가지고 있다. 이미지 캡션 생성, 질문 답변 등에서 사용된다.

54. ERNIE 4.0 (2023)

• 논문: 비공개 (바이두에서 개발)
• 요약: ERNIE 4.0은 바이두의 최신 대형 언어 모델로, 향상된 자연어 이해와 생성 능력을 제공하며, 기존 ERNIE 모델들보다 더 정교한 지식 그래프 기반 학습을 통해 성능을 개선했다. 다국어 지원 및 다양한 태스크에서 높은 성과를 보인다.

55. Sparrow (2023)

• 논문: 없음 (DeepMind에서 비공개로 개발)
• 요약: Sparrow는 DeepMind가 개발한 대화형 AI 모델로, 안전하고 윤리적인 대화를 중점으로 설계되었다. 사용자와의 상호작용에서 보다 신뢰할 수 있는 응답을 제공하며, AI의 윤리적 문제를 해결하려는 시도가 포함되어 있다.

56. Claude 2 (2023)

• 논문: 없음 (Anthropic에서 비공개로 개발됨)
• 요약: Claude 2는 Claude의 후속 모델로, 안전성과 성능을 강화하여 더 자연스럽고 윤리적인 대화를 지원한다. 다양한 대화형 태스크에서 뛰어난 성능을 발휘하며, AI의 신뢰성과 책임성을 중요시한다.

57. LLaMA 3.1 (2024)

• 논문: 비공개 (Meta에서 개발)
• 요약: LLaMA 3.1은 Meta에서 개발한 LLaMA 시리즈의 최신 모델로, 파라미터 효율성이 크게 개선되었다. 더 강력하고 효율적인 성능을 제공하며, 최신 트렌드에 맞춰 대규모 언어 모델의 성능을 극대화한 모델이다. 특히, 자원 소모를 줄이면서도 우수한 성능을 발휘한다.

58. NeMo Megatron (2024)

• 논문: 비공개 (NVIDIA에서 개발)
• 요약: NeMo Megatron은 NVIDIA에서 개발한 초거대 언어 모델로, 고성능 컴퓨팅과 분산 학습에서 뛰어난 성능을 자랑한다. 상업적 응용에 적합하며, 대규모 데이터 처리에 최적화된 모델로, 다양한 산업에서 활용될 가능성이 높다.

59. Gemini 1.5 (2024)

• 논문: 없음 (Google DeepMind에서 비공개로 개발)
• 요약: Gemini 1.5는 Google DeepMind에서 개발한 최신 경량화된 대형 언어 모델로, 향상된 효율성과 성능을 제공한다. 다양한 태스크에 적합하도록 설계되었으며, 빠른 응답 속도와 적은 자원 소모를 목표로 한다.

📬 "추가하거나 불필요한 모델이 있으면 알려주세요~"

• 논문: "Attention is All You Need"
• 요약: Transformer 모델은 기존 RNN과 CNN을 대체하며 등장한 모델로, 주목할 만한 점은 모든 정보를 다루는 데 있어 'Self-Attention' 메커니즘을 사용한다. 이를 통해 병렬화가 가능해 학습 속도가 크게 향상되었다. NLP 분야에서 큰 혁신을 가져온 기초 모델.

2. BERT (2018)

• 논문: "BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding"
• 요약: BERT는 양방향(Bidirectional)으로 문맥을 이해하는 사전 학습된 트랜스포머 모델이다. 마스크된 언어 모델링(Masked Language Modeling, MLM)과 다음 문장 예측을 사용하여 텍스트를 학습하며, 다양한 NLP 작업에서 성능이 우수함.

3. RoBERTa (2019)

• 논문: "RoBERTa: A Robustly Optimized BERT Pretraining Approach"
• 요약: RoBERTa는 BERT의 변형으로, 학습 데이터와 시간, 배치 크기 등을 증가시키고, 다음 문장 예측을 제거해 성능을 향상시킨 모델이다. BERT의 구조는 유지하되, 최적화를 통해 더 좋은 성능을 낸다.

4. T5 (2019)

• 논문: "Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer"
• 요약: T5는 모든 NLP 작업을 텍스트-투-텍스트(Text-to-Text) 문제로 변환하여 해결하는 방식의 모델이다. 즉, 번역, 요약, 질문 답변 등 모든 태스크를 같은 형식으로 처리하는 것이 특징이다.

5. GPT-2 (2019)

• 논문: "Language Models are Unsupervised Multitask Learners"
• 요약: GPT-2는 대규모의 텍스트 데이터로 학습된 비지도 학습 모델로, 문맥을 잘 이해하고 이어지는 문장을 예측하는 데 뛰어난 성능을 발휘한다. 'Generative Pretrained Transformer'의 두 번째 버전으로 텍스트 생성 작업에서 우수한 성과를 냄.

6. XLNet (2019)

• 논문: "XLNet: Generalized Autoregressive Pretraining for Language Understanding"
• 요약: XLNet은 BERT와 GPT의 장점을 결합한 모델로, 순차적 예측 대신 "Permutation-based" 방식으로 모든 가능한 순서의 단어를 학습함으로써 성능을 향상시킨다. 자가회귀와 양방향성의 강점을 결합했다.

7. DistilBERT (2019)

• 논문: "DistilBERT, a distilled version of BERT: smaller, faster, cheaper and lighter"
• 요약: DistilBERT는 BERT의 축소판으로, 성능은 크게 유지하면서도 모델 크기를 줄이고 속도를 향상시킨 경량화된 트랜스포머 모델이다. 이는 지식 증류(knowledge distillation) 기술을 사용하여 만들어졌다.

8. XLM-R (2019)

• 논문: "Unsupervised Cross-lingual Representation Learning at Scale"
• 요약: XLM-R은 다국어 언어 모델로, 대규모 다국어 코퍼스를 사용해 훈련된 RoBERTa 기반 모델이다. 언어 간 전이 학습 성능이 뛰어나며, 다양한 언어에서 높은 성능을 보여준다.

9. ALBERT (2019)

• 논문: "ALBERT: A Lite BERT for Self-supervised Learning of Language Representations"
• 요약: ALBERT는 BERT의 경량화 모델로, 매개변수 공유와 행렬 분해를 통해 모델 크기를 줄이면서 성능 저하를 최소화했다. BERT보다 적은 리소스를 사용하면서도 거의 동일한 성능을 낸다.

10. GPT-3 (2020)

• 논문: "Language Models are Few-Shot Learners"
• 요약: GPT-3는 GPT-2의 확장판으로, 1750억 개 이상의 매개변수를 가진 초대형 언어 모델이다. 텍스트 생성, 번역, 질문 답변 등 다양한 태스크에서 뛰어난 성능을 발휘하며, 특이하게도 훈련된 태스크 없이도 새로운 태스크를 해결하는 'few-shot' 학습 능력을 보여준다.

11. BART (2020)

• 논문: "BART: Denoising Sequence-to-Sequence Pre-training for Natural Language Generation, Translation, and Comprehension"
• 요약: BART는 문장을 무작위로 삭제하거나 손상시키는 방식으로 텍스트를 노이즈화하고, 이를 복원하는 학습을 통해 자연어 생성과 이해에서 뛰어난 성능을 보인다. 인코더-디코더 구조를 사용한 트랜스포머 모델이다.

12. Turing-NLG (2020)

• 논문: 없음 (마이크로소프트에서 비공개 연구로 발표)
• 요약: Turing-NLG는 마이크로소프트가 개발한 초대형 언어 모델로, 자연어 생성 태스크에서 탁월한 성능을 발휘한다. 170억 개 이상의 매개변수를 가지고 있으며, 주로 생성 기반 작업에 사용된다.

13. Electra (2020)

• 논문: "ELECTRA: Pre-training Text Encoders as Discriminators Rather Than Generators"
• 요약: Electra는 새로운 학습 방식인 'Replaced Token Detection'을 도입한 모델로, 생성된 단어가 올바른지 여부를 판별하는 방식으로 학습된다. 이 방식은 기존 MLM보다 효율적이며, 적은 리소스로 더 빠르고 효과적으로 학습할 수 있다.

14. UniLM (2020)

• 논문: "Unified Language Model Pre-training for Natural Language Understanding and Generation"
• 요약: UniLM은 단일 트랜스포머 모델로 자연어 이해와 생성 태스크를 동시에 수행할 수 있도록 설계되었다. 이 모델은 다양한 학습 모드를 지원하여 다양한 NLP 작업에서 높은 성능을 보인다.

15. TinyBERT (2020)

• 논문: "TinyBERT: Distilling BERT for Natural Language Understanding"
• 요약: TinyBERT는 BERT 모델의 경량 버전으로, 지식 증류 방식을 사용해 BERT의 성능을 유지하면서도 모델 크기를 줄이고 속도를 향상시켰다. 모바일 환경에서도 사용할 수 있도록 설계되었다.

16. MobileBERT (2020)

• 논문: "MobileBERT: a Compact Task-Agnostic BERT for Resource-Limited Devices"
• 요약: MobileBERT는 리소스가 제한된 환경에서 실행할 수 있도록 설계된 BERT의 경량화 버전이다. BERT 모델의 성능을 유지하면서도 모바일 기기와 같은 환경에서도 활용할 수 있게 최적화되었다.

  17. MiniLM (2020)

• 논문: "MiniLM: Deep Self-Attention Distillation for Task-Agnostic Compression of Pre-trained Transformers"
• 요약: MiniLM은 사전 학습된 트랜스포머 모델의 작은 버전으로, 자체 주의 메커니즘의 증류를 통해 성능을 유지하면서도 파라미터 수를 대폭 줄였다. 경량 모델로서 빠른 추론이 필요한 응용에 적합하다.

18. Quantized BERT (Q-BERT) (2020)

• 논문: "Q-BERT: Hessian Based Ultra Low Precision Quantization of BERT"
• 요약: Q-BERT는 BERT 모델을 양자화하여 메모리 사용량을 줄이고 추론 속도를 향상시킨 모델이다. 특히 매우 낮은 정밀도(ultra-low precision)에서도 성능을 유지하도록 설계되었다.

19. Reformer (2020)

• 논문: "Reformer: The Efficient Transformer"
• 요약: Reformer는 트랜스포머의 효율성을 개선한 모델로, 메모리 사용량을 줄이고 더 긴 시퀀스를 처리할 수 있게 만든다. 이는 국소적 민감 해싱(Locality-Sensitive Hashing)과 가역적 네트워크(reversible network)를 통해 가능해졌다.

20. DeBERTa (2021)

• 논문: "DeBERTa: Decoding-enhanced BERT with Disentangled Attention"
• 요약: DeBERTa는 기존 BERT 모델에 분리된(attention disentangling) 주의 메커니즘과 절대적 위치 정보가 아닌 상대적 위치 인코딩을 도입하여 성능을 향상시킨 모델이다. 다양한 NLP 태스크에서 BERT보다 우수한 성능을 발휘한다.

21. Megatron (2021)

• 논문: "Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism"
• 요약: Megatron은 매우 대규모 언어 모델 학습을 위한 병렬화 프레임워크로, 수십억 개의 매개변수를 가진 모델을 효율적으로 학습하는 데 최적화되어 있다. 대형 트랜스포머 모델을 학습할 수 있는 기술적 인프라를 제공한다.

23. Switch Transformer (2021)

• 논문: "Switch Transformers: Scaling to Trillion Parameter Models with Simple and Efficient Sparsity"
• 요약: Switch Transformer는 모델을 희소하게 학습하는 방식으로 수조 개의 매개변수를 다루는 모델이다. 활성화되는 파라미터만 사용하는 방식으로 효율성을 높였다. 매우 대규모 모델을 효율적으로 학습할 수 있도록 설계되었다.

24. LaMDA (2021)

• 논문: 비공개 (구글의 대화 모델 연구 발표)
• 요약: LaMDA는 구글이 개발한 대규모 대화형 언어 모델로, 대화를 보다 자연스럽게 이어갈 수 있도록 설계되었다. 자유 주제 대화에서 문맥을 이해하고, 사용자와 의미 있는 상호작용을 할 수 있는 특징을 가짐.

25. Gopher (2021)

• 논문: "Gopher: Scaling Language Models"
• 요약: Gopher는 DeepMind가 개발한 대규모 언어 모델로, 약 2800억 개의 파라미터를 가지고 있으며 다양한 자연어 처리 태스크에서 우수한 성능을 보여준다. 특히 대형 언어 모델의 윤리적 측면에 대한 연구도 포함되었다.

26. ERNIE (2021)

• 논문: "ERNIE 3.0: Large-scale Knowledge Enhanced Pre-training for Language Understanding and Generation"
• 요약: ERNIE는 바이두가 개발한 언어 모델로, 지식 그래프를 활용하여 언어 이해와 생성 능력을 강화했다. 대규모 지식 기반을 통합함으로써 의미적 표현 학습에서 더욱 우수한 성능을 보인다.

27. OpenAI Codex (2021)

• 논문: 없음 (GPT-3의 확장으로 개발됨)
• 요약: Codex는 GPT-3를 기반으로 한 모델로, 자연어를 프로그래밍 코드로 변환하는 능력을 갖추고 있다. 이를 통해 코드를 생성하거나 수정하는 데 도움을 주며, 주로 GitHub Copilot과 같은 개발 도구에 통합된다.

28. DALL·E (2021)

• 논문: "Zero-Shot Text-to-Image Generation"
• 요약: DALL·E는 텍스트 설명을 입력받아 이미지를 생성할 수 있는 모델이다. 창의적인 이미지 생성 작업에서 뛰어난 성과를 보이며, 이미지 생성에 대한 새로운 가능성을 열었다.

29. PERCEIVER (2021)

• 논문: "Perceiver: General Perception with Iterative Attention"
• 요약: Perceiver는 입력 데이터의 크기나 형식에 관계없이 다양한 형태의 입력을 처리할 수 있도록 설계된 모델이다. 이를 통해 이미지, 비디오, 텍스트 등 여러 형태의 데이터를 처리하는 데 강점을 가진다.

30. HyperClova (2021)

• 논문: 비공개 (네이버의 대규모 언어 모델)
• 요약: HyperClova는 네이버에서 개발한 한국어에 최적화된 대형 언어 모델이다. 2040억 개의 파라미터를 가지고 있으며, 한국어 기반 태스크에서 탁월한 성능을 발휘한다. 다양한 응용에서 활용된다.

BERT는 NLP에서 광범위하게 사용되는 사전 훈련된 모델로, 주로 텍스트 분류, 문장 유사도, 문장 생성 등 다양한 작업에 적용됩니다. BERT 모델은 입력 텍스트 시퀀스를 인코딩하고 해당 시퀀스를 통해 여러 다운스트림 작업에 사용할 수 있는 특징을 추출합니다.

✅ 본 포스트는 Huggingface의 transformers 라이브러리에 기반합니다.

Transformers 인코더 구조

BERT의 전체적인 구조는 크게 Embedding 파트, Encoder 파트, Classifier 파트로 나뉩니다.

1. Embedding part

입력 텍스트 시퀀스를 토큰화하고, 각 토큰에 대해 다음 세 가지 임베딩을 더해 하나의 벡터로 만듭니다:

• Token Embeddings (word_embeddings): 단어의 고유한 벡터 표현
• Segment Embeddings (token_type_embeddings): 문장 구분을 위한 임베딩
• Position Embeddings (position_embeddings): 각 토큰의 순서를 나타내는 임베딩

class BertEmbeddings(nn.Module):
    """Construct the embeddings from word, position and token_type embeddings."""
    def __init__(self, config):
        super().__init__()
        self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
        self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
        self.token_type_embeddings = nn.Embedding(config.type_vocab_size, config.hidden_size)

토크나이저로 부터 세 가지 ids(input_ids, token_type_ids, position_ids)를 받아 임베딩 후, 세 가지 임베딩을 더해서 최종적인 임베딩 벡터를 반환합니다.

def forward(input_ids, token_type_ids, position_ids, ...) -> torch.Tensor:     
    if inputs_embeds is None:
        inputs_embeds = self.word_embeddings(input_ids)

    token_type_embeddings = self.token_type_embeddings(token_type_ids)

    embeddings = inputs_embeds + token_type_embeddings

    if self.position_embedding_type == "absolute":
        position_embeddings = self.position_embeddings(position_ids)
        embeddings += position_embeddings

    return embeddings

2. Encoder part

인코더는 입력된 임베딩 벡터를 여러 계층의 어텐션 메커니즘을 통해 처리하여 더 높은 수준의 표현을 추출합니다. BERT는 Transformer 구조의 인코더만을 사용하며, 이 인코더는 여러 층으로 구성되어 있습니다. 각 층은 어텐션과 피드포워드 네트워크로 구성됩니다.

BertEncoder의 구성

- BertLayer
    - BertAttention
        - BertSelfAttention
        - BertSelfOutput    
     - BertIntermediate (Feed-forward)
    - BertOutput

BertLayer

하나의 BERT Layer는 어텐션과 Feed-forward (BertIntermediate) 계층을 포함합니다.

class BertLayer(nn.Module):
    def __init__(self, config):
        super().__init__()

        self.attention = BertAttention(config)

        self.add_cross_attention = config.add_cross_attention
        if self.add_cross_attention:
            self.crossattention = BertAttention(config, position_embedding_type="absolute")

        self.intermediate = BertIntermediate(config)
        self.output = BertOutput(config)

BertAttention

BertAttention은 셀프 어텐션과 출력 레이어로 구성됩니다.

class BertAttention(nn.Module):
    def __init__(self, config, position_embedding_type=None):
        super().__init__()
        self.self = BertSelfAttention(config, position_embedding_type=position_embedding_type)
        self.output = BertSelfOutput(config)

BertSelfAttention

BertSelfAttention은 Query, Key, Value 벡터를 생성하여 어텐션 점수를 계산합니다.

class BertSelfAttention(nn.Module):
    def __init__(self, config, position_embedding_type=None):
        super().__init__()

        self.query = nn.Linear(config.hidden_size, self.all_head_size)
        self.key = nn.Linear(config.hidden_size, self.all_head_size)
        self.value = nn.Linear(config.hidden_size, self.all_head_size)

        attention_scores = attention_scores / math.sqrt(self.attention_head_size)
        attention_probs = nn.functional.softmax(attention_scores, dim=-1)

BertSelfOutput

BertSelfOutput은 어텐션 결과를 처리하고, 원래의 입력 값과 결합한 후 정규화합니다.

class BertSelfOutput(nn.Module):
    def forward(self, hidden_states, input_tensor) -> torch.Tensor:
        hidden_states = self.dense(hidden_states)
        hidden_states = self.dropout(hidden_states)
        hidden_states = self.LayerNorm(hidden_states + input_tensor)
        return hidden_states

BertIntermediate

BertIntermediate는 Feed-forward 네트워크를 정의합니다.

class BertIntermediate(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.dense = nn.Linear(config.hidden_size, config.intermediate_size)

        if isinstance(config.hidden_act, str):
            self.intermediate_act_fn = ACT2FN[config.hidden_act]
        else:
            self.intermediate_act_fn = config.hidden_act

    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
        hidden_states = self.dense(hidden_states)
        hidden_states = self.intermediate_act_fn(hidden_states)
        return hidden_states

✅ ACT2FN: Activation functions

BertOutput

BertOutput은 피드포워드 네트워크의 마지막 출력을 담당합니다.

class BertOutput(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
        self.dropout = nn.Dropout(config.hidden_dropout_prob)

    def forward(self, hidden_states, input_tensor) -> torch.Tensor:
        hidden_states = self.dense(hidden_states)
        hidden_states = self.dropout(hidden_states)
        hidden_states = self.LayerNorm(hidden_states + input_tensor)
        return hidden_states

3. Classifier part

BERT의 마지막 부분은 다운스트림 작업에 맞춰 결과를 도출하는 분류기입니다. 예를 들어, 문장 분류 작업에서는 시퀀스의 벡터를 하나의 예측 값으로 변환합니다.

class BertForSequenceClassification(BertPreTrainedModel):
    def __init__(self, config):
        super().__init__(config)
        self.num_labels = config.num_labels
        self.config = config

        self.bert = BertModel(config)

        self.classifier = nn.Linear(config.hidden_size, config.num_labels)

        # Initialize weights and apply final processing
        self.post_init()

Linear 변환

(시퀀스 길이, hidden_size)와 (hidden_size, num_labels)의 행렬 곱(시퀀스 길이, num_labels)을 통해 최종 분류 결과를 생성합니다.

✅ 각 시퀀스에 따른 분류결과로 나타난다.

• num_labels = 1 (ReLU): 단일 값 출력, 예시: 2.6
• num_labels = 1 (Sigmoid): 0과 1 사이의 값 출력
• num_labels = 3 (Sigmoid & Softmax): 예시: (0.2, 0.3, 0.5)

활용 방법

BERT 모델에 추가적인 임베딩을 삽입하여 학습에 활용할 수 있습니다. 예를 들어, 감정 표현 처리나 새로운 형태의 토크나이징 작업을 위한 임베딩을 추가할 수 있습니다.

class BertEmbeddings(nn.Module):
    def __init__(self, config):
        super().__init__()

        self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
        self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
        self.token_type_embeddings = nn.Embedding(config.type_vocab_size, config.hidden_size)

        # 감정 표현을 처리하는 임베딩 추가
        self.emotion_embeddings = nn.Embedding(config.emotion_vocab_size, config.hidden_size)

        # 다른 토크나이징 방식 처리를 위한 임베딩 추가
        self.word_embeddings_syllable = nn.Embedding(config.syllable_vocab_size, config.hidden_size)

그림 출처: 모두의 연구소, by Sarthak Vajpayee in Towards Data Science

1. Git과 GitHub란?

Git은 소프트웨어 버전 관리 시스템(VCS)이다. 소프트웨어 개발에서 여러 개발자가 동시에 협업할 때 코드 수정 내역을 서로 공유하고 관리함으로써 효율적인 개발을 도와준다. Git은 분산 버전 관리 시스템으로, 중앙 서버(Git server)와 로컬 클라이언트(Git client)가 각각 존재한다. 예를 들어, GitHub.com과 같은 원격 서버는 중앙에 코드를 저장하고, Visual Studio Code나 Git CLI 같은 클라이언트를 통해 로컬에서도 작업할 수 있다. 이러한 분산 구조 덕분에 모든 팀원이 로컬에서 자유롭게 작업할 수 있으며, 변경 사항을 원격 서버에 반영하여 협업을 원활히 할 수 있다.

2. 리포지토리 만들기 & 커밋하기

리포지토리(Repository)는 프로젝트와 관련된 모든 파일과 그 파일의 수정 기록을 담는 저장소이다. GitHub에서는 리포지토리를 통해 코드를 저장하고 관리할 수 있을 뿐만 아니라 협업을 위한 여러 기능도 제공한다.

커밋(commit)은 특정 변경 사항을 저장하는 과정으로, Git에서 버전을 관리하는 데 필수적인 역할을 한다. 커밋을 통해 변경 내역을 기록하고, 나중에 필요할 때 쉽게 이전 상태로 되돌아갈 수 있다. 커밋에는 변경 내용을 설명하는 커밋 메시지를 작성하여, 다른 팀원들이 어떤 수정이 이루어졌는지 쉽게 이해할 수 있도록 돕는다.

대규모 프로젝트에서는 Git을 도입하여 효율적인 협업이 가능하며, 커밋 히스토리를 통해 프로젝트의 모든 변경 내역을 추적할 수 있다. 이렇게 하면 누가 언제 어떤 부분을 수정했는지 명확히 알 수 있어 문제 발생 시 빠르게 원인을 파악할 수 있다.

3. GitHub Issues로 소통하기

Issues는 개발 중 발생하는 문제나 개선사항을 추적하는 도구이다. 예를 들어, 새로운 기능을 추가하거나 버그를 수정해야 할 때 Issues를 통해 이를 기록하고 관리할 수 있다. 팀원들 간의 의견 교환도 Issues를 통해 이루어질 수 있다.

라벨(labels)을 이용해 이슈의 유형을 명확히 표시하고, Assignee를 통해 담당자를 지정하여 협업을 원활하게 할 수 있다. 이렇게 하면 팀 내 소통을 강화하고, 효과적으로 문제를 해결할 수 있다. 또한, 특정 코드에 문제가 있을 때 코드에 댓글을 달아 다른 개발자와 의견을 공유할 수 있다.

4. 클론(복제) & Git 설정

클론(Clone)은 GitHub의 리포지토리를 로컬 컴퓨터로 복제하는 과정이다. 이를 통해 로컬 환경에서 원격 리포지토리의 파일들을 받아와 개발을 진행할 수 있다. 이렇게 하면 로컬에서 자유롭게 실험하거나 수정할 수 있고, 수정한 내용을 다시 원격 저장소에 반영할 수 있다.

또한, Git 설정(git config) 명령어를 사용해 로컬에서 커밋 시 누가 작업을 했는지 기록할 수 있다. 예를 들어, git config --global user.name "사용자 이름"과 git config --global user.email "사용자 이메일"을 설정하여 커밋 기록에 사용자 정보를 남길 수 있다.

5. Git Push: 원격 저장소에 업로드

로컬에서 작업한 내용을 원격 저장소에 반영하려면 Push 명령어를 사용한다. Push는 로컬에서 커밋한 모든 변경 사항을 원격 저장소에 업로드하는 과정이다. 이를 통해 다른 팀원들도 내가 작업한 내용을 확인하고 함께 작업을 진행할 수 있다.

Push 명령어를 사용할 때는 원격 저장소의 이름(일반적으로 origin)과 업로드할 브랜치를 지정해줘야 한다. 예를 들어, git push origin main 명령어를 사용하면 로컬에서 작업한 main 브랜치를 원격 저장소의 main 브랜치에 반영할 수 있다.

6. Git Pull: 원격 변경사항 반영하기

다른 팀원이 원격 저장소에 push한 변경사항을 내 로컬 환경에 반영하고 싶을 때 pull 명령어를 사용한다. Pull은 fetch와 merge가 결합된 명령어로, 원격 저장소의 변경 사항을 가져와 로컬 저장소와 병합한다. 이를 통해 최신 상태로 동기화하여 작업을 이어나갈 수 있다.

7. Fetch & Merge: 분리된 동기화 과정

Fetch는 원격 저장소의 변경 사항을 가져오기만 하는 명령어이고, Merge는 가져온 변경 사항을 로컬에 병합하는 과정이다. Pull 대신 fetch와 merge를 나눠서 사용하면 충돌을 미리 해결하고 안전하게 병합할 수 있다. 예를 들어, git fetch origin을 사용하여 원격 저장소의 변경 사항을 가져오고, git merge origin/main을 사용하여 로컬 브랜치와 병합할 수 있다.

8. Git Init & Add: 로컬 저장소 시작하기

Git Init은 로컬 저장소를 Git으로 관리할 수 있게 설정하는 명령어이다. 프로젝트 폴더에서 git init 명령어를 실행하면 해당 폴더가 Git 저장소로 초기화된다. 이를 통해 로컬에서 버전 관리를 시작할 수 있다.

Git Add는 커밋할 파일을 선택하는 명령어로, 커밋하기 전에 변경된 파일을 스테이징(staging) 영역에 올리는 역할을 한다. 한 커밋에 포함할 파일을 정리하고 관리할 수 있도록 돕는다. 예를 들어, git add 파일명 명령어를 사용하면 해당 파일이 스테이징 영역에 추가되고, 이후 git commit 명령어를 통해 커밋할 수 있다.

9. Git Checkout: 이전 버전으로 돌아가기

Git Checkout은 특정 커밋의 상태로 저장소를 되돌리는 명령어이다. 예를 들어, 코드에 문제가 발생했을 때 이전 커밋으로 되돌아가 오류를 수정할 수 있다. HEAD는 현재 작업 중인 위치를 가리키며, master(main)는 최신 커밋을 가리킨다. Checkout을 통해 원하는 커밋으로 되돌아갔다가, 다시 최신 버전으로 복구할 수 있다.

예를 들어, git checkout 커밋해시 명령어를 사용하면 해당 커밋의 상태로 작업 디렉토리가 변경된다. 이후 수정이 완료되면 git checkout main을 통해 최신 버전으로 돌아올 수 있다.

브랜치는 독립된 개발 환경을 제공하는 기능이다. 브랜치는 여러 명이 동시에 개발할 때 각각의 작업을 분리하여 진행하거나, 새로운 기능을 테스트할 때 유용하게 사용할 수 있다. Git의 강력한 기능 중 하나로, 소스코드의 주 버전(main/master)과는 독립된 작업 공간을 만든다.

• 기본 브랜치는 보통 main 혹은 master 브랜치로 사용된다.
• 새 브랜치 생성: 새로운 브랜치를 만들어 독립적으로 기능을 개발할 수 있다.

  git branch 브랜치명

• 브랜치 전환: 현재 작업 중인 브랜치를 변경한다.

  git checkout 브랜치명

• 브랜치 생성 및 이동: 브랜치를 생성하고 바로 이동한다.

  git checkout -b 브랜치명

브랜치 실습 예시

• 새로운 기능을 개발하거나 버그를 수정할 때 새 브랜치를 만들어 작업하고, 완료되면 merge를 통해 주 브랜치에 반영하는 방식이다.

2. Merge와 충돌 해결

Merge는 하나의 브랜치를 다른 브랜치와 병합하는 과정이다. 일반적으로 기능 개발을 완료한 후 개발 브랜치를 main 브랜치에 병합할 때 사용된다.

• Fast-forward Merge는 두 브랜치의 내용이 충돌하지 않을 때 사용하는 방식으로, 하나의 브랜치가 다른 브랜치에 병합되면서 히스토리가 직선으로 이어진다.
• 3-Way Merge는 브랜치의 변경 내용이 서로 다를 때 사용되며, 여러 갈래로 나뉜 기록들을 하나로 합친다.
• 충돌(conflict) 해결: 서로 다른 브랜치에서 동일한 파일의 같은 부분을 수정하면 충돌이 발생할 수 있다. 충돌이 발생한 경우 Git에서 자동으로 해결하지 못하기 때문에 개발자가 직접 코드를 수정하여 해결해야 한다.

Merge 실습

• Merge 명령어: git merge 브랜치명
• 충돌 해결: 충돌이 발생한 파일은 Git에서 자동으로 표시된다. 이 파일들을 수동으로 수정하고 저장 후, add와 commit을 통해 병합을 완료한다.

3. Rebase

Rebase는 브랜치의 히스토리를 변경하여 더 깔끔하게 유지하는 방법이다. 브랜치에서 진행된 커밋들을 다른 브랜치의 최신 커밋 뒤로 옮기면서 하나의 직선형 히스토리를 만들 수 있다.

• Rebase vs Merge: Merge는 브랜치 간의 히스토리를 유지하며 병합하지만, Rebase는 히스토리를 다시 작성해 마치 브랜치가 한 줄로 이어진 것처럼 만든다.

Rebase 실습

• 브랜치의 작업 내용을 다른 브랜치 위에 재배치할 때 사용한다.

  git rebase 브랜치명

• 주의점: 이미 push한 커밋을 Rebase하는 경우, 팀원과 협업 시 혼란을 초래할 수 있으므로 신중하게 사용해야 한다.

4. Stash

Stash는 현재 작업 중인 내용을 임시로 저장해 두고 나중에 다시 적용할 수 있도록 하는 기능이다. 갑자기 다른 브랜치로 전환해야 할 때, 현재의 변경 사항을 커밋하지 않고 저장할 수 있다.

• Stash 저장: 현재의 변경 내용을 임시로 저장한다.

  git stash

• Stash 불러오기: 임시로 저장해 둔 변경 사항을 다시 불러온다.

  git stash apply

• Stash 목록 확인: 저장해둔 변경 사항의 목록을 확인한다.

  git stash list

Stash 실습 예시

• 긴급하게 브랜치를 변경해야 할 때, 아직 완료되지 않은 작업을 stash로 임시 저장하고 다른 브랜치로 이동한 후, 다시 돌아와 apply를 통해 복원할 수 있다.

5. Remote와 Tracking Branch

Remote는 원격 저장소를 의미하며, 보통 GitHub, GitLab, Bitbucket 같은 서비스에 저장된 리포지토리를 가리킨다.

• origin은 원격 저장소의 기본 이름이며, 원격 저장소를 추가할 때 주로 사용한다.
• Tracking Branch는 로컬 브랜치와 원격 저장소의 특정 브랜치를 연결해 주는 브랜치이다.

  git branch --track 브랜치명 origin/브랜치명

실습 예시

• Remote 설정: 기존 프로젝트에 원격 저장소를 연결한다.

  git remote add origin 원격저장소URL

6. Git Reset

Git Reset은 로컬 저장소의 상태를 이전 커밋으로 되돌릴 때 사용한다. 이를 통해 특정 커밋 이후의 변경 사항을 취소할 수 있다.

• Soft Reset: 특정 커밋으로 돌아가지만, 변경 사항은 그대로 스테이징 영역에 남겨둔다.

  git reset --soft HEAD~1

• Mixed Reset (기본 옵션): 특정 커밋으로 돌아가며, 변경 사항을 스테이징 영역에서 제거하지만 워킹 디렉토리에는 남겨둔다.

  git reset --mixed HEAD~1

• Hard Reset: 특정 커밋으로 돌아가며, 변경 사항을 모두 삭제한다.

  git reset --hard HEAD~1

Reset 실습 예시

• 실수로 잘못된 커밋을 했을 경우 해당 커밋을 취소하고 다시 작업을 이어나가고자 할 때 reset을 사용한다.

7. Git Log와 Diff

Git Log는 커밋 히스토리를 확인하는 명령어로, 현재 리포지토리의 모든 커밋 내역을 볼 수 있다.

• git log: 모든 커밋의 로그를 출력한다.
• git log --oneline: 간결하게 한 줄로 로그를 확인한다.

Git Diff는 변경 사항을 확인하는 명령어로, 파일이 어떻게 변경되었는지 비교할 수 있다.

• git diff: 현재 변경된 파일의 차이점을 확인한다.
• git diff 브랜치1 브랜치2: 두 브랜치 간의 차이점을 확인한다.

8. Git Tag

Tag는 특정 커밋을 가리키는 표시로, 보통 중요한 시점(예: 릴리즈 버전)을 나타내기 위해 사용된다.

• 태그 생성: 특정 커밋에 태그를 추가한다.

  git tag 태그명

• 태그 푸시: 원격 저장소에 태그를 푸시한다.

  git push origin 태그명

9. Git Flow

Git Flow는 Git을 이용한 브랜치 전략으로, 협업 프로젝트에서 브랜치를 효율적으로 관리하는 방법론이다. 일반적으로 다음과 같은 브랜치를 사용한다.

• master: 배포 가능한 코드만 존재하는 안정적인 브랜치.
• develop: 개발 중인 코드가 존재하며, 새로운 기능이 추가되고 테스트된다.
• feature: 새로운 기능을 개발하기 위한 브랜치로, 개발 완료 후 develop 브랜치에 병합된다.
• release: 배포 준비를 위한 브랜치.
• hotfix: 긴급한 버그 수정을 위한 브랜치로, master와 develop에 병합된다.

10. Git Alias

Git Alias는 자주 사용하는 Git 명령어를 별명으로 등록하여 더 간편하게 사용할 수 있게 한다. 예를 들어, git checkout을 git co로 간단하게 사용할 수 있다.

• Alias 등록:

  git config --global alias.co checkout
  git config --global alias.br branch

Hugging Face의 Transformers 라이브러리는 자연어 처리(NLP) 분야에서 혁신적인 변화를 불러일으킨 오픈 소스 라이브러리이다. 2019년에 처음 출시된 이후, 간편하면서도 강력한 방식으로 다양한 최신 Transformer 모델을 활용할 수 있게 해주어 많은 개발자와 연구자들 사이에서 인기를 끌고 있다. 이 글에서는 Transformers 라이브러리가 무엇인지, 어떤 기능을 제공하며 어떻게 활용할 수 있는지 살펴보겠다.

🥕 허깅 페이스 홈페이지에서 더 자세히 알아볼 수 있다.

Transformers 라이브러리란?

Hugging Face의 Transformers는 BERT, GPT, RoBERTa, T5와 같은 다양한 Transformer 기반의 딥러닝 모델을 쉽게 사용할 수 있도록 하는 파이썬 라이브러리이다. 이 라이브러리는 Google, OpenAI, Facebook 등의 연구팀에서 개발한 대규모 사전학습(pre-trained) 모델들을 제공하며, 사용자가 간단한 API 호출로 이러한 모델들을 불러와 사용할 수 있도록 지원한다. 주로 텍스트 분류, 번역, 감정 분석, 질문 응답 등 여러 NLP 작업에 활용된다.

Transformers 라이브러리는 단순히 모델을 제공하는 것에 그치지 않고, 다양한 응용 프로그램에서 쉽게 사용할 수 있는 강력한 도구들을 포함하고 있다. Hugging Face는 PyTorch와 TensorFlow를 모두 지원하여 사용자가 선호하는 딥러닝 프레임워크를 자유롭게 선택할 수 있게 하고 있으며, 모델 학습 및 추론 과정을 훨씬 간단하게 만들어준다. 이러한 접근 방식 덕분에 NLP 프로젝트에 입문한 초보자부터, 최적의 성능을 추구하는 연구자까지 폭넓은 사용자가 Transformers를 활용하고 있다.

주요 특징

1. 다양한 모델 지원

   • Transformers 라이브러리는 BERT, GPT 시리즈, T5, DistilBERT 등 다양한 모델을 포함하고 있으며, 최신 연구 결과에 기반한 모델들을 지속적으로 업데이트하고 있다.
   • Hugging Face의 모델 허브(Model Hub)에서 수많은 커뮤니티 모델을 찾아볼 수 있으며, 이를 사용해 손쉽게 텍스트 생성, 요약, 번역 등의 작업을 수행할 수 있다. Model Hub는 전 세계 개발자들이 각자의 모델을 업로드하고 공유하는 공간으로, 이를 통해 최신 모델을 손쉽게 얻을 수 있으며, 커뮤니티가 기여한 수많은 실험적 모델을 직접 사용할 수 있다.

2. 사용이 간편한 인터페이스

   • Transformers는 NLP 작업을 위한 통합된 인터페이스를 제공하여 초보자도 쉽게 사용할 수 있다. 예를 들어, pipeline() 함수를 통해 단 몇 줄의 코드로 복잡한 모델을 불러오고 실행할 수 있다. 파이프라인은 NLP에서 가장 자주 사용되는 작업들을 단순화하여 사용할 수 있게 도와준다.
   • 기본적으로 PyTorch와 TensorFlow를 모두 지원하며, 사용자 선호에 따라 쉽게 전환이 가능하다. PyTorch와 TensorFlow의 이중 지원은 연구 단계에서 실험을 위한 유연성과 실제 배포 단계에서의 최적화를 가능하게 한다. 이를 통해 사용자는 자신의 필요에 맞춰 두 프레임워크 사이를 자유롭게 오갈 수 있다.

3. 전이 학습(Fine-tuning)

   • 제공된 사전학습 모델을 바탕으로 사용자 정의 데이터셋에 맞게 모델을 재학습(전이 학습)할 수 있다. 이를 통해 특정 도메인이나 문제에 특화된 모델을 만드는 것이 가능하다. 예를 들어, 특정 산업에서의 고객 리뷰 분석이나 법률 문서의 분류 작업을 위해 Transformers 모델을 특화시킬 수 있다.
   • Fine-tuning을 지원하는 예제 코드와 튜토리얼이 풍부하게 제공되어 있어, 손쉽게 자신만의 모델을 구축할 수 있다. Hugging Face의 공식 문서와 예제들은 매우 상세하게 작성되어 있어, 처음 시작하는 사람도 쉽게 따라 할 수 있다. 전이 학습을 통해 모델을 사용자 정의하는 과정은 NLP 프로젝트에서 성능을 크게 향상시키는 중요한 단계이다.

Transformers 활용 예시

1. 텍스트 분류

   이 예시에서는 감정 분석(sentiment analysis)을 위해 pipeline을 사용한다. 간단한 한 줄 코드만으로 긍정적인 감정인지 부정적인 감정인지 분석할 수 있다. 감정 분석은 고객 피드백을 분석하거나, 소셜 미디어에서 브랜드에 대한 반응을 모니터링하는 데 유용하게 사용될 수 있다.

2. 질문 답변(Question Answering)

   이 코드를 통해 주어진 문맥에서 특정 질문에 대한 답을 찾아주는 기능을 수행할 수 있다. 질문 응답 시스템은 고객 지원, 교육, 정보 검색 등 다양한 분야에서 응용될 수 있으며, 사용자가 원하는 정보를 빠르게 제공할 수 있는 강력한 도구이다.

3. 텍스트 생성(Text Generation)

   이 예시는 GPT-2 모델을 활용해 주어진 문장의 이어지는 텍스트를 생성한다. 이러한 기능은 이야기 작성, 대화형 AI, 마케팅 문구 생성 등 다양한 분야에 응용될 수 있다. 특히 창의적인 글쓰기나 자동 응답 시스템 등에서 큰 도움을 줄 수 있다.

4. 번역(Translation)

   번역 작업 역시 Transformers 라이브러리를 통해 간단히 수행할 수 있다. 여러 언어 간의 번역은 국제 비즈니스 커뮤니케이션, 학술 연구 자료 이해 등에 활용될 수 있으며, 글로벌 시장에서의 언어 장벽을 허물어주는 역할을 한다.

사용 사례

Transformers는 자연어 처리의 거의 모든 응용 분야에 사용될 수 있다. 기업은 고객 피드백 분석이나 챗봇 개발에 활용하고, 연구자들은 최신 모델을 테스트하거나 새로운 NLP 기술을 개발하는 데 Transformers를 사용한다. 또한, 학계와 산업계에서는 전이 학습을 통해 자신만의 모델을 쉽게 구축하여 특수한 언어 모델을 만들기도 한다.

커뮤니티와 생태계

Hugging Face는 단순히 라이브러리 제공에서 그치지 않고, 모델 허브와 커뮤니티 포럼을 운영하여 전 세계의 연구자와 개발자들이 협력할 수 있도록 하고 있다. 누구나 자신의 모델을 업로드하거나 다른 사람들이 만든 모델을 자유롭게 사용할 수 있어, 모델의 개발과 사용이 훨씬 쉬워졌다.

모델 허브는 수천 개의 사전학습된 모델을 포함하고 있어, 사용자는 필요한 모델을 검색하고 바로 사용할 수 있다. 커뮤니티 포럼은 사용자가 직면한 문제를 서로 공유하고 해결책을 찾는 데 유용한 공간으로, Transformers의 성장을 이끄는 중요한 요소이다. Hugging Face는 이러한 협력적인 환경을 조성함으로써 NLP 연구의 속도를 가속화하고 있다.

마무리

Hugging Face의 Transformers는 최신 NLP 모델들을 손쉽게 사용하고 응용할 수 있는 매우 강력한 도구이다. 모델 구현의 복잡함을 덜어주고 누구나 최신 연구를 실용적으로 활용할 수 있게 해주는 이 라이브러리는 NLP 작업의 진입 장벽을 낮추고 있다. 다양한 기능과 활발한 커뮤니티 덕분에 앞으로도 많은 NLP 프로젝트에서 그 중요성을 계속 유지할 것으로 보인다.

이제 Hugging Face의 Transformers를 이용해 여러분의 NLP 프로젝트에 날개를 달아보자! 이를 통해 복잡한 자연어 처리 문제를 해결하고, 혁신적인 솔루션을 개발하며, 언어와 관련된 다양한 도전 과제를 극복해 나가기를 바란다.

Machine Reading Comprehension(MRC)은 머신이 자연어로 구성된 질문에 대해 주어진 텍스트에서 답변을 추출하거나 생성하는 작업을 의미한다. 전통적으로 MRC는 텍스트 내에 존재하는 정보를 기반으로 특정 답변을 추출하는 Extractive 방식이 주로 사용되었다. 하지만 최근에는 Generative-based 접근 방식이 점점 더 큰 주목을 받고 있다. 이러한 접근 방식은 질문에 대해 텍스트를 "생성"하는 모델을 활용해 보다 유연한 답변을 제공한다.

Generative-based MRC는 사전 학습된 대규모 언어 모델을 활용하여 답변을 생성한다. 이는 단순히 주어진 텍스트에서 정답을 찾는 것을 넘어, 보다 창의적이고 포괄적인 답변을 만들어내는 것을 목표로 한다. 대표적으로 GPT 계열 모델들이 이러한 역할을 수행할 수 있으며, 주어진 질문에 대해 훈련된 지식과 입력된 정보를 바탕으로 자연스러운 텍스트를 생성한다.

Generation-based MRC의 장점

이러한 방식의 장점은 두 가지로 요약할 수 있다. 첫째, Generative-based MRC는 주어진 정보로부터 직접적으로 답변을 추출하기 어려운 경우에도 답변을 만들어낼 수 있다. 예를 들어, 텍스트에 명시적으로 드러나지 않은 정보를 유추하거나 여러 문장을 연결해서 새로운 인사이트를 도출하는 것이 가능하다. 둘째, 인간의 언어와 비슷한 수준의 유연한 표현이 가능하다는 점이다. 따라서 사용자와의 상호작용에서 더 자연스러운 답변을 제공할 수 있으며, 다양한 질문 유형에 대응할 수 있다.

Generation-based MRC의 도전과제

하지만 Generative-based 접근 방식에는 몇 가지 도전 과제도 존재한다. 가장 큰 문제는 답변의 정확성이다. 생성 모델은 실제와 다른 정보를 만들어내는 경향이 있을 수 있어, 신뢰성을 보장하기 위해 추가적인 검증 절차가 필요하다. 또한 모델의 훈련 데이터에 의존하기 때문에, 편향된 데이터가 사용되면 편향된 답변을 생성할 위험도 존재한다.

Generative-based MRC는 이러한 한계를 극복하기 위해 강화 학습(RLHF)이나 인과적 추론(Chain-of-Thought)을 활용하여 더 정확하고 신뢰성 있는 답변을 생성하려는 노력이 지속되고 있다. 이를 통해 MRC 모델이 사람의 질문에 대해 보다 인간적인 방식으로 답변하고, 복잡한 문제를 해결하는 방향으로 발전하고 있다.

Generation-based MRC와 Extraction-based MRC 비교

1. 모델 구조: Seq-to-seq PLM(Generative) vs. PLM + Classifier(Extraction)
2. 답변 형태: 자유형 텍스트(Generative) vs. 지문 내 답 위치(Extraction)
   • Extraction-based MRC는 F1 계산을 위해 텍스트로 변환하는 과정이 필요하다.

Generation-based MRC Overview

Preprocessing

입력 텍스트는 토큰화 과정을 거친다. Word Piece Tokenizer가 주로 사용되며, 텍스트를 작은 단위로 나누어 인덱스로 변환한다. 모델의 기본 입력은 이러한 인덱스(input_ids)이다.

Special Tokens

PAD, CLS, SEP 토큰을 사용하거나, 대신 자연어를 이용하여 정해진 텍스트 포맷(format)으로 데이터를 생성할 수도 있다.

추가 정보 - 입력 표현

• Attention Mask: 어텐션 연산을 수행할지 결정한다.
• Token Type IDs: BART에는 token_type_ids가 없어 Extraction-based MRC의 BERT와 차이를 보인다.

Outputs - 정답 생성

• Extraction-based MRC는 시작/끝 토큰 위치를 출력하며, Generation-based MRC는 실제 텍스트 생성을 목표로 한다.(전체 시퀀스의 각 위치마다 모델이 아는 모든 단어들 중 하나의 단어를 맞추는 Classification 문제)

Models

BART

BART는 기계독해, 기계번역, 요약 등 sequence-to-sequence 문제의 사전 학습을 위한 디노이징 오토인코더 모델이다. 인코더는 BERT처럼 양방향(bi-directional), 디코더는 GPT처럼 단방향(uni-directional)이다.

• BART의 사전 학습(Pre-training): 텍스트에 노이즈를 주고 원래 텍스트를 복구하는 문제를 풀며 학습한다.

T5 (Text-to-Text Transfer Transformer)

T5는 모든 텍스트 처리 문제를 'text-to-text' 문제로 취급한다. 즉, 텍스트를 입력으로 받아 새로운 텍스트를 생성하는 것을 출력으로 하는 접근 방식을 사용한다. 이를 통해 번역, 요약, 질의응답 등 다양한 작업을 하나의 통일된 방식으로 처리할 수 있다.

Text-to-Text Framework

• 입출력 포맷: T5는 모든 작업을 자연어 문장이 들어가고 자연어 문장이 나오는 형태로 정의한다. 예를 들어 번역 작업에서는 'translate English to French: [입력 텍스트]'와 같은 형식으로 입력을 받으며, 요약 작업에서도 'summarize: [입력 텍스트]' 형태로 진행된다. 이처럼 각 작업에 대해 명시적인 지시어(prefix)를 사용하여 다양한 작업을 단일 모델로 수행할 수 있도록 설계되었다.

• Relative Position Encoding: Transformer 모델에서 위치 정보를 인코딩하는 방식으로, 기존의 절대적 위치 인코딩 대신 상대적 위치 인코딩을 사용하여 더 효과적인 문맥 이해를 가능하게 한다. 이는 특히 긴 문장이나 문맥에서 문장 간의 관계를 잘 포착하는 데 유리하다.

• Prefix 사용: 다운스트림 작업에 대한 fine-tuning 시, 각 작업에 대해 특정 prefix(예: 'translate', 'summarize', 'question answering' 등)를 입력에 추가한다. 현재는 Instruct라는 prefix 방식을 사용하여 모델이 특정 작업을 수행하도록 지시한다. 이를 통해 모델은 입력된 문장이 어떤 작업에 해당하는지를 이해하고, 해당 작업에 맞는 출력을 생성하게 된다.

T5의 사전 학습

Span 단위의 Masking(Replace corrupted spans)을 통해 원래 텍스트를 순차적으로 복구하는 문제를 품으로써 사전 학습한다.

다중 작업 학습(Multi-task Pre-training)

사전 학습 데이터셋과 self-supervised task로 변환된 다운스트림 작업들의 데이터셋을 결합하여 동시에 학습한다. 이 방식은 모델이 다양한 작업을 한꺼번에 학습하면서 일반화 능력을 높일 수 있도록 돕는다. 사전 학습 데이터셋은 대규모로 수집된 일반적인 텍스트 데이터를 사용하고, 다운스트림 작업들은 구체적인 문제(예: 번역, 요약, 질의응답 등)에 맞춰 변환된 데이터셋을 의미한다.

Post-processing

Decoding: 디코더의 출력이 다음 스텝의 입력으로 들어가는 autoregressive 방식이다. 맨 처음 입력은 문장 시작을 뜻하는 스페셜 토큰이다.

Searching: 보통 Beam Search나 Sampling 기법을 이용해 답변을 생성한다. Beam Search는 여러 후보를 동시에 탐색하여 가장 가능성이 높은 답변을 선택하는 방식이며, Sampling 기법은 확률적으로 다양한 답변을 생성해 더 창의적인 답변을 제공할 수 있다.

Extraction-based Machine Reading Comprehension (MRC)은 자연어 처리에서 주어진 텍스트에서 질문에 대한 답을 직접적으로 추출하는 접근법이다. 이 방법은 문서에서 이름, 날짜, 정의와 같은 특정 정보를 효율적으로 찾는 데 유용하며, 많은 질문-응답 시스템의 기반이 된다.

Extractive MRC 시스템은 텍스트와 질문을 입력으로 받아 텍스트 내에서 정답일 가능성이 높은 부분(위치)을 예측한다. 이를 위해 BERT, RoBERTa와 같은 트랜스포머 기반 모델들이 자주 사용된다. 이 모델들은 질문과 텍스트를 함께 인코딩함으로써, 질문의 의미에 맞는 텍스트의 중요한 부분에 집중할 수 있도록 한다.

이 과정은 질문과 텍스트를 동일한 임베딩 공간으로 인코딩하는 것에서 시작한다. 이를 통해 모델은 질문과 텍스트 간의 상관관계를 파악할 수 있게 된다. 모델은 텍스트 내 각 단어의 위치에 대해 소프트맥스 함수를 적용하여 답변이 시작되는 위치와 끝나는 위치를 예측하고, 이를 통해 답변 범위를 추출한다.

Extraction-based MRC의 장단점

Extractive MRC의 장점 중 하나는 텍스트에서 직접 정답을 선택하기 때문에 정보의 정확성을 유지할 수 있다는 것이다. 이는 잘못된 정보 생성의 위험을 줄여주며, 특히 고객 서비스 챗봇, 법률 문서 분석, 학술 연구와 같이 높은 정확성이 요구되는 분야에서 유용하다.

그러나 이 접근법에는 몇 가지 한계가 존재한다. 텍스트에서 정확히 일치하는 답을 찾아야 하므로, 답이 명시적으로 나타나 있지 않거나 여러 문장에 걸쳐 종합적인 이해가 필요한 경우 모델이 어려움을 겪을 수 있다. 또한, 모호한 질문이나 추론을 필요로 하는 질문에 대해서는 잘 대응하지 못하는 경우가 많다. 이러한 점은 생성적 또는 요약 기반의 MRC 접근법에 비해 한계로 작용한다.

Extraction-based MRC Overview

1. Pre-processing for Extractive MRC (전처리)

Tokenization

• Special Tokens: 문서와 질문을 구분하기 위해 특별한 토큰([CLS], [SEP] 등)을 사용한다.
• Attention Mask: 모델이 유효한 토큰에만 집중하도록 마스크를 사용한다.
• Token Type IDs: 문서와 질문을 구별하기 위해 각 토큰에 문서 또는 질문의 타입을 표시한다.

Text Normalization

• 대소문자 통일, 공백 처리, 특수문자 제거 등을 통해 입력 텍스트를 정규화한다.
• 불필요한 토큰이나 기호를 제거하여 모델의 학습 성능을 높인다.

2. Processing for Extractive MRC

정답은 문서 내에 있는 연속된 단어 토큰(span)이기 때문에, span의 시작과 끝 위치를 알면 정답을 찾을 수 있다. 따라서 Extraction-based 접근법에서는 답안을 새로 생성하는 대신, 시작 위치와 끝 위치를 예측하도록 모델을 학습시킨다. 이는 곧 Token Classification 문제로 변환하는 것과 같은 방식이다.

모델 아키텍처

1. Transformer 기반 모델(BERT, RoBERTa 등)을 사용하여 문서와 질문을 함께 인코딩한다.
2. 모델은 질문과 문서의 관계를 파악하여, 문서 내에서 답변이 될 수 있는 span의 시작과 끝 위치를 예측한다.

3. Post-processing for Extractive MRC (후처리)

불가능한 답 제거하기

다음과 같은 경우 candidate list에서 제거

• End position이 start position보다 앞에 있는 경우 (e.g. start=90, end=80)
• 예측한 위치가 context를 벗어난 경우 (e.g. question 위치 쪽에 답이 나온 경우)
• 미리 설정한 max_answer_length보다 길이가 더 긴 경우

최적의 답안 찾기

1. Start/end position prediction에서 score(logits)가 가장 높은 N개를 각각 찾는다.
2. 불가능한 start/end 조합을 제거한다.
3. 가능한 조합들을 score의 합이 큰 순서대로 정렬한다.
4. Score가 가장 큰 조합을 최종 예측으로 선정한다.
5. Top-k가 필요한 경우 차례대로 내보낸다.

정답 후보 필터링 및 가중치 조정

• 여러 개의 가능한 답변이 있는 경우, 각 답변의 확률을 기반으로 필터링하고, 필요에 따라 가중치를 조정하여 최종 정답을 선정한다.
• 모델의 예측 결과가 여러 답변 후보를 포함할 때, 각 후보의 가중치를 평가하여 최적의 답변을 선택한다.

Error Analysis

• 모델이 오답을 선택한 경우 그 원인을 분석하여 학습 데이터나 모델 구조를 개선할 수 있는 인사이트를 제공한다.
• 정답이 여러 문장에 걸쳐 있거나, 문맥적으로 복잡한 질문에 대해 모델이 오류를 범하는 경우를 파악하고 이를 개선하기 위한 방법을 도출한다.

이 글은 Sparse Embedding과 Dense Embedding을 사용한 Reranking에 대해 설명한다. Reranking 작업은 정보 검색 및 추천 시스템에서 높은 정확도를 제공하기 위해 일반적으로 사용된다. 기본적인 검색 단계에서 다수의 후보 항목을 빠르게 선별한 다음, 이 후보들을 다시 평가하여 최종적인 순위를 매기는 방식이다.

Sparse와 Dense를 활용한 Rerank

기본 검색 단계에서 Sparse Embedding을 사용하여 후보 문서를 빠르게 찾은 후, Dense Embedding을 이용해 Reranking하는 방식은 효과적이다. 이 방식은 다음과 같은 단계로 이루어진다.

Sparse Retrieval (기본 검색):

초기 검색 단계에서는 빠른 검색이 필요하기 때문에 주로 Sparse Embedding을 사용한다.

예를 들어, 사용자가 입력한 쿼리에 대해 BM25 같은 모델을 이용하여 초기 후보 문서 집합을 빠르게 검색한다.

이 단계의 결과물은 수백에서 수천 개의 문서가 될 수 있으며, 이들은 고전적인 키워드 매칭을 통해 필터링된다.

Dense Rerank (재정렬):

초기 단계에서 추출된 후보 문서를 대상으로 Dense Embedding을 사용해 Reranking한다.

이 과정에서 BERT나 Siamese Network와 같은 딥러닝 기반의 임베딩 모델을 이용해 각 문서와 쿼리의 의미적 유사도를 계산한다.

Dense Embedding은 문서의 의미적 내용을 잘 포착할 수 있기 때문에 더 정교한 순위를 매길 수 있다.

예를 들어, BERT를 사용해 쿼리와 문서 간의 상호작용을 인코딩하고, 문서의 순위를 정교하게 재조정하는 방식이다.

Rerank의 방식

1. Bi-encoder 방식

구조: Bi-encoder는 두 개의 문장을 독립적으로 인코딩하여 고차원의 벡터로 표현한다. 일반적으로 쿼리와 후보 문서를 각각 독립된 신경망(대부분은 동일한 파라미터를 공유하는 BERT나 다른 트랜스포머 모델)을 통해 임베딩하고, 이 두 임베딩의 유사도를 계산하여 관련성을 측정한다.

사용 시나리오: 이 방식은 대량의 후보 문서를 빠르게 처리해야 하는 상황에서 유용하다. 쿼리와 문서의 벡터를 독립적으로 계산한 후, 벡터 간의 내적이나 코사인 유사도를 계산하는 방식이므로 효율적이다.

장점: 효율적인 계산과 저장이 가능하다. 사전에 후보 문서들을 임베딩하여 데이터베이스에 저장해 두고, 쿼리가 들어오면 빠르게 유사도를 계산할 수 있다.

단점: 쿼리와 문서를 독립적으로 인코딩하기 때문에 문맥에 따라 상호작용하는 정보가 충분히 반영되지 않을 수 있다. 특히, 더 미묘한 상호작용이 필요한 복잡한 질문에 대해선 정확도가 떨어질 수 있다.

2. Cross-encoder 방식

구조: Cross-encoder는 쿼리와 문서를 하나의 입력으로 합쳐 트랜스포머 모델에 넣어 인코딩한다. 예를 들어 [CLS] 쿼리 [SEP] 문서 [SEP] 형식으로 쿼리와 문서를 동시에 인코딩하고, 이를 통해 두 텍스트 간의 관련성을 예측한다.

사용 시나리오: 정확도가 매우 중요한 경우, 특히 최종 순위를 매기는 재정렬 작업에서 자주 사용된다. 모델이 두 문장 간의 상호작용을 충분히 반영할 수 있기 때문에 더 정밀한 관련성 판단이 가능하다.

장점: 쿼리와 문서를 하나의 입력으로 합쳐 모델에 넣기 때문에 문맥적인 상호작용이 잘 반영되며, 더 높은 정확도를 얻을 수 있다.

단점: 계산 비용이 높다. 쿼리가 들어올 때마다 쿼리와 모든 후보 문서를 조합하여 모델을 통해 인코딩해야 하므로, 대규모 데이터셋에서는 비효율적이다.

Hybrid Approach (결합 접근)

Sparse와 Dense를 결합하는 하이브리드 방법을 사용하는 경우도 있다. 이 방식은 각 Embedding의 장점을 결합하여 최적의 성능을 달성한다.

Sparse Embedding은 키워드 매칭을 잘 처리하기 때문에 특정 단어가 반드시 포함된 결과를 찾는 데 유리하다.

Dense Embedding은 의미적 유사도를 잘 반영하기 때문에 관련성은 있지만 정확히 같은 단어를 사용하지 않은 문서도 잘 찾을 수 있다.

이 두 Embedding을 Concat하거나 가중 평균을 구해 쿼리와 문서 간의 유사도를 측정하고, 최종적으로 순위를 매기는 방식으로 활용할 수 있다.

Bi-encoder Rerank

✅ 이번 실습에서는 하나의 query가 아닌 복수의 queries를 한번에 처리한다.

Dataset 로드하기

[Input]

from datasets import load_dataset

dataset = load_dataset("squad_kor_v1")

Tokenizer 준비하기

[Input]

from transformers import AutoTokenizer

model_checkpoint = "BM-K/KoSimCSE-roberta-multitask"
tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)

데이터 샘플 준비하기

[Input]

import numpy as np
import random

random.seed(42)

num_samples = 128
sample_idx = np.random.choice(range(len(dataset['train'])), num_samples)
contexts = dataset['train'][sample_idx]['context']
queries = dataset['train'][sample_idx]['question']
ground_truth = dataset['train'][sample_idx]['context']

print(len(contexts), len(queries), len(ground_truth))

[output]

>>  128 128 128

✅ 128개의 랜덤 샘플만 사용하여 데이터를 구성한다. KorQuAD 데이터셋의 context, question feature를 사용해 Retrieval를 실습해 볼 수 있다. ▶ KorQuAD란 무엇일까?

First Step. Sparse Embedding (TF-IDF)

[Input]

def tokenizer_for_retrieve(text):
    tokens = tokenizer.tokenize(text, max_length=512, truncation=True)
    return tokens

from sklearn.feature_extraction.text import TfidfVectorizer
vectorizer = TfidfVectorizer(tokenizer=tokenizer_for_retrieve)

vectorizer.fit(contexts)
contexts_vec = vectorizer.transform(contexts)
queries_vec = vectorizer.transform(queries)

print(contexts_vec.shape, queries_vec.shape)

[output]

>>  (128, 6285) (128, 6285)

✅ contexts와 query를 TF-IDF를 사용해 임베딩한다. ▶ TF-IDF가 기억나지 않는다면?

Sparse Embedding 유사도 측정 (TF-IDF)

[Input]

result = queries_vec * contexts_vec.T
print(result.shape)

[output]

>>  (128, 128)

✅ 128개의 쿼리와 128개의 문장간의 유사도 점수

Sparse Embedding Top-K 추출하기 (TF-IDF)

[Input]

doc_scores = []
doc_indices = []
k = 50

if not isinstance(result, np.ndarray):
  result = result.toarray()
for i in range(result.shape[0]):
  sorted_result = np.argsort(result[i, :])[::-1]
  doc_scores.append(result[i, :][sorted_result].tolist()[:k])
  doc_indices.append(sorted_result.tolist()[:k])

tfidf_output = {'question': queries, 
                'contexts': [[contexts[i] for i in doc_ids] for doc_ids in doc_indices], 
                'answer': ground_truth,
                'scores': doc_scores}

tfidf_output_df = pd.DataFrame(tfidf_output)
tfidf_output_df["correct"] = tfidf_output_df.apply(lambda row: row["answer"] in row["contexts"], axis=1)

✅ 128개의 각각의 쿼리에 대해 유사도가 높은 50개의 contexts와 doc_scores(유사도 점수)를 저장한다.

Sparse Embedding Ranking 확인하기 (TF-IDF)

[Input]

example_idx = 0
example_question = queries[example_idx]
example_answer = ground_truth[example_idx]
doc_scores_by_example = doc_scores[example_idx]
doc_indices_by_example = doc_indices[example_idx]


print("[Search query]\n", example_question, "\n")

print("[Ground truth passage]")
print(example_answer, "\n")

for i in range(k):
  print("Top-%d passage with score %.4f" % (i + 1, doc_scores_by_example[i]))
  doc_id = doc_indices_by_example[i]
  print(contexts[doc_id], "\n")

[output]

>>  [Search query]
    2010년 8월 17일 FFF의 징계 청문회 후 징계를 면한 사람은? 

    [Ground truth passage]
    니콜라 아넬카, 파트리스 에브라, 프랑크 리베리, 제레미 툴랄랑, 그리고 에리크 아비달이 FIFA 월드컵 기간동안 주요 사건에 연루된 5명이었고, 2010년 8월 17일에 FFF의 징계 청문회로 소환되었다. ...

    Top-1 passage with score 0.1007
    니콜라 아넬카, 파트리스 에브라, 프랑크 리베리, 제레미 툴랄랑, 그리고 에리크 아비달이 FIFA 월드컵 기간동안 주요 사건에 연루된 5명이었고, 2010년 8월 17일에 FFF의 징계 청문회로 소환되었다. ...

    Top-2 passage with score 0.0452
    죽음은 죽은 사람에게만 비참을 가져오는 것은 아니다. 사망자가 앞서가 남겨진 산 사람에는 고독이 남겨진다. 산 사람이 친밀한 사람의 죽음의 정산에 실패하면 큰 후회가 남겨져 대단한 고통에 괴롭혀지게 된다. ...

    Top-3 passage with score 0.0390
    《Prism》은 2013년 10월 18일 발매되었고, 빌보드 200 1위로 데뷔했다. 네 달 후 페리는 로스앤젤레스에서 열린 iHeartRadio에서 앨범의 수록곡들을 선보였다. ...

    ...

✅ 예시로 첫번째 쿼리에 대해 잘 예측하는 지 확인

Sparse Embedding 결과 보기 (TF-IDF)

[Input]

print(len(tfidf_output['question']))
print(len(tfidf_output['answer']))
print(len(tfidf_output['contexts'][0]))
print(len(tfidf_output['scores'][0]))

[output]

>>  128
    128
    50
    50

✅ tfidf_output에는 128개의 question과 answer, 그리고 각각의 question에는 topk=50의 contexts와 scores가 저장되었다.

Dense Embedding (Bi-encoder)

✅ Dense Embedding 학습을 구성하는 과정은 Dense Embedding 과 동일하다.

[Input]

from tqdm import tqdm, trange
import argparse
import random
import torch
import torch.nn.functional as F
from transformers import BertModel, BertPreTrainedModel, AdamW, TrainingArguments, get_linear_schedule_with_warmup

torch.manual_seed(42)
torch.cuda.manual_seed(42)
np.random.seed(42)

학습용 데이터 셋 구성하기

[Input]

from torch.utils.data import (DataLoader, RandomSampler, TensorDataset)

q_seqs = tokenizer(queries, padding="max_length", truncation=True, return_tensors='pt')
p_seqs = tokenizer(contexts, padding="max_length", truncation=True, return_tensors='pt')

train_dataset = TensorDataset(p_seqs['input_ids'], p_seqs['attention_mask'], p_seqs['token_type_ids'],
                              q_seqs['input_ids'], q_seqs['attention_mask'], q_seqs['token_type_ids'])

BertEncoder 구성하기 (Bi-encoder)

[Input]

class BertEncoder(BertPreTrainedModel):
  def __init__(self, config):
    super(BertEncoder, self).__init__(config)

    self.bert = BertModel(config)
    self.init_weights()

  def forward(self, input_ids,
              attention_mask=None, token_type_ids=None):

      outputs = self.bert(input_ids,
                          attention_mask=attention_mask,
                          token_type_ids=token_type_ids)

      pooled_output = outputs[1]

      return pooled_output

p_encoder = BertEncoder.from_pretrained(model_checkpoint)
q_encoder = BertEncoder.from_pretrained(model_checkpoint)

if torch.cuda.is_available():
  p_encoder.cuda()
  q_encoder.cuda()

BertEncoder 학습하기

[Input]

def train(args, dataset, p_model, q_model):

  # Dataloader
  train_sampler = RandomSampler(dataset)
  train_dataloader = DataLoader(dataset, sampler=train_sampler, batch_size=args.per_device_train_batch_size)


  no_decay = ['bias', 'LayerNorm.weight']
  optimizer_grouped_parameters = [
        {'params': [p for n, p in p_model.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': args.weight_decay},
        {'params': [p for n, p in p_model.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},
        {'params': [p for n, p in q_model.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': args.weight_decay},
        {'params': [p for n, p in q_model.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}
        ]

  optimizer = AdamW(optimizer_grouped_parameters, lr=args.learning_rate, eps=args.adam_epsilon)

  t_total = len(train_dataloader) // args.gradient_accumulation_steps * args.num_train_epochs
  scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=args.warmup_steps, num_training_steps=t_total)

  # Start training!
  global_step = 0

  p_model.zero_grad()
  q_model.zero_grad()
  torch.cuda.empty_cache()

  train_iterator = trange(int(args.num_train_epochs), desc="Epoch")

  for _ in train_iterator:
    epoch_iterator = tqdm(train_dataloader, desc="Iteration")

    for step, batch in enumerate(epoch_iterator):
      q_encoder.train()
      p_encoder.train()

      if torch.cuda.is_available():
        batch = tuple(t.cuda() for t in batch)

      p_inputs = {'input_ids': batch[0],
                  'attention_mask': batch[1],
                  'token_type_ids': batch[2]
                  }

      q_inputs = {'input_ids': batch[3],
                  'attention_mask': batch[4],
                  'token_type_ids': batch[5]}

      p_outputs = p_model(**p_inputs)  # (batch_size, emb_dim)
      q_outputs = q_model(**q_inputs)  # (batch_size, emb_dim)


      # Calculate similarity score & loss
      sim_scores = torch.matmul(q_outputs, torch.transpose(p_outputs, 0, 1))  # (batch_size, emb_dim) x (emb_dim, batch_size) = (batch_size, batch_size)

      # target: position of positive samples = diagonal element
      targets = torch.arange(0, args.per_device_train_batch_size).long()
      if torch.cuda.is_available():
        targets = targets.to('cuda')

      sim_scores = F.log_softmax(sim_scores, dim=1)

      loss = F.nll_loss(sim_scores, targets)

      loss.backward()
      optimizer.step()
      scheduler.step()
      q_model.zero_grad()
      p_model.zero_grad()
      global_step += 1

      torch.cuda.empty_cache()


  return p_model, q_model

[Input]

args = TrainingArguments(
    output_dir="dense_retireval",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=2,
    per_device_eval_batch_size=2,
    num_train_epochs=2,
    weight_decay=0.01
)

p_encoder, q_encoder = train(args, train_dataset, p_encoder, q_encoder)

Sparse Embedding Top-K 결과를 바탕으로 Dense Embedding 하기

[Input]

import torch

batch_size = 64

with torch.no_grad():
    p_encoder.eval()
    q_encoder.eval()

    # Query를 배치로 토큰화하고 임베딩
    all_q_embs = []
    for i in range(0, len(queries), batch_size):
        batch_queries = queries[i:i + batch_size]
        q_seqs_val = tokenizer(batch_queries, padding="max_length", truncation=True, return_tensors='pt').to('cuda')
        q_emb_batch = q_encoder(**q_seqs_val)  # (batch_size, emb_dim)
        all_q_embs.append(q_emb_batch)

    # 배치로 처리한 임베딩들을 하나로 병합
    q_emb = torch.cat(all_q_embs, dim=0)  # (num_query, emb_dim)

    # contexts의 3차원 데이터를 2차원으로 풀어내서 배치 처리
    flattened_contexts = [p for context_list in tfidf_output['contexts'] for p in context_list]
    total_passages = len(flattened_contexts)  # 128 * 50 = 6400
    print(f'Total passages: {total_passages}')  # 6400

    # Passage 임베딩을 배치로 처리
    all_p_embs = []
    for i in range(0, total_passages, batch_size):
        batch_contexts = flattened_contexts[i:i + batch_size]
        p_seqs_val = tokenizer(batch_contexts, padding="max_length", truncation=True, return_tensors='pt').to('cuda')
        p_emb_batch = p_encoder(**p_seqs_val)  # (batch_size, emb_dim)
        all_p_embs.append(p_emb_batch)

    p_embs = torch.cat(all_p_embs, dim=0)  # (total_passages, emb_dim)
    p_embs = p_embs.view(len(tfidf_output['contexts']), -1, p_embs.size(-1))

    print(f'p_embs shape: {p_embs.shape}')  # (128, 50, emb_dim)

✅ 학습된 Encoder를 활용해서 question과 contexts를 임베딩한다. 병렬처리를 위해 contexts를 flatten 후 임베딩하고 원래의 상태로 반환하는 과정을 진행하였다. 임베딩 또한 배치단위로 진행된다.

Dense Embedding을 바탕으로 유사도 측정

[Input]

q_emb = q_emb.unsqueeze(1) # query_embeddings은 (128, 1, 768)이고 passage_embeddings는 (128, 50, 768)

# 1. Cosine Similarity
cosine_similarities = F.cosine_similarity(q_emb, p_embs, dim=-1)  # (128, 50)
# 2. Dot Product Similarity
dot_product_similarities = torch.matmul(q_emb, p_embs.transpose(-1, -2))  
dot_product_similarities = dot_product_similarities.squeeze(1) # (128, 50)

print(dot_product_similarities.shape)  

[Output]

>> (128, 50)

✅ 128개의 question과 TF-IDF로 필터링한 50개의 context사이의 유사도이다.

Dense Embedding Re-ranked Top-K 추출하기

[Input]

reranked_doc_scores = []
reranked_doc_indices = []
k_rerank = 5

# 각 쿼리마다 유사도 기반으로 랭킹을 계산
for i in range(dot_product_similarities.size(0)):  # 쿼리 개수(128)
    # 각 쿼리와 50개의 패시지 간의 유사도를 정렬 (내림차순으로)
    rank = torch.argsort(dot_product_similarities[i], dim=-1, descending=True)
    reranked_doc_scores.append(dot_product_similarities[i][rank][:k_rerank].tolist())
    reranked_doc_indices.append(rank[:k_rerank].tolist())

DPR_output = {
    'question': queries,
    'contexts': [
        [tfidf_output['contexts'][i][idx] for idx in doc_ids]
        for i, doc_ids in enumerate(reranked_doc_indices)
    ],
    'answer': ground_truth,
    'scores': reranked_doc_scores
}

DPR_output_df = pd.DataFrame(DPR_output)
DPR_output_df["correct"] = DPR_output_df.apply(lambda row: row["answer"] in row["contexts"], axis=1)

✅ 이전 스텝(TF-IDF)에서 진행한 것과 같이 128개의 question에 대해 50개의 context 중에 Dense Embedding Similarity로 재정렬된 5개의 context와 socers만 DPR_output에 저장한다.

Dense Embedding Re-ranked Top-K 확인하기

[Input]

k = 5  # 상위 k개의 패시지 출력
query_idx = 0  # 첫 번째 쿼리의 인덱스 

# 첫 번째 쿼리에 대해 상위 k개의 패시지 랭킹을 출력
query = tfidf_output['question'][query_idx]
rank = reranked_doc_indices[query_idx] # 첫 번째 쿼리의 랭킹

print("[Search query]\n", query, "\n")
print("[Ground truth passage]")
print(ground_truth[query_idx], "\n")

# dot_prod_scores는 torch 텐서이므로 CPU로 옮기고 점수 확인
dot_prod_scores_query = dot_product_similarities[query_idx].cpu().numpy()  # 첫 번째 쿼리의 유사도 점수

# 상위 k개의 패시지와 점수 출력
for i in range(k):
    top_idx = rank[i]
    print(f"Top-{i+1} passage with score {dot_prod_scores_query[top_idx]:.4f}")
    print(tfidf_output['contexts'][query_idx][top_idx])
    print()

[Output]

[Search query]
 토너먼트 팔씨름에서 우승한 팀이 영입한 선수는? 

[Ground truth passage]
팀원 트레이드는 더욱 더 강한 팀을 만들기 위한 취지로 도입된 제도로서 트레이드 우선권 순으로 상대팀 에이스 1명과 자신의 팀 1명을 교환할 수 있다. ...

Top-1 passage with score 17.8967
팀원 트레이드는 더욱 더 강한 팀을 만들기 위한 취지로 도입된 제도로서 트레이드 우선권 순으로 상대팀 에이스 1명과 자신의 팀 1명을 교환할 수 있다. ...

Top-2 passage with score 13.7799
2015년 2월 26일 서울 태릉빙상경기장에서 열린 제96회 전국동계체전 대학부 3000m에 출전한 김보름(대구)이 대학부 3000m 4연패를 달성했다. ...

Top-3 passage with score 13.6980
그러나 그는 여기서 물러서지 않았다. 이윽고 펼쳐진 CYON MBC게임 스타리그 승자결승까지 진출한 그는 다시 한 번 지난 리그와 같은 위치에서 마재윤을 만났다. ...

Top-4 passage with score 13.4651
2014년 7월 11일부터 2014년 8월 29일까지 온게임넷을 통해 방송된 리그이다. 진행방식은 토너먼트 방식으로 8강과 3-4위전은 3판 2선승제, 4강과 결승전은 5판 3선승제로 진행되었다. ...

Top-5 passage with score 12.5125
2010년 말 현역 시절 활약하였던 포항 스틸러스의 부름을 받아 포항의 감독으로 부임하였고, 2011 시즌부터 포항을 이끌었다. ...

Re-rank Retriver 정확도 측정

[Input]

print("correct Re-rank retrieval result by exhaustive search", DPR_output_df["correct"].sum() / len(DPR_output_df['contexts']))

[Output]

>> correct Re-rank retrieval result by exhaustive search 0.9306640625

✅ 전체 128개의 Query에 대한 5개의 Retrieved Passage(contexts) 중 정답 Passage(contexts)가 포함될 확률을 나타낸다.

Cross-Encoder Re-rank

기본적으로 STS(Semantic Textual Similarity) Task를 사용해 Query와 Passage사이의 유사도를 구한다.

🚧 추후 정리 해보도록 하자 🚧

Dense Embedding은 데이터의 의미를 고차원 공간에 압축해 표현하는 방법으로, 유사도 측정에 있어 Dense Embedding은 매우 중요한 역할을 한다. 여기서는 Dense Embedding의 개념과 이를 이용한 유사도 측정 방법에 대해 설명한다.

Dense Embedding은 고차원의 벡터로, 문장이나 단어, 이미지와 같은 데이터를 수치화하여 나타낸 것이다. 이러한 벡터는 딥러닝 모델을 통해 학습되며, 데이터 간의 의미적 유사도를 잘 반영하도록 설계된다. 예를 들어, '고양이'와 '동물'이라는 단어는 비슷한 의미를 가지기 때문에, Dense Embedding으로 표현했을 때 이 두 단어의 벡터는 서로 가까운 위치에 있을 것이다.

Dense Embedding을 사용해 유사도를 측정할 때 가장 많이 활용되는 방법은 코사인 유사도(Cosine Similarity)이다. 코사인 유사도는 두 벡터 간의 각도를 측정하여 얼마나 비슷한 방향을 가리키고 있는지를 평가한다. 수식으로는 다음과 같이 정의된다:

$ \text{Cosine Similarity}(\mathbf{A}, \mathbf{B}) = \frac{\mathbf{A} \cdot \mathbf{B}}{|\mathbf{A}| |\mathbf{B}|} $

여기서:

• $\mathbf{A}$와 $\mathbf{B}$는 비교하려는 두 벡터이다.
• $\mathbf{A} \cdot \mathbf{B}$는 두 벡터의 내적이다.
• $|\mathbf{A}|$와 $|\mathbf{B}|$는 각각 벡터 $\mathbf{A}$와 $\mathbf{B}$의 크기(또는 노름)이다.

코사인 유사도의 값은 -1에서 1 사이에 있으며, 1에 가까울수록 두 벡터의 방향이 매우 비슷함을 의미하고, 0에 가까울수록 직교에 가깝고, -1에 가까울수록 반대 방향을 가리킨다.

또 다른 방법으로는 유클리드 거리(Euclidean Distance) 또는 점수 함수(Score Function) 등을 활용할 수 있다. 유클리드 거리는 두 벡터 사이의 직선 거리를 계산하여 유사도를 측정하는 방식이며, 거리가 짧을수록 두 데이터가 더 유사하다고 볼 수 있다. 반면 점수 함수는 특정 목적을 위해 설계된 함수로, 예를 들어 검색엔진에서 쿼리와 문서의 관련성을 평가할 때 사용될 수 있다.

Dense Embedding의 특징은 고차원 공간에서 데이터를 압축하고, 의미적 유사성을 잘 반영한다는 것이다. 이는 기존의 Bag of Words와 같은 Sparse Representation 방식과 달리, 단어의 순서나 문맥을 잘 반영하여 유사도 측정의 정밀도를 높여준다. 특히 BERT와 같은 사전학습된 언어 모델을 통해 얻어진 Dense Embedding은 문장의 의미를 깊이 있게 표현하며, 이로 인해 보다 정밀한 유사도 계산이 가능해졌다.

BERT를 활용한 Dense Passage Retrieval

데이터셋 로딩

[Input]

from datasets import load_dataset

dataset = load_dataset("squad_kor_v1")

토크나이저 준비 & 데이터 확인

[Input]

from transformers import AutoTokenizer

model_checkpoint = "BM-K/KoSimCSE-roberta-multitask"
tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)

tokenized_input = tokenizer(dataset['train'][0]['context'], padding="max_length", truncation=True)
decoded_tokens = tokenizer.decode(tokenized_input['input_ids'])
print(decoded_tokens)

[output]

>>  [CLS] 1839년 바그너는 괴테의 파우스트을 처음 읽고 그 내용에 마음이 끌려 이를 소재로 해서 하나의 교향곡을 쓰려는 뜻을 갖는다. 이 시기 바그너는 1838년에 빛 독촉으로 산전수전을 다 [UNK] 상황이라 좌절과 실망에 가득했으며 메피스토펠레스를 만나는 파우스트의 심경에 공감했다고 한다. 또한 파리에서 아브네크의 지휘로 파리 음악원 관현악단이 연주하는 베토벤의 교향곡 9번을 듣고 깊은 감명을 받았는데, 이것이 이듬해 1월에 파우스트의 서곡으로 쓰여진 이 작품에 조금이라도 영향을 끼쳤으리라는 것은 의심할 여지가 없다. 여기의 라단조 조성의 경우에도 그의 전기에 적혀 있는 것처럼 단순한 정신적 피로나 실의가 반영된 것이 아니라 베토벤의 합창교향곡 조성의 영향을 받은 것을 볼 수 있다. 그렇게 교향곡 작곡을 1839년부터 40년에 걸쳐 파리에서 착수했으나 1악장을 쓴 뒤에 중단했다. 또한 작품의 완성과 동시에 그는 이 서곡 ( 1악장 ) 을 파리 음악원의 연주회에서 연주할 파트보까지 준비하였으나, 실제로는 이루어지지는 않았다. 결국 초연은 4년 반이 지난 후에 드레스덴에서 연주되었고 재연도 이루어졌지만, 이후에 그대로 방치되고 말았다. 그 사이에 그는 리엔치와 방황하는 네덜란드인을 완성하고 탄호이저에도 착수하는 등 분주한 시간을 보냈는데, 그런 바쁜 생활이 이 곡을 잊게 한 것이 아닌가 하는 의견도 있다. [SEP] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD]

Dense encoder (BERT) 학습 시키기

[Input]

from tqdm import tqdm, trange
import argparse
import random
import torch
import torch.nn.functional as F
from transformers import BertModel, BertPreTrainedModel, AdamW, TrainingArguments, get_linear_schedule_with_warmup

torch.manual_seed(42)
torch.cuda.manual_seed(42)
np.random.seed(42)
random.seed(42)

Training Dataset 샘플 준비 & 토큰화 & Train Data 재구성

[Input]

sample_idx = np.random.choice(range(len(dataset['train'])), 128)
training_dataset = dataset['train'][sample_idx]

from torch.utils.data import (DataLoader, RandomSampler, TensorDataset)

q_seqs = tokenizer(training_dataset['question'], padding="max_length", truncation=True, return_tensors='pt')
p_seqs = tokenizer(training_dataset['context'], padding="max_length", truncation=True, return_tensors='pt')

train_dataset = TensorDataset(p_seqs['input_ids'], p_seqs['attention_mask'], p_seqs['token_type_ids'],
                              q_seqs['input_ids'], q_seqs['attention_mask'], q_seqs['token_type_ids'])

✅ training_dataset은 dataset['train']에서 random으로 128개의 샘플만 추출하여 사용하고 question과 context를 토큰화해서 하나의 데이터셋에 담는다.

BERT encoder

[Input]

class BertEncoder(BertPreTrainedModel):
  def __init__(self, config):
    super(BertEncoder, self).__init__(config)

    self.bert = BertModel(config)
    self.init_weights()

  def forward(self, input_ids, attention_mask=None, token_type_ids=None):

    outputs = self.bert(input_ids,
                        attention_mask=attention_mask,
                        token_type_ids=token_type_ids)

    pooled_output = outputs[1]

    return pooled_output

p_encoder = BertEncoder.from_pretrained(model_checkpoint)
q_encoder = BertEncoder.from_pretrained(model_checkpoint)

if torch.cuda.is_available():
  p_encoder.cuda()
  q_encoder.cuda()

✅ BertPreTrainedModel Class를 상속받아 CLS 토큰에 해당하는 출력층 토큰 outputs[1]을 사용한다.

*outputs[1] corresponds to the pooled output, which is derived from the [CLS] token. * In the outputs returned by BertModel, outputs[0] is the last hidden state (representations of all tokens in the sequence), and outputs[1] is the pooled output (the representation of the [CLS] token after a pooling operation).

Encoder fine-tuning

[Input]

def train(args, dataset, p_model, q_model):

  # Dataloader
  train_sampler = RandomSampler(dataset)
  train_dataloader = DataLoader(dataset, sampler=train_sampler, batch_size=args.per_device_train_batch_size)


  no_decay = ['bias', 'LayerNorm.weight']
  optimizer_grouped_parameters = [
        {'params': [p for n, p in p_model.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': args.weight_decay},
        {'params': [p for n, p in p_model.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},
        {'params': [p for n, p in q_model.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': args.weight_decay},
        {'params': [p for n, p in q_model.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}
        ]

✅ weight_decay를 사용하지 않을 부분을 지정한다.

✅ Weight decay를 적용하지 않는 이유: Bias 파라미터: 모델의 편향 학습에 중요하며, 불필요한 규제로 인해 성능 저하를 방지하기 위해 제외. LayerNorm.weight 파라미터: 입력 데이터의 스케일 조절에 필요하며, weight decay로 인해 정규화 효과가 감소하는 것을 방지하기 위해 제외.

  optimizer = AdamW(optimizer_grouped_parameters, lr=args.learning_rate, eps=args.adam_epsilon)

  t_total = len(train_dataloader) // args.gradient_accumulation_steps * args.num_train_epochs
  scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=args.warmup_steps, num_training_steps=t_total)

  # Start training!
  global_step = 0

  p_model.zero_grad()
  q_model.zero_grad()
  torch.cuda.empty_cache()

  train_iterator = trange(int(args.num_train_epochs), desc="Epoch")

  for _ in train_iterator:
    epoch_iterator = tqdm(train_dataloader, desc="Iteration")

    for step, batch in enumerate(epoch_iterator):
      q_encoder.train()
      p_encoder.train()

      if torch.cuda.is_available():
        batch = tuple(t.cuda() for t in batch)

      p_inputs = {'input_ids': batch[0],
                  'attention_mask': batch[1],
                  'token_type_ids': batch[2]
                  }

      q_inputs = {'input_ids': batch[3],
                  'attention_mask': batch[4],
                  'token_type_ids': batch[5]}

      p_outputs = p_model(**p_inputs)  # (batch_size, emb_dim)
      q_outputs = q_model(**q_inputs)  # (batch_size, emb_dim)

In-batch Negative

      # Calculate similarity score & loss
      sim_scores = torch.matmul(q_outputs, torch.transpose(p_outputs, 0, 1))  # (batch_size, emb_dim) x (emb_dim, batch_size) = (batch_size, batch_size)

      # target: position of positive samples = diagonal element
      targets = torch.arange(0, args.per_device_train_batch_size).long()

      if torch.cuda.is_available():
        targets = targets.to('cuda')

      sim_scores = F.log_softmax(sim_scores, dim=1)

      loss = F.nll_loss(sim_scores, targets)

      loss.backward()
      optimizer.step()
      scheduler.step()
      q_model.zero_grad()
      p_model.zero_grad()
      global_step += 1

      torch.cuda.empty_cache()

  return p_model, q_model

✅ Checkpoint! sim_scores: question의 임베딩과 context의 유사도를 내적을 사용하여 구한다. sim_scores[i][j]는 i번째 질문과 j번째 문서 사이의 유사도 점수를 나타낸다. targets: 0부터 batch_size-1까지의 정수 시퀀스이다. 즉, 각 데이터 샘플의 정답 인덱스를 의미한다. 대각선 요소(sim_scores[i][i])는 각 질문과 그에 해당하는 정답 문서의 유사도 점수이기 때문이다. loss: 로그 확률인 예측된 유사도와 정답 인덱스 사이의 nll_loss를 구한다.

✅ nll_loss란? 모델이 정답 문서에 높은 확률(즉, 높은 로그 확률)을 할당할수록 손실 값이 작아진다. 인자로 들어간 소프트맥스 함수는 확률 분포를 생성하므로, 정답 클래스의 확률을 높이면 다른 클래스들의 확률은 자연스럽게 낮아진다.

✅ negative sampling과 in-batch negative 🔹전통적인 negative sampling: 전체 데이터셋에서 임의로 네거티브 샘플을 추출하여 모델 학습에 사용. 주로 대규모 클래스나 어휘 집합을 처리할 때 계산량을 줄이기 위해 사용. 🔹In-batch negative: 배치 내의 다른 문서들을 네거티브 샘플로 사용합. 별도로 네거티브 샘플을 샘플링하거나 생성하지 않는다. 🔹배치 크기의 영향: 배치 크기가 클수록 배치 내 네거티브 샘플의 수가 증가하여 모델이 더 많은 네거티브 사례를 학습할 수 있다.

[Input]

args = TrainingArguments(
    output_dir="dense_retireval",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=2,
    per_device_eval_batch_size=2,
    num_train_epochs=2,
    weight_decay=0.01
)
p_encoder, q_encoder = train(args, train_dataset, p_encoder, q_encoder)

Passage etrieval with Dense embedding

Validation data 준비

[Input]

valid_corpus = list(set([example['context'] for example in dataset['validation']]))[:10]
sample_idx = random.choice(range(len(dataset['validation'])))
query = dataset['validation'][sample_idx]['question']
ground_truth = dataset['validation'][sample_idx]['context']

if not ground_truth in valid_corpus:
  valid_corpus.append(ground_truth)

print(f"Query: {query}")
print(f"Grount Truth: ground_truth")

[output]

>>  Query: 반기문이 2016년 6월 이스라엘에 방문할 당시 이스라엘의 총리의 이름은 무엇인가?
    Grount Truth: 2016년 1월 26일 반기문은 안전보장이사회의 중동 관련 토론에서 이스라엘이 최근 요르단 강 서안에서 유대인 정착촌을 확대하는 건 팔레스타인의 ...

Dense embedding 생성

[Input]

def to_cuda(batch):
  return tuple(t.cuda() for t in batch)

with torch.no_grad():
  p_encoder.eval()
  q_encoder.eval()

  q_seqs_val = tokenizer([query], padding="max_length", truncation=True, return_tensors='pt').to('cuda')
  q_emb = q_encoder(**q_seqs_val).to('cpu')  #(num_query, emb_dim)

  p_embs = []
  for p in valid_corpus:
    p = tokenizer(p, padding="max_length", truncation=True, return_tensors='pt').to('cuda')
    p_emb = p_encoder(**p).to('cpu').numpy()
    p_embs.append(p_emb)

p_embs = torch.Tensor(p_embs).squeeze()  # (num_passage, emb_dim)

print(p_embs.size(), q_emb.size())

[output]

>>  torch.Size([11, 768]) torch.Size([1, 768])

✅ torch.Size([11, 768]) 랜덤으로 선정한 10개 샘플 + Ground Truth = 11개

Similarity ranking in Documents

[Input]

dot_prod_scores = torch.matmul(q_emb, torch.transpose(p_embs, 0, 1))
print(dot_prod_scores.size())

rank = torch.argsort(dot_prod_scores, dim=1, descending=True).squeeze()
print(dot_prod_scores)
print(rank)

[output]

>>  torch.Size([1, 11])
    tensor([[ 9.4619,  9.6707,  8.3590, 10.9888,  7.4889,  6.7830, 10.5825,  9.6571,
          4.7864,  7.1045, 18.2881]])
    tensor([10,  3,  6,  1,  7,  0,  2,  4,  9,  5,  8])

Top-5 passage retrieve & ground truth와 비교하기

[Input]

k = 5
print("[Search query]\n", query, "\n")
print("[Ground truth passage]")
print(ground_truth, "\n")

for i in range(k):
  print("Top-%d passage with score %.4f" % (i+1, dot_prod_scores.squeeze()[rank[i]]))
  print(valid_corpus[rank[i]])

[output]

>>  [Search query]
    반기문이 2016년 6월 이스라엘에 방문할 당시 이스라엘의 총리의 이름은 무엇인가? 

    [Ground truth passage]
    2016년 1월 26일 반기문은 안전보장이사회의 중동 관련 토론에서 이스라엘이 최근 요르단 강 서안에서 유대인 정착촌을 확대하는 건 팔레스타인의 증오를 부추기고 국제사회를 모욕하는 행동이라고 지적하였다. 반기문은 억압받는 민족이 시대를 걸쳐 보여줬듯이 점령에 저항하는 건 인간의 본성이며, 이는 증오와 극단주의의 강력한 인큐베이터가 된다고 강조하면서 이스라엘의 조치를 강한 어조로 비판하였다. 이후 2016년 6월 이스라엘과 팔레스타인을 직접 방문하여 베냐민 네타냐후 이스라엘 총리, 마흐무드 압바스 팔레스타인 자치정부 수반을 각각 만나 분쟁 해결을 위한 중재를 하였다. 반기문은 이스라엘과 팔레스타인 양측 모두 이 땅에 역사적 종교적 연결점이 있음을 강조하면서, 유엔이 분쟁 해결책으로 제시해 온 평화 협상에 기반한 2국가 해법(two-state solution)을 다시금 상기시켰다. 

    Top-1 passage with score 18.2881
    2016년 1월 26일 반기문은 안전보장이사회의 중동 관련 토론에서 이스라엘이 최근 요르단 강 서안에서 유대인 정착촌을 확대하는 건 팔레스타인의 증오를 부추기고 국제사회를 모욕하는 행동이라고 지적하였다. 반기문은 억압받는 민족이 시대를 걸쳐 보여줬듯이 점령에 저항하는 건 인간의 본성이며, 이는 증오와 극단주의의 강력한 인큐베이터가 된다고 강조하면서 이스라엘의 조치를 강한 어조로 비판하였다. 이후 2016년 6월 이스라엘과 팔레스타인을 직접 방문하여 베냐민 네타냐후 이스라엘 총리, 마흐무드 압바스 팔레스타인 자치정부 수반을 각각 만나 분쟁 해결을 위한 중재를 하였다. 반기문은 이스라엘과 팔레스타인 양측 모두 이 땅에 역사적 종교적 연결점이 있음을 강조하면서, 유엔이 분쟁 해결책으로 제시해 온 평화 협상에 기반한 2국가 해법(two-state solution)을 다시금 상기시켰다.
    Top-2 passage with score 10.9888
    2011년 10월 15일, 10.26 서울시장 보궐선거에 나선 한나라당 나경원 후보가 자신의 트위터에서 스스로를 지지하는 ‘자화자찬’하는 글을 올려 논란이 일었다. 자신이 작성한 글을 리트윗(재인용)해 “콘텐츠가 있는 공약과 정책 정말 멋집니다” 등 자신을 지지하는 댓글을 달았다. 이에 네티즌들이 ‘나르시즘 나경원’ ‘자화자찬도 유분수’ ‘알바의 실수인가’ 등의 지적을 하자 나경원 측은 2011년 10월 16일 해당 트위터 글을 삭제하고 “확인 결과 시스템 간에 충돌이 일어나 계정 연동 오류가 발생한 것으로 확인됐다”며 “현재 오류를 바로 잡았다”고 밝혔다. 그러나 2011년 10월 20일 한 트위터 사용자가 나경원 트위터 멘션 오류에 대해 트위터 본사에 문의한 내용을 온라인에 게시했는데 트위터 본사 답변에 따르면 “나 후보 측의 트위터 글은 트위터 내부 오류나 장애가 아니다”라며 “후보자는 트윗을 포스팅 하기 위해 외부 어플리케이션을 사용한 것으로 보인다”고 답했다. 이어 “이같은 오류나 장애는 트위터가 아닌 이 어플리케이션에서 발생된 것으로 보인다”며 트위터 계정 연동 오류가 아니라고 밝혀 '계정 연동 시스템 오류'라던 나경원의 해명이 거짓말로 드러났다.
    Top-3 passage with score 10.5825
    "나는 대통령 때 외무부에 지시해 독도 인근 해역에 배를 엄청나게 띄워 해상시위를 하도록 했다"며 "그때 배 선착장에 몇 백명이 올라가서 시위를 하니 일본 정부가 우리 외무부에 그만두도록 해달라고 요청했다"고 지난 1996년 당시 강원도 어민들이 벌인 '일본 독도 영유권 주장 망언 규탄' 대규모 해상시위를 언급하고 이어 "대통령이 문제다. 외교 활동을 제대로 못하고 있으니 (일본이 노대통령을) '바보'로 취급하는 것"이라고 노무현 정권의 외교 활동을 비난하였다. 그는 김대중 전 대통령의 방북 계획과 관련해 "말만 나오는 것이지 가기는 자기가 어디로 가느냐"면서 "누가 오라는 사람도 있는 것도 아니고…. 김정일에게 아무것도 갖다줄 게 없는데 누가 오라고 하겠나"라고 '쓴소리'를 가했다.
    Top-4 passage with score 9.6707
    1934년 7월, 사이토 내각을 이어 출범한 오카다 게이스케 내각은 과격파 청년 장교들의 계속되는 갈등 유발과 점령지 주민들의 계속되는 저항에 부딪쳤다. 1936년 2월 26일 육군 하급 장교 22명이 제1사단 휘하 3개 연대와 근위보병연대의 무장 병사들 1,400명을 이끌고 도쿄에서 반란을 일으켜 사이토 마코토 내대신, 다카하시 고레키요 대장대신, 와타나베 조타로 교육총감을 살해하는 2·26 사건이 일어났다. 또, 이 사건으로 경찰관 5명이 죽었으며, 스즈키 간타로 시종장이 부상을 입었다. 요코스카 진수부에 있던 진수부 사령장관 요나이 미쓰마사, 참모장 이노우에 시게요시는 도쿄 만에 함대를 집결시켰고 정부는 계엄령을 발동했다. 정부의 발빠른 수습으로 주동자들 중 한 명은 자결하고 나머지 지휘관들은 항복했으며, 병사 대부분이 부대로 돌아갔지만 계엄령은 5개월 넘게 이어졌다.
    Top-5 passage with score 9.6571
    이 선거에서는 (사전 여론조사 및 1차 투표 결과로 비추어 볼 때) 좌파 지지 유권자가 우파 지지 유권자보다 훨씬 많았음에도 불구하고, 결과는 우파 후보의 당선으로 나타났다. 이는 결선투표제하에서도 후보 단일화의 필요성이 제기될 수 있음을 보여주는 대표적인 사례다. 한편 최저 득표자를 탈락시키는 선거를 반복해서 했다면, 좌파 후보들 중에서 한 명(아마도 조스팽)이 당선되었겠지만, 이 방식은 지나치게 번거롭다는 문제가 있다. 그런데 이 번거로움을 해결해주는 제도가 있다. 바로 선호투표제다. 선호투표제에 대해서는 이 문서의 아래 문단 및 선호투표제 문서를 참조 바람. 그리고 2002년 프랑스 대선이 선호투표제로 치뤄졌을 경우의 결과는 《2002년 프랑스 대선이 선호투표제로 치뤄졌다면?》을 참조 바람.

Passage Embedding은 텍스트의 일부분을 고차원 공간의 벡터로 표현하는 방법으로, 의미적으로 유사한 패시지가 유사한 벡터 표현을 갖도록 한다. 패시지 임베딩은 문장의 맥락적인 의미를 담아 정보 검색, 질문 응답, 의미 검색 등의 자연어 처리 작업에 쓰인다. 그 중에서도 Retrieval(검색)의 과정으로 질문과 지문을 임베딩하여 질문과 유사한 지문을 가져오기 위해 Passage Embedding을 사용한다.

Sparse Embedding

벡터화(임베딩)된 Passage를 이용하여 Passage 간 유사도 등을 알고리즘으로 계산할 수 있다. 이번 포스트에서는 Sparse Embedding을 통해 passage를 벡터로 표현하고 유사도를 구하는 방법을 설명한다.

Bag-of-Words (BoW)

• BoW를 구성하는 방법 → n-gram
  1. unigram(1-gram): It was the best of times → It, was, the, best, of, times
  2. bigram(2-gram): It was the best of times → It was, was the, the best, best of, of times

TF-IDF (Term Frequency - Inverse Document Frequency)

Term Frequency(TF): 단어의 등장빈도 Inverse Document Frequency(IDF): 단어가 제공하는 정보의 양

ex) It was the best of times → It, was, the, of: 자주 등장하지만 제공하는 정보량이 적음 → best, times: 좀 더 많은 정보를 제공

1. Term Frequency (TF)

• Raw count
• Adjusted for doc length (TF): raw count / num words

2. Inverse Document Frequency (IDF)

   $$IDF(t) = \log\frac{N}{DF(t)}$$

Document Frequency (DF): Term t가 등장한 document의 개수 N: 총 document의 개수

3. Combine TF & IDF

   $$TF-IDF(t, d) = TF(t, d) * IDF(t)$$

TF-IDF(t, d): TF-IDF for term $t$ in document $d$,

TF-IDF 이해하기

i) ‘a’, ‘the’ 등 관사 ⇒ Low TF-IDF: TF는 높을 수 있지만, IDF가 0에 가까울 것 (거의 모든document에 등장 ⇒ N ≈ DF(t) ⇒ log(N / DF) ≈ 0) ii) 자주 등장하지 않는 고유명사 (ex. 사람이름, 지명 등) ⇒ High TF-IDF: IDF가 커지면서 전체적인 TF-IDF값이 증가

TF-IDF를 이용해 유사도 구해보기

목표: 계산한 문서 TF-IDF를 가지고 질의 TF-IDF를 계산한 후 가장 관련있는 문서를 찾기

1. 사용자가 입력한 질의를 토큰화
2. 기존에 단어 사전에 없는 토큰들은 제외
3. 질의를 하나의 문서로 생각하고, 이에 대한 TF-IDF계산
4. 질의 TF-IDF값과 각 문서별 TF-IDF값을 곱하여 유사도 점수 계산 $Score(D, Q) = \sum_{term \in Q} TFIDF(term, Q) * TFIDF(term, D)$
5. 가장 높은 점수를 가지는 문서 선택

BM25

TF-IDF의 개념을 바탕으로, 문서의 길이까지 고려하여 점수를 매김

• TF 값에 한계를 지정해두어 일정한 범위를 유지하도록 함
• 평균적인 문서의 길이 보다 더 작은 문서에서 단어가 매칭된 경우 그 문서에 대해 가중치를 부여
• 실제 검색엔진, 추천 시스템 등에서 아직까지도 많이 사용되는 알고리즘

Sparse Embedding 특징

• Dimension of embedding vector = number of term
  • 등장하는 단어가 많아질수록 증가
  • N-gram의 n이 커질수록 증가 → 더 다양한 조합이 발생
• Term overlap을 정확하게 잡아내야 할 때 유용
• 반면, 의미(semantic)가 비슷하지만 다른단어인 경우 비교가 불가

TF-IDF Passage Retrieval

데이터 불러오기

from datasets import load_dataset
dataset = load_dataset("squad_kor_v1")

데이터 확인 및 토큰화

[Input]

corpus = list(set([example['context'] for example in dataset['train']]))
print("context_sample:", corpus[0])

tokenizer_func = lambda x: x.split(' ')
tokenized_sample = tokenizer_func(corpus[0])[:10]
print("tokenized_sample:", corpus[0])

[output]

>> context_sample: 데스몬드 도스는 교회의 창문을 갈던 중 차에 깔린 남자를 발견하고 병원으로 데려가 그의 목숨을 구한다. ...
   tokenized_sample: ['데스몬드', '도스는', '교회의', '창문을', '갈던', '중', '차에', '깔린', '남자를', '발견하고']

TF-IDF Embedding

[Input]

from sklearn.feature_extraction.text import TfidfVectorizer
vectorizer = TfidfVectorizer(tokenizer=tokenizer_func, ngram_range=(1,2))

vectorizer.fit(corpus)
sparse_matrix = vectorizer.transform(corpus)
print(sparse_matrix.shape)

[output]

>> (9606, 1272768)

ngram_range=(1,2)은 벡터화할 때 unigram과 bigram을 모두 포함하는 경우를 말한다. ngram_range=(1, 1) → unigram만 사용 (단어 하나씩만) ngram_range=(1, 2) → unigram + bigram (단어 하나와 두 단어 묶음 모두) ngram_range=(2, 2) → bigram만 사용 (두 단어 묶음만) ngram_range=(1, 3) → unigram, bigram, trigram까지 포함 이는 텍스트의 연속된 단어 간의 관계를 더 잘 반영할 수 있도록 도와주는 설정이다.

[Input]

import pandas as pd
df = pd.DataFrame(sp_matrix[0].T.todense(), index=vectorizer.get_feature_names_out(), columns=["TF-IDF"])
df = df.sort_values('TF-IDF', ascending=False)
print(df.head(10))

[output]

>>             TF-IDF
  도스는       0.297943
  헌혈을       0.148971
  도스가       0.148971
  허리띠를      0.148971
  남자를       0.126206
  쉬트에게      0.077815
  뛰어요'라고    0.077815
  꽂은 뒤로     0.077815
  내쫓는다.     0.077815
  앉는다. 아버지  0.077815

희소 행렬: 메모리 효율성이 높음. 0이 아닌 원소들만 저장. 밀집 행렬: 모든 원소를 저장하여 메모리 사용량이 큼. 모든 값을 명시적으로 저장. todense(): 희소행렬 to 밀집행렬 get_feature_names_out(): n-gram된 텍스트 데이터를 벡터로 변환할 때 사용된 특성 이름 목록을 반환

Passage retrieval with TF-IDF embedding

import random
import numpy as np

random.seed(42)
sample_idx = random.choice(range(len(dataset['train'])))

query = dataset['train'][sample_idx]['question']
ground_truth = dataset['train'][sample_idx]['context']

[Input]

query_vec = vectorizer.transform([query])['context']
result = query_vec * sparse_matrix.T # Dot Product로 유사도를 계산한다. 
print(query_vec.shape)
print(result.shape)

[output]

>> (1, 1272768)
   (1, 9606)

Top-3개의 passage를 retrieve 하고, 실제 ground_truth와 비교

[Input]

sorted_result = np.argsort(-result.data) # result.data의 값을 내림차순으로 정렬했을 때, 값이 원래 어느 위치에 있었는지를 알려주는 인덱스 배열
doc_scores = result.data[sorted_result]
doc_ids = result.indices[sorted_result]

k = 3
print(sorted_result[:k])
print(doc_scores[:k])
print(doc_ids[:k])

[output]

>>  array([312, 137, 298])  
    array([0.16595357, 0.04368785, 0.03937975])
     array([2775, 7138,  798], dtype=int32)

[Input]

print("[Search query]\n", query, "\n")

print("[Ground truth passage]")
print(ground_truth, "\n")

for i in range(k):
  print("Top-%d passage with score %.4f" % (i + 1, doc_scores[i]))
  doc_id = doc_ids[i]
  print(corpus[doc_id], "\n")

[output]

>>  [Search query]
    구식 군인들의 월급인 쌀에 모래와 돌멩이가 들어가있던 사건을 말미암아 일어난 사태의 이름은? 

    [Ground truth passage]
    1882년 6월 민영익의 귀국 권고로 일시 귀국했다가 다시 되돌아갔다. ...

    Top-1 passage with score 0.1660
    1882년 6월 민영익의 귀국 권고로 일시 귀국했다가 다시 되돌아갔다. ...

    Top-2 passage with score 0.0437
    6월 13일, 런던에서 일어난 사태의 소식이 전해지자 하트퍼드셔 세인트올번스 읍도 들끓기 시작했다.  ...

    Top-3 passage with score 0.0394
    그리고 이러한 만민공동회 활동과 관련하여, 독립협회에서 만민공동회에 사주하여 결의한 헌의 6조에 배치되는 활동이 자주 나타났고, ...

토큰화(tokenization)는 자연어 처리(NLP)에서 텍스트를 의미 있는 단위로 분할하는 과정이다. 이러한 단위는 '토큰(token)'이라고 불리며, 토큰은 단어, 문장, 문단, 혹은 더 작은 의미 단위가 될 수 있다. 토큰화는 텍스트를 기계가 이해하고 처리할 수 있도록 만드는 첫 단계로서, 이후의 언어 모델링, 기계 학습 등에 중요한 역할을 한다.

토크나이제이션 방법에는 크게 단어 단위, 형태소 단위, 문자 단위, 서브워드(subword) 단위 토큰화 방법이 있다. 단어 단위 토크나이제이션은 텍스트를 단어별로 나누는 방식이며, 주로 띄어쓰기를 기준으로 구분된다. 형태소 단위 토크나이제이션은 단어의 의미적 최소 단위인 형태소로 분할하는 방식으로, 한국어처럼 형태소 분석이 중요한 언어에 유리하다. 문자 단위 토크나이제이션은 텍스트를 한 글자씩 분할하는 방식으로, 주로 아주 짧거나 구조적인 텍스트에서 사용된다. 서브워드 단위 토크나이제이션은 단어보다 작지만 의미를 가진 단위로 나누는 방식으로, BPE(Byte Pair Encoding)나 WordPiece와 같은 기법이 대표적이다. 이는 특히 새로운 단어에 대해 유연하게 대처할 수 있어 최근 널리 사용되고 있다.

토크나이제이션은 단순히 텍스트를 분리하는 작업이지만, 언어적 특성과 모델의 목적에 따라 그 방법이 달라질 수 있다. 예를 들어, 영어와 같이 띄어쓰기가 명확한 언어는 단어 단위 토크나이제이션이 비교적 간단하지만, 한국어와 같이 교착어적인 특성을 가진 언어는 형태소 분석이 중요한 요소가 된다. 또한, 딥러닝 기반의 언어 모델에서는 서브워드 단위 토크나이제이션이 자주 사용되는데, 이는 드문 단어나 미지의 단어에 대해 더 나은 일반화를 가능하게 하기 때문이다.

토크나이제이션의 결과는 이후의 자연어 처리 과정에서 매우 중요한 영향을 미친다. 각 토큰은 모델이 이해할 수 있는 형태로 변환되어야 하며, 이를 임베딩(embedding) 과정에서 벡터로 표현하게 된다. 따라서 좋은 토크나이제이션은 언어의 의미와 구조를 잘 반영하면서도 모델의 효율성을 높이는 방향으로 이루어져야 한다. 토크나이제이션은 자연어 처리의 첫 단계이자 매우 중요한 기초 작업으로, 이를 통해 텍스트 데이터의 의미를 최대한 유지하면서도 기계가 처리할 수 있는 형태로 변환하게 된다.

Tokenizing with KorQuAD

KorQuAD 데이터셋을 예시로 허깅페이스 AutoTokenizer를 이용해 토큰화과정을 진행한다. KorQuAD 데이터셋이 궁금하다면, KorQuAD 데이터셋은 뭘까?에서 확인할 수 있다.

Tokenizer 불러오기

from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("KLUE/roberta-large")

Only 토큰화

[Input]

example_text = dataset["train"][0]['question']
tokenized_txt = tokenizer.tokenize(example_text)
print(tokenized_txt)

[output]

>> ['바그너','##는', '괴테', '##의', '파우', '##스트', '##를', '읽', '##고', '무엇', '##을', '쓰', '##고', '##자', '했', '##는', '##가', '?']

'바그너는 괴테의 파우스트를 읽고 무엇을 쓰고자 했는가?' 라는 문장을 위와 같이 토크나이징하였다.

토큰화 & 인덱싱 & 어텐션 마스킹

[Input]

tokens = tokenizer(example_text)
print(tokens)

[output]

>> {'input_ids': [101, 9318, 78136, 70162, 11018, 8905, 119351, 10459, 9901, 89108, 101825, 9642, 11664, 9294, 119137, 10622, 9511, 11664, 13764, 9965, 11018, 11287, 136, 102], 
    'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
    'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}

단일 문장이기 때문에 token_type_ids은 모두 0으로, Encoder-Only 모델일 경우에는 attention_mask가 모두 1로 설정된다.

Decode Tokens

[Input]

original_text = tokenizer.decode(tokenizer(example_text)['input_ids'])
print(original_text)

[output]

>> [CLS] 바그너는 괴테의 파우스트를 읽고 무엇을 쓰고자 했는가? [SEP]

Tokenizer가 자동으로 CLS 토큰과 SEP 토큰을 추가해주는 것을 알 수 있다.

입력 토큰이 너무 길다면

데이터 둘러보기

[Input]

examples = dataset['train'][:1]
print(examples)

[output]

>> {'id': ['6566495-0-0'], 
    'title': ['파우스트_서곡'], 
    'context': ['1839년 바그너는 괴테의 파우스트을 처음 읽고 그 내용에 마음이 끌려 이를 소재로 해서 하나의 교향곡을 쓰려는 뜻을 갖는다. 이 시기 바그너는 1838년에 빛 독촉으로 산전수전을 다 걲은 상황이라 좌절과 실망에 가득했으며 메피스토펠레스를 만나는 파우스트의 심경에 공감했다고 한다. 또한 파리에서 아브네크의 지휘로 파리 음악원 관현악단이 연주하는 베토벤의 교향곡 9번을 듣고 깊은 감명을 받았는데, 이것이 이듬해 1월에 파우스트의 서곡으로 쓰여진 이 작품에 조금이라도 영향을 끼쳤으리라는 것은 의심할 여지가 없다. 여기의 라단조 조성의 경우에도 그의 전기에 적혀 있는 것처럼 단순한 정신적 피로나 실의가 반영된 것이 아니라 베토벤의 합창교향곡 조성의 영향을 받은 것을 볼 수 있다. 그렇게 교향곡 작곡을 1839년부터 40년에 걸쳐 파리에서 착수했으나 1악장을 쓴 뒤에 중단했다. 또한 작품의 완성과 동시에 그는 이 서곡(1악장)을 파리 음악원의 연주회에서 연주할 파트보까지 준비하였으나, 실제로는 이루어지지는 않았다. 결국 초연은 4년 반이 지난 후에 드레스덴에서 연주되었고 재연도 이루어졌지만, 이후에 그대로 방치되고 말았다. 그 사이에 그는 리엔치와 방황하는 네덜란드인을 완성하고 탄호이저에도 착수하는 등 분주한 시간을 보냈는데, 그런 바쁜 생활이 이 곡을 잊게 한 것이 아닌가 하는 의견도 있다.'], 
    'question': ['바그너는 괴테의 파우스트를 읽고 무엇을 쓰고자 했는가?'], 
    'answers': [{'text': ['교향곡'], 'answer_start': [54]}]}

복수의 데이터는 각 feature의 list로 주어진다.

토큰화하기

모델이 긴 문맥에서 답을 찾을 때, 원본 텍스트의 연속성을 유지하기 위해 문장을 여러 시퀀스로 나누게 된다. 이 과정에서 "질문(question)"과 "문맥(context)"을 한 번에 토큰화하며, 토큰의 총 길이가 설정된 최대 길이(max_length)를 초과하면 "문맥" 부분만 잘라낸다. 이 방법을 only_second라 하며, 잘라낸 토큰들은 return_overflowing_tokens 옵션을 통해 별도의 시퀀스로 반환된다.

stride는 두 시퀀스가 자연스럽게 이어지도록 일정 부분을 겹치게 만드는 역할을 한다. 이렇게 하면 답이 두 시퀀스의 경계에 걸려 있더라도 겹친 부분을 통해 문맥의 흐름이 이어져, 답을 찾기 쉬워진다.

[Input]

tokenized_examples = tokenizer(
        examples["question"],
        examples["context"],
        truncation="only_second",  # Truncate to max_length. This will only truncate the second sequence of a pair.
        max_length=250, # The maximum length of the combined string of the question, context, and special tokens.
        stride=50, # The length of the overlapping sequence when the context is split because it's too long.
        return_overflowing_tokens=True, # Whether or not to return overflowing token sequences.
        return_offsets_mapping=True,  # Whether or not to return (char_start, char_end) for each token.
        padding="max_length",
    )

print(tokenized_examples)

[output]

>> {'input_ids': [[0, 27982, 2259, 21310, 2079, 11994, 3791, 2138, ...], 
                    [0, 27982, 2259, 21310, 2079, 3791, ..., 1, 1, 1, 1]], 
    'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...], 
                        [0, 0, 0, ..., 1, 1, 1, 1, 1, 1, ..., 0, 0, 0, 0]], 
    'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...], 
                        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ..., 0, 0, 0, 0, 0, 0]], 
    'offset_mapping': [[(0, 0), (0, 3), (3, 4), (5, 7), (7, 8), (8, 10), ...], 
                        [(0, 0), (0, 3), (3, 4), (7, 8), ..., (0, 0), (0, 0)]], 
    'overflow_to_sample_mapping': [0, 0]}

input_ids: 두번째 시퀀스의 마지막 빈공간은 pading token으로 대체되었다. token_type_ids: 앞부분의 "question"과 padding은 0으로 "context"는 1로 설정하여 두 가지 문장타입 사이에 seperate token을 배치할 수 있도록 하였다. attention_mask: padding token은 attention 대상에서 제외한다. offset_mapping: 토큰이 원본 텍스트 내에서 차지하는 위치 overflow_to_sample_mapping: 여러 시퀀스가 하나의 문맥에서 나왔음을 나타낸다.

KorQuAD(Korean Question Answering Dataset)는 한국어 자연어 처리(NLP) 연구에 중요한 역할을 하는 질문-응답 데이터셋이다. KorQuAD는 한국어로 된 질문과 답변 쌍을 포함하고 있으며, 이를 통해 기계가 한국어 문서를 이해하고 주어진 질문에 답변하는 능력을 평가하고 향상시킬 수 있다. 이 데이터셋은 특히 한국어 자연어 이해 및 기계 독해(Machine Reading Comprehension) 연구를 위해 설계되었다.

KorQuAD의 첫 번째 버전은 2018년에 LG CNS에 의해 공개되었으며, 이는 SQuAD(Stanford Question Answering Dataset)의 구조를 본떠 한국어로 개발되었다. 데이터셋은 수천 개의 질문과 그에 대한 답변을 포함하는 문서로 구성되어 있어, 기계 학습 모델이 한국어 텍스트의 맥락을 이해하고 해당 문서에서 관련된 정보를 찾아 답을 생성할 수 있도록 돕는다. 이로 인해 KorQuAD는 한국어 NLP 모델의 성능을 평가하는 데 중요한 벤치마크로 자리 잡았다.

최근에는 KorQuAD 2.0과 같은 확장된 데이터셋도 등장하여 더욱 복잡한 질문 유형에 대해 모델을 학습시키고 평가하는 데 도움을 주고 있다.

↓ 아래의 링크에서 자세히 확인할 수 있다. KorQuAD: https://korquad.github.io/

KorQuAD의 구성

데이터 불러오기

from datasets import load_dataset
dataset = load_dataset("squad_kor_v1")

데이터셋 구성 확인하기

[Input]

print(dataset)

[output]

>> DatasetDict({
        train: Dataset({
            features: ['id', 'title', 'context', 'question', 'answers'],
            num_rows: 60407
        })
        validation: Dataset({
            features: ['id', 'title', 'context', 'question', 'answers'],
            num_rows: 5774
        })
    })

데이터는 train 데이터셋 60407개와 validation 데이터셋 5774개로 구성되어있으며, 하나의 샘플은 'id', 'title', 'context', 'question', 'answers' 를 feature로 한다.

train dataset 확인하기

[Input]

import random
pick = random.randint(0, len(dataset['train'])-1)
example = dataset['train'][pick]

print(example)

[output]

>> {'id': '6566495-0-0',
     'title': '파우스트_서곡',
     'context': '1839년 바그너는 괴테의 파우스트을 처음 읽고 그 내용에 마음이 끌려 이를 소재로 해서 하나의 교향곡을 쓰려는 뜻을 갖는다. 이 시기 바그너는 1838년에 빛 독촉으로 산전수전을 다 걲은 상황이라 좌절과 실망에 가득했으며 메피스토펠레스를 만나는 파우스트의 심경에 공감했다고 한다. 또한 파리에서 아브네크의 지휘로 파리 음악원 관현악단이 연주하는 베토벤의 교향곡 9번을 듣고 깊은 감명을 받았는데, 이것이 이듬해 1월에 파우스트의 서곡으로 쓰여진 이 작품에 조금이라도 영향을 끼쳤으리라는 것은 의심할 여지가 없다. 여기의 라단조 조성의 경우에도 그의 전기에 적혀 있는 것처럼 단순한 정신적 피로나 실의가 반영된 것이 아니라 베토벤의 합창교향곡 조성의 영향을 받은 것을 볼 수 있다. 그렇게 교향곡 작곡을 1839년부터 40년에 걸쳐 파리에서 착수했으나 1악장을 쓴 뒤에 중단했다. 또한 작품의 완성과 동시에 그는 이 서곡(1악장)을 파리 음악원의 연주회에서 연주할 파트보까지 준비하였으나, 실제로는 이루어지지는 않았다. 결국 초연은 4년 반이 지난 후에 드레스덴에서 연주되었고 재연도 이루어졌지만, 이후에 그대로 방치되고 말았다. 그 사이에 그는 리엔치와 방황하는 네덜란드인을 완성하고 탄호이저에도 착수하는 등 분주한 시간을 보냈는데, 그런 바쁜 생활이 이 곡을 잊게 한 것이 아닌가 하는 의견도 있다.',
     'question': '바그너는 괴테의 파우스트를 읽고 무엇을 쓰고자 했는가?',
     'answers': {'text': ['교향곡'], 'answer_start': [54]}}

answer_start는 context내에서 정답(answer.text)가 시작하는 부분(index)이다.

Tokenizing with KorQuAD

Tokenizer 불러오기

from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("KLUE/roberta-large")

Only 토큰화

[Input]

example_text = dataset["train"][0]['question']
tokenized_txt = tokenizer.tokenize(example_text)
print(tokenized_txt)

[output]

>> ['바그너','##는', '괴테', '##의', '파우', '##스트', '##를', '읽', '##고', '무엇', '##을', '쓰', '##고', '##자', '했', '##는', '##가', '?']

'바그너는 괴테의 파우스트를 읽고 무엇을 쓰고자 했는가?' 라는 문장을 위와 같이 토크나이징하였다.

Tokenizing with KorQuAD 이어서 보기 ▶