# 언어모델 768차원 임베딩 벡터 생성 원리 완벽 가이드 ## 핵심 질문들 1. **768차원이 뭘 의미하는가?** 2. **컴퓨터가 어떻게 차원을 구분해내는가?** 3. **"안녕하세요"가 어떻게 768개 숫자가 되는가?** ## 1. 768차원의 정확한 의미 ### 기본 개념 **768차원 = 각 단어를 768개의 실수로 표현** ```python # 실제 예시: "안"이라는 글자 "안" → [0.1234, -0.5678, 0.2345, 0.8901, -0.1122, 0.3344, ..., 0.7654] 1번째 2번째 3번째 4번째 5번째 6번째 768번째 # 총 768개의 실수가 하나의 글자를 표현 ``` ### 간단한 3차원 예시로 이해 ```python # 이해를 위해 3차원으로 축소 임베딩테이블 = { "안": [0.2, -0.5, 0.8], # 3개 숫자로 "안" 표현 "녕": [0.1, 0.7, -0.3], # 3개 숫자로 "녕" 표현 "하": [-0.4, 0.3, 0.6] # 3개 숫자로 "하" 표현 } # "안녕하" 입력 시 입력토큰 = ["안", "녕", "하"] 임베딩결과 = [ [0.2, -0.5, 0.8], # "안"의 3차원 벡터 [0.1, 0.7, -0.3], # "녕"의 3차원 벡터 [-0.4, 0.3, 0.6] # "하"의 3차원 벡터 ] ``` ## 2. 컴퓨터는 처음에 아무것도 모른다! ### 최초 상태: 완전히 랜덤 ```python # 학습 시작 전 - 모든 것이 랜덤 "안" → [0.234, -0.567, 0.891, -0.123, ..., 0.456] # 의미 없는 랜덤 "녕" → [-0.789, 0.345, -0.678, 0.234, ..., -0.567] # 의미 없는 랜덤 "하" → [0.567, -0.234, 0.123, -0.789, ..., 0.345] # 의미 없는 랜덤 # 이 시점에서는 768차원이 아무 의미가 없습니다! # 컴퓨터는 "안녕"이 인사말인지도 모릅니다. ``` ### 의미가 없는 초기 예측 ```python # 학습 전 예측 (완전히 엉터리) "안녕하" 다음 단어 예측: - "냉장고": 15% - "자동차": 12% - "세요": 8% ← 정답인데 낮은 확률 - "컴퓨터": 11% - ... (랜덤한 확률들) ``` ## 3. 학습을 통한 의미 생성 과정 ### 학습 데이터와 패턴 발견 ```python # 수백만 개의 학습 문장 학습데이터 = [ "안녕하세요 반갑습니다", "안녕하세요 어떻게 지내세요", "안녕하세요 오늘 날씨가 좋네요", "안녕하세요 처음 뵙겠습니다", "안녕 친구야", "안녕히 가세요", "안녕히 계세요", ... (수백만 개 문장) ] ``` ### 실제 학습 과정 (단순화) ```python # 학습 사이클 반복 for 문장 in 학습데이터: # 1단계: 예측 시도 예측 = model("안녕하세요 반갑") # 다음 단어 예측 정답 = "습니다" # 2단계: 틀리면 벡터 조정 if 예측 != 정답: # "안녕하세요" 관련 벡터들을 조금씩 수정 # "습니다"가 나올 확률이 높아지도록 "안"의_벡터[0] += 0.001 # 1번째 차원 미세 조정 "안"의_벡터[1] -= 0.002 # 2번째 차원 미세 조정 "안"의_벡터[2] += 0.001 # 3번째 차원 미세 조정 ... "안"의_벡터[767] += 0.001 # 768번째 차원 미세 조정 # "녕", "하", "세", "요" 벡터들도 모두 조정 ``` ### 패턴 발견과 차원 특화 ```python # 수백만 번 학습 후, 컴퓨터가 자동으로 발견하는 패턴들 # 패턴 1: 인사말 관련 자주_등장하는_조합 = [ "안녕하세요" + "반갑습니다", # 1000번 등장 "안녕하세요" + "어떻게", # 800번 등장 "안녕하세요" + "오늘", # 600번 등장 "안녕하세요" + "처음", # 400번 등장 ] # 결과: 특정 차원이 "인사말 정도"를 나타내게 됨 "안"의_벡터[4] = 0.8 # 5번째 차원 = 높은 값 = 인사말 "하"의_벡터[4] = 0.7 # 높은 값 = 인사말 "컴"의_벡터[4] = 0.1 # 낮은 값 = 인사말 아님 "퓨"의_벡터[4] = 0.1 # 낮은 값 = 인사말 아님 # 패턴 2: 시간대 관련 시간대_패턴 = [ "안녕하세요" + "좋은 아침", # 아침 인사 "안녕하세요" + "점심", # 점심 인사 "안녕하세요" + "저녁", # 저녁 인사 ] # 결과: 다른 차원이 "시간대"를 나타내게 됨 "안"의_벡터[22] = 0.3 # 23번째 차원 = 시간 중립적 "아"의_벡터[22] = 0.9 # 높은 값 = 아침 관련 "저"의_벡터[22] = 0.1 # 낮은 값 = 저녁 관련 # 패턴 3: 격식 수준 격식_패턴 = [ "안녕하세요" + "습니다", # 정중함 "안녕하세요" + "입니다", # 정중함 "안녕" + "야", # 친근함 "안녕" + "ㅋㅋ", # 친근함 ] # 결과: 또 다른 차원이 "격식 수준"을 나타내게 됨 "안"의_벡터[67] = 0.6 # 68번째 차원 = 중간 격식 "요"의_벡터[67] = 0.9 # 높은 값 = 정중함 "야"의_벡터[67] = 0.1 # 낮은 값 = 친근함 ``` ## 4. 구체적인 3차원 학습 시뮬레이션 ### 학습 전후 비교 ```python # === 학습 전 (의미 없는 랜덤) === embedding_table_초기 = { "안": [0.1, 0.2, 0.3], # 랜덤값 "녕": [0.4, 0.5, 0.6], # 랜덤값 "컴": [0.7, 0.8, 0.9], # 랜덤값 "퓨": [0.2, 0.3, 0.4], # 랜덤값 } # === 학습 과정 시뮬레이션 === for 학습_사이클 in range(1000000): # 100만 번 반복 # 학습 데이터 1: "안녕" → "하세요" if "안녕하세요" in 학습문장: # "안"과 "녕"의 벡터를 "하세요"가 나오도록 조정 embedding_table["안"][0] += 0.00001 # 1번째 차원 미세 조정 embedding_table["안"][1] -= 0.00001 # 2번째 차원 미세 조정 embedding_table["녕"][0] += 0.00001 # 1번째 차원 미세 조정 # 학습 데이터 2: "컴퓨터" → "프로그램" if "컴퓨터 프로그램" in 학습문장: # "컴"과 "퓨"의 벡터를 "프로그램"이 나오도록 조정 embedding_table["컴"][0] -= 0.00001 # 인사말과 반대 방향 embedding_table["컴"][2] += 0.00001 # 기계 관련 특성 강화 embedding_table["퓨"][0] -= 0.00001 embedding_table["퓨"][2] += 0.00001 # === 학습 후 (의미를 가진 벡터) === embedding_table_학습후 = { "안": [0.8, 0.2, 0.1], # 1번째 차원: 인사말 높음 "녕": [0.7, 0.3, 0.1], # 1번째 차원: 인사말 높음 "컴": [0.1, 0.8, 0.9], # 2,3번째 차원: 기계 관련 높음 "퓨": [0.1, 0.7, 0.8], # 2,3번째 차원: 기계 관련 높음 } # 각 차원의 의미 (자동으로 생성됨) 차원의_의미 = { "1번째 차원": "인사말 여부", "2번째 차원": "기계/기술 관련성", "3번째 차원": "전문성 수준" } ``` ## 5. 768차원이 필요한 이유 ### 언어의 복잡한 특성들 ```python 언어의_복잡성 = [ # 문법적 특성 "품사", # 명사, 동사, 형용사 등 "주어/목적어", # 문장 내 역할 "시제", # 과거, 현재, 미래 "어미변화", # 다양한 활용형 # 의미적 특성 "구체성", # 추상적 vs 구체적 "감정", # 긍정, 부정, 중립 "범주", # 사물, 사람, 행동, 상태 "추상도", # 물리적 vs 개념적 # 사용법 특성 "격식수준", # 존댓말, 반말 "빈도", # 자주 vs 드물게 사용 "지역성", # 표준어, 방언 "세대", # 젊은층, 기성세대 용어 # 문맥적 특성 "동반단어", # 어떤 단어와 자주 등장 "선후관계", # 앞/뒤에 오는 단어 패턴 "도메인", # 과학, 문학, 일상 등 "상황", # 공식적, 비공식적 # ... (수백 가지 더 많은 특성들) ] # 이 모든 복잡한 특성을 표현하려면 768개 차원이 필요! ``` ### 차원별 특화 예시 (가상의 해석) ```python # 실제로는 학습을 통해 자동으로 결정되지만, 가상의 해석: "안녕하세요"의_768차원_벡터 = [ 0.9, # 1번째 차원: "인사말" 정도 0.1, # 2번째 차원: "질문" 정도 0.8, # 3번째 차원: "정중함" 정도 0.5, # 4번째 차원: "친근함" 정도 0.2, # 5번째 차원: "명령문" 정도 0.7, # 6번째 차원: "일상성" 정도 0.3, # 7번째 차원: "시간관련성" 정도 0.6, # 8번째 차원: "대화시작" 정도 ... # 9번째~768번째: 기타 미묘한 의미들 0.4 # 768번째 차원: 알 수 없는 추상적 특성 ] ``` ## 6. 실제 언어모델에서의 동작 ### 전체 과정 정리 ```python # 1단계: 토큰화 "안녕하세요" → ["안", "녕", "하", "세", "요"] → [1909, 1169, 2546, 1770, 2008] # 2단계: 임베딩 (각 토큰 → 768차원 벡터) 1909 ("안") → [0.1234, -0.5678, 0.2345, ..., 0.7654] # 768개 숫자 1169 ("녕") → [0.2345, -0.6789, 0.3456, ..., 0.8765] # 768개 숫자 2546 ("하") → [0.3456, -0.7890, 0.4567, ..., 0.9876] # 768개 숫자 1770 ("세") → [0.4567, -0.8901, 0.5678, ..., 0.0987] # 768개 숫자 2008 ("요") → [0.5678, -0.9012, 0.6789, ..., 0.1098] # 768개 숫자 # 3단계: 문맥 고려 (Transformer가 담당) # 각 위치의 768차원 벡터들이 서로 상호작용하여 최종 벡터 생성 # 4단계: 다음 단어 예측 최종_768차원_벡터 → nn.Linear(768, 2701) → 2701개_단어_확률 ``` ### 메모리와 계산량 ```python # 메모리 사용량 계산 한_토큰_메모리 = 768차원 × 4바이트(float32) = 3,072바이트 = 3KB # "안녕하세요"(5토큰) 5토큰 × 3KB = 15KB # 긴 문서(1000토큰) 1000토큰 × 3KB = 3MB # GPT-3의 경우 (12,288차원) 한_토큰_메모리 = 12,288차원 × 4바이트 = 48KB ``` ## 7. 왜 이렇게 복잡한가? ### 언어의 미묘함 ```python # 같은 "안녕"이어도 상황에 따라 다른 의미 상황별_안녕 = { "안녕하세요": "정중한 인사", "안녕": "친근한 인사", "안녕히 가세요": "이별 인사", "안녕히 계세요": "이별 인사 (머무는 사람에게)", "안녕 못하겠다": "걱정, 우려" # 완전히 다른 의미! } # 이런 미묘한 차이를 모두 구별하려면 많은 차원이 필요 ``` ### 비슷한 단어들의 관계 ```python # 학습된 임베딩에서 유사도 (코사인 유사도) 유사도_예시 = { ("안녕", "하이"): 0.85, # 둘 다 인사말 → 높은 유사도 ("안녕", "세요"): 0.72, # 자주 함께 등장 → 높은 유사도 ("안녕", "사과"): 0.15, # 관련 없음 → 낮은 유사도 ("안녕", "컴퓨터"): 0.08, # 관련 없음 → 낮은 유사도 } # 768차원의 미묘한 수치 차이로 이런 관계들을 모두 표현! ``` ## 8. 핵심 정리 ### 차원 생성 원리 1. **처음에는 완전 랜덤**: 768개 숫자가 아무 의미 없음 2. **패턴 학습**: 수백만 문장에서 "어떤 단어 다음에 어떤 단어가 오는지" 학습 3. **자동 특화**: 각 차원이 저절로 서로 다른 언어적 특성을 담당하게 됨 4. **의미 창발**: 사람이 설계하지 않아도 의미 있는 표현이 자동 생성 ### 컴퓨터의 학습 방식 - **통계적 패턴 인식**: "이 단어 다음에는 보통 저 단어가 온다" - **미세한 조정**: 틀릴 때마다 768개 숫자를 조금씩 수정 - **반복 학습**: 수백만 번 반복으로 최적의 숫자 조합 발견 ### 768차원의 의미 - **각 차원 = 하나의 언어적 특성** - **768개 = 언어의 복잡한 특성들을 표현하기에 적당한 개수** - **더 많은 차원 = 더 정교한 표현 (하지만 메모리와 계산량 증가)** **핵심**: 컴퓨터는 의미를 모르고 시작하지만, 수많은 텍스트를 학습하면서 768개 차원에 언어의 모든 미묘함을 자동으로 저장하게 됩니다! ## 관련 참고 자료 - [[torch.nn 선형 레이어와 임베딩 레이어 대학생 수준 완벽 가이드]] - [[02일차_2장 to 2.4_GPT 기초]] - [[GPT 배치 생성 함수 한글 예시로 완벽 이해]]