Token Lab검색

AI INFRA / KUBERNETES

Kubernetes AI 전체 과정: 원시 코퍼스에서 토큰 생성 API까지

데이터·학습·체크포인트·릴리스·추론 전 과정을 구축합니다. 검증한 CPU 실습, 선택적 GPT-2 학습과 Kubernetes 구성을 제공합니다.

출처 및 버전 정보
이 글의 목차

구조와 책임 경계

공급업체 내부 구조가 아닌 독자 참조 설계입니다. 파랑은 산출물, 주황은 비공개 요청, 점선은 거부·복원입니다. 게이트웨이가 대기열 전에 인증·예산을 확인합니다. CPU 실습은 외부 게이트웨이 대신 비공개 port-forward를 사용합니다.
공급업체 내부 구조가 아닌 독자 참조 설계입니다. 파랑은 산출물, 주황은 비공개 요청, 점선은 거부·복원입니다. 게이트웨이가 대기열 전에 인증·예산을 확인합니다. CPU 실습은 외부 게이트웨이 대신 비공개 port-forward를 사용합니다. 원본 크기로 보기
단계입력 → 출력책임과 실패 경계
수집기록 → 불변 스냅샷데이터 담당: 미허가·잘못된 형식을 격리·기록.
전처리스냅샷 → 분할·토크나이저데이터 엔지니어: 스키마·중복·누수 경계, 재시도 시 분할 유지.
학습버전 데이터·설정 → 체크포인트학습 담당: 모든 rank 함께 복구, 미완료 저장 사용 금지.
릴리스후보·근거 → 승인 버전모델 담당: 거부 시 현재 버전 보존, 승인 기준 버전 기록.
서빙승인 가중치·토크나이저 → 준비 복제본플랫폼: 해시 검증 후 로드·워밍업, 실패 복제본에 트래픽 차단.
요청허가 입력·토큰 예산 → 스트림게이트웨이·엔진: 대기열·기한·취소 제어, 관측 출력 재생성 금지.

도구보다 서비스 계약부터 정의하기

버전 관리된 코퍼스로 학습하는 비공개 텍스트 완성 서비스를 만듭니다. 오프라인은 허용 기록→데이터→토크나이저→학습→체크포인트→승인 버전, 온라인은 인증→예산→토큰화→실행→생성 토큰 반환입니다. Kubernetes는 프로세스를 배치하지만 데이터·모델 품질이나 권한을 보장하지 않습니다.

키트는 실제 학습한 작은 bigram 모델로 전 과정을 연결합니다. 로컬 학습, 정확한 재개, 무결성, HTTP와 스트리밍은 실행했습니다. 2층 GPT-2 학습 코드와 vLLM 참조는 제공하지만 실행하지 않았습니다. 이 환경에는 Docker·클러스터·GPU가 없습니다. CPU 실습과 운영 GPU 플랫폼을 구분하며 작은 모델은 실용적인 도우미가 아닙니다.

기록 d17을 따라가면 원본 R1→정제 C2→데이터 D3→토크나이저 T1→실행 J4→체크포인트 K400→내보내기 M1입니다. 릴리스 R7은 M1·T1·이미지 digest·생성 한도를 묶습니다. 요청 q9는 시작 때 별칭을 R7로 한 번만 해석합니다. 제어면은 목표 버전·정책을 바꾸고 데이터면은 바이트 이동·계산을 합니다. 레지스트리는 참조·근거이며 GPU 프로세스가 아닙니다. Service는 체크포인트가 아니라 복제본으로 연결합니다. 별칭 변경은 배포 완료가 아닙니다.

장애를 설명하는 선수 지식

이미지는 코드와 라이브러리를 포함하지만 호환되는 호스트 GPU 드라이버까지 포함하지 않습니다. Pod는 실행 단위, Job은 완료 추적, Deployment는 복제 유지, Service는 엔드포인트 선택입니다. PVC의 접근 모드와 토폴로지도 중요합니다. 데이터 커서·옵티마이저 없이 재시작하면 학습 복구가 아닐 수 있습니다.

토큰은 특정 토크나이저의 정수, logits는 점수, softmax는 확률, 교차 엔트로피는 손실입니다. 학습은 가중치를 갱신하고 추론은 고정 가중치를 씁니다. 재개 체크포인트는 추론 내보내기보다 많은 상태를 포함합니다. 일관성·HTTP·TLS·신원·지표가 올바른 모델과 호출자를 연결합니다.

kubectl의 Job은 API server에서 인증·인가·admission 후 저장됩니다. 컨트롤러가 Pod를 만들고 scheduler가 자원 요청·제약·볼륨 토폴로지로 노드를 고릅니다. kubelet은 runtime에 컨테이너 시작을 요청합니다. device plugin은 GPU를 광고하고 CSI는 볼륨을 준비합니다. 옵티마이저는 컨테이너 안에서 실행됩니다. Running이어도 모델 로딩 중일 수 있어 Service 자격은 readiness로 판단합니다. startup probe는 초기화 중 조기 재시작을 방지하며 readiness 실패 자체는 재시작하지 않습니다.

수집: 학습 윈도보다 불변 기록 먼저

각 소스에 ID·권한·취득 시각·해시·보존 규칙을 붙이고 원본 스냅샷과 정제 코드 버전을 보존합니다. 표·코드·문서 경계를 지키며 정확·근사 중복을 구분합니다. 중첩 윈도를 만들기 전에 소스·사용자·시간 단위로 나눠 검증 누출을 막습니다. 해시 분할만으로 관련 문서를 묶지는 못합니다.

키트는 독창적인 CC0 합성 JSONL의 공백 정규화·정확 중복 제거·해시 분할을 수행합니다. 운영에는 개인정보·동의·격리·출처 균형·파생물 삭제 전파가 필요합니다. 카탈로그는 계보를 기록할 뿐 학습 권한을 결정하지 않습니다. 객체 삭제는 가중치의 망각이 아니며 재학습이 필요할 수 있습니다.

원본 offset은 명시한 프로토콜로 불변 객체와 manifest 항목을 영속화한 뒤 확인합니다. 재시도는 같은 내용 주소 객체를 다시 쓸 수 있지만 변환 버전이 바뀌면 파생 ID도 바뀝니다. 해시는 동의·품질·의미 유사성을 입증하지 않습니다. 유사 중복을 군집화한 뒤 그룹 분할합니다. hash mod 5의 검증 비율은 기대20%이지 유한 데이터의 정확20%가 아닙니다. 원본100 GB와 파생60 GB는 최소160 GB입니다. 스트리밍 shard는 메모리를 제한하지만 압축·크기·순서가 CPU와 읽기 증폭을 결정합니다.

토크나이저·패킹·학습 계약

버전에는 어휘·정규화·특수 ID·필요한 채팅 템플릿이 포함됩니다. 다른 토크나이저는 입력 ID를 조용히 바꿉니다. Transformer 예제는 훈련 데이터로만 바이트 BPE를 학습하고 EOS를 붙이며 패딩을 손실에서 제외합니다. 문서 패킹은 어텐션의 문서 경계 통과 여부를 명시해야 합니다.

ID·라벨은 B×T, logits는 B×T×V입니다. 인과 모델은 다음 토큰을 예측합니다. 제공 모델은 내부에서 라벨을 이동하므로 ID를 복사하고 패딩을−100으로 만들되 로더에서 또 이동하지 않습니다. 검증도 같은 계약과 유효 토큰 수 가중치를 사용합니다.

가상 예시로 “AI helps”→[17,42], 이라면 [17,42,1]은 17→42와 [17,42]→1을 학습합니다. 키트 실제 ID는 아닙니다. B4·T128·V512이면 logits262144개, FP32로1 MiB입니다. embedding이 B×T×d로 바꾸고 위치 정보가 순서를 나타냅니다. 문서 packing 시 뒷문서가 앞문서를 볼 수 있는지 정해야 합니다. EOS는 자동 어텐션 방화벽이 아니며 손실 padding 마스크와 attention 마스크는 별개입니다.

학습이 실제 계산하는 것

순전파는 임베딩·인과 층에서 logits를 만들고 손실은 정답 다음 토큰의 낮은 확률을 벌합니다. 역전파는 도함수를, AdamW는 모멘트·가중치 갱신을 계산합니다. 누적 시 손실 스케일을 맞춰야 합니다. 마이크로배치2×누적8×데이터 병렬4는64시퀀스이며 같은 토큰 수를 뜻하지 않습니다.

실측 예제는 직전 문자만 보는 V×V 표를 학습합니다. 실제 자기회귀 학습이지만 어텐션은 없습니다. 선택 GPT-2는2층·4헤드·폭128로 패키징을 가르칩니다. 사전학습·SFT·선호 학습·RL은 데이터·참조 모델·자원 패턴이 다르며 rollout 서비스는 옵티마이저 Job과 다릅니다.

손실의 b는 시퀀스, t는 다음 토큰 위치, m은 유효 목표1·padding0, N_valid는 m 합입니다. B_micro는 복제본당 시퀀스 수, A는 누적 횟수, D는 데이터 병렬 수입니다. 유효 토큰 수가 다르면 마이크로배치 동일 평균은 토큰 평균과 다릅니다.

인과 head는 T×d_model의 X에서 Q·K·V를 계산합니다. QKᵀ는 T×T이고 미래 점수를 −∞로 가린 뒤 행 softmax와 V 곱으로 T×d_h를 얻습니다. 출력 투영·잔차는 폭을 유지하고 FFN은 위치별, attention은 위치 사이를 처리합니다. 역전파는 연쇄법칙입니다. logits[0,0], 목표1이면 확률[0.5,0.5], 손실0.6931, 기울기[0.5,−0.5]입니다. SGD0.1 후[−0.05,0.05], 손실≈0.6444입니다. AdamW는 두 모멘트·초기 편향 보정·분리된 감쇠를 사용하므로 가중치만 복원하면 다음 갱신이 바뀝니다.

M은 허용0·미래−∞ mask, d_h는 폭, z_j는 logit, y는 목표ID입니다. AdamW의 g_t는 기울기, β₁/β₂는 계수, η는 학습률, λ_w는 감쇠, ε는 안정항입니다. 제곱은 요소별이며 편향 보정·AMSGrad 없는 일반식입니다. 정밀도·구현에 따라 수치는 달라집니다.

병렬화와 스케줄링 구분하기

데이터 병렬은 복제·기울기 동기화, 텐서 병렬은 층 내부 분할, 파이프라인은 층 분할, 샤딩은 상태 분할입니다. 혼합 정밀도 Adam의 한 구현은 활성값 전 약16바이트/매개변수로7입니다. BF16 추론 가중치14GB와 다르며 보편 상수도 아닙니다.

rank마다 world size·rendezvous·집합 통신 순서를 맞춰야 합니다. 연결망이 동기화 비용을 결정합니다. Kueue형 승인은 할당량을, gang 배치는 일부 worker만 점유하는 문제를 다룹니다. rank 장애에는 시간 제한·협조 종료·완전 체크포인트 재개가 필요합니다. Deployment 복제 증가가 분산 학습기는 아닙니다.

같은 로컬 배치라면 각 g_r을 all-reduce 합산 후 D로 나눕니다. 유효 토큰 수가 다르면 전역 토큰 수로 가중해야 합니다. 이상적 ring은 rank당2(D−1)G/D 바이트를 전송합니다. D4·G8 GB이면12 GB,25 GB/s에서 대역폭 하한0.48초입니다. 텐서 병렬은 층 내부 통신이 잦아 빠른 링크가 유리합니다. ZeRO는 옵티마이저·기울기·파라미터를 순차 분할해 통신과 메모리를 교환합니다. 파이프라인은 bubble도 생겨 stage 증가가 속도를 보장하지 않습니다.

G는 복제본 기울기 bytes, D는 rank 수, B_net은 유효bytes/s이며 십진 단위입니다. 전체 예측이 아닌 하한입니다.

두 수명주기에 맞는 Kubernetes 자원

유한한 준비·학습은 Job, 지속 추론은 Deployment, 내부 이름은 Service를 사용합니다. CPU 준비·GPU 학습·저지연 추론의 풀과 우선순위를 나누고 CPU·RAM도 확보합니다. 드라이버·런타임·플러그인이 GPU 자원을 노출하며 GPU 제한을 초과 예약해도 메모리는 생기지 않습니다.

키트는 namespace·RWO 볼륨·Job·Deployment를 씁니다. 읽기 전용과 해시로 불완전 산출물을 거부하고 단순화를 위해 Recreate의 중단을 수용합니다. 운영에서는 불변 승인 객체를 Pod별로 독립 배치하고 완전히 로드한 후 ready로 만듭니다. 스토리지와 GPU의 배치 영역을 맞춰야 합니다.

CPU request1은 배치 예약이고 limit2는 runtime/cgroup 소비 한도입니다. memory request는 배치를 돕고 limit 초과는 OOM을 일으킬 수 있습니다. GPU 자원은 남은 VRAM 바이트가 아닌 장치 수입니다. Pending은 장치·affinity·볼륨을 구분하고 시작 후 CUDA 실패는 드라이버/runtime/권한을 봅니다. RWO는 한 노드 읽기·쓰기이지 Pod 하나나 노드 간 공유 FS가 아닙니다. 실습 볼륨은 분산 데이터 서비스가 아닙니다.

체크포인트·후보·출시 버전 구분

재개점은 가중치·옵티마이저·스케줄러·step·난수·데이터 버전·위치를 저장합니다. 샤드를 임시 위치에 쓰고 모두 완성된 뒤 완료 표식을 게시합니다. 객체 저장소는 다중 쓰기를 원자적으로 만들지 않으며 읽기는 완전한 명세만 선택합니다.

추론 내보내기는 구조·토크나이저·adapter·정밀도·해시·라이선스를 보존하고 학습 상태는 뺍니다. 레지스트리는 산출물과 승인 카탈로그입니다. 출시는 환경별 후보·이미지·설정을 묶고 롤백은 모델 이름만 아니라 호환 조합 전체를 복원합니다.

고유 shard를 쓰고 해시를 계산한 뒤 전체 크기·해시 manifest를 만듭니다. 완전성 확인 후 조건부 쓰기로 최신 완료 포인터를 바꿉니다. 읽기는 manifest를 검증하며 파일 목록으로 버전을 추측하지 않습니다. 이전 장애는 쓰레기만 남깁니다. 키트의 임시 파일+rename은 부분 파일 노출을 막지만 전원 장애 내구성은 FS·디렉터리 동기화에도 달립니다. 유효 파일이 좋은 모델을 뜻하지 않고 rollback도 전달한 토큰을 취소하지 못합니다.

모델 파일에서 첫 토큰과 후속 토큰까지

ready 전에 산출물 검증·가중치 로드·버퍼 할당·커널 초기화·대표 형태 워밍업을 합니다. prefill은 프롬프트에서 KV를 만들고 decode는 이를 재사용해 생성합니다. 연속 배칭은 효율을 높이지만 공정성과 취소가 필요합니다. 토큰화·큐·통신 버퍼도 첫 토큰 시간을 좌우합니다.

×층×KV헤드×헤드차원×바이트×상주토큰입니다.32층·8KV헤드·128차원·BF16이면131,072바이트/토큰,8,192토큰은 부가 비용 전1GiB입니다. GQA의 KV헤드와 질의헤드를 혼동하면 안 됩니다. 가중치가 들어가도 문맥이 못 들어갈 수 있고 가중치·KV 양자화는 별개입니다.

L은 층 수, H_KV는 KV헤드 수, d_h는 폭, b는 스칼라당 바이트, T_i는 시퀀스 i의 상주 토큰 수입니다. 2는 key와 value입니다. 할당 오버헤드는 제외하며 잠재 어텐션·압축 캐시에 그대로 적용할 수 없습니다.

Prefill은 T위치를 계산해 층별 K/V를 저장합니다. Decode는 query 하나를 추가해 이전 K/V 재계산 없이 커지는 캐시를 읽습니다. 밀집 prompt 상호작용은 대략 제곱, decode 한 단계는 문맥에 선형이며 투영·FFN은 별도입니다. 페이지 KV는 논리 block을 물리 block으로 매핑합니다. block16, 길이17·31은64slot 중16미사용이고 각128 예약이면256slot입니다. 속도 측정이 아닙니다. prefix 공유는 모델·토큰화·위치·설정 일치와 안전한 참조 계수가 필요합니다.

P는 block당 토큰, T_i는 길이입니다. 시퀀스마다 block 단위 올림하며 prefix공유·metadata는 제외합니다.

페이지 KV: 논리 길이와 물리 용량. 4블록×16=64슬롯, 48사용·16미사용. 할당·상태 도식이며 성능 실측이 아닙니다.
페이지 KV: 논리 길이와 물리 용량. 4블록×16=64슬롯, 48사용·16미사용. 할당·상태 도식이며 성능 실측이 아닙니다. 원본 크기로 보기

API를 제어된 상태 머신으로 보기

client→TLS→신원·정책→할당량·승인→router→비공개 추론→stream 순서입니다. GPU 사용 전 본문 크기·모델 권한·토큰 길이·출력 예약을 확인합니다. request ID로 추적하고 alias는 요청 동안 같은 버전을 가리킵니다.

stream은 증분 이벤트입니다. 버퍼·기한을 맞추고 공개 후 재시도의 중복 텍스트·과금을 막습니다. 재시도는 공개 전으로 제한하거나 재개 계약을 정의합니다. 연결 종료를 엔진에 전달해 KV·슬롯을 반환하며 도구 제안을 거래 권한으로 오해하지 않습니다.

클라이언트 tenant 필드를 믿지 말고 자격을 검증합니다. 주체를 허용 모델·예산으로 매핑하고 해당 토크나이저로 입력+예약 출력≤문맥을 확인합니다. 용량을 예약하고 실제 사용으로 정산합니다. SSE는 빈 줄로 이벤트를 구분하므로 TCP 조각을 버퍼링해야 합니다. HTTP 성공 후 생성 실패도 가능해 두 종료 상태를 기록합니다. EOS·한도·기한·취소로 중단합니다. temperature의 logits 조정은 사실성을 보장하지 않습니다.

요청 상태: 할당·출력·취소. 용량은 한 번만 해제. 할당·상태 도식이며 성능 실측이 아닙니다.
요청 상태: 할당·출력·취소. 용량은 한 번만 해제. 할당·상태 도식이며 성능 실측이 아닙니다. 원본 크기로 보기

용량·자동 확장·배포 비용

GPU 비율뿐 아니라 큐 길이·나이·시퀀스·토큰·KV·첫 토큰 및 토큰 간 시간을 봅니다. Little 법칙은 안정 상태 평균이지 포화 시 꼬리를 예측하지 않습니다.10요청/초×2초=20진행 중이지만 메모리는 문맥에도 의존합니다.

시작에는 배치·다운로드·로드·워밍업이 필요해 HPA가 없애지 못합니다. 여유를 예약하고 큐를 제한합니다. canary는 비슷한 분포로 비교합니다. PDB는 자발적 중단만 제한합니다. drain은 새 승인을 막고 유한 stream을 마칩니다. 단일 GPU Recreate는 중단되며 유휴·배포 용량도 비용에 포함합니다.

TTFT를 진입·인증토큰화·대기·prefill·전송으로 나눕니다. 예20+10+80+150+10=270 ms입니다. prefill30 ms 절약으로 수초 대기는 해결되지 않습니다. batching은 전체 처리량을 높여도 개별 대기를 늘릴 수 있습니다. 교육 M/M/1의 μλ에서 μ10/s·λ8/s는0.5초, λ9.5/s는2초입니다. 실제 예측식이 아닌 포화 민감도 예시입니다. 요청 수만 아니라 잔여 작업량·시작 시간으로 확장합니다.

모든 단계의 보안과 관측성

수집·학습·승인·서비스 신원을 분리합니다. 서비스 Pod는 승인 산출물을 읽고 자체 승격·데이터 변경은 못 합니다. 단기 자격·출구 제한·감사를 쓰고 불필요한 Kubernetes 토큰은 빼세요. NetworkPolicy는 CNI에 의존하며 API 사용자 인증이 아닙니다.

데이터 해시·run·체크포인트·release·이미지·request를 연결하고 거부·처리량·손실·저장 시간·GPU 오류·큐·토큰·취소를 측정합니다. 프롬프트나 임의 ID를 지표 라벨로 쓰면 고카디널리티·누출 위험이 생깁니다. trace는 접근·보존을 제어합니다. 관측 누락은 무장애 증거가 아니며 가용성은 정확성과 다릅니다.

권한은 별도 추적합니다. trainer는 D3읽기·자기run쓰기, 릴리스 컨트롤러는 승인, 서빙 주체는 승인본 읽기만 합니다. label은 tenant 인증이 아닙니다. NetworkPolicy는 연결, IAM은 객체 작업을 제어합니다. queue/prefill/decode span, 승인거부counter, 지연histogram, 용량gauge를 수집합니다. ID는 sampled trace·exemplar에 두고 무한 label로 쓰지 않습니다. 응답에 버전을 기록합니다. span 부재는 샘플링·유실·미완료일 수도 있습니다.

제어 지점과 제약으로 스택 선택

클라우드는 노드·저장·신원을 제공해도 데이터 계약과 승인은 팀 책임입니다. NVIDIA는 장치, PyTorch는 학습, Kubernetes는 조정, vLLM은 서비스·KV에 가깝습니다. 레지스트리는 목록, 객체 저장소는 바이트, 게이트웨이는 외부 승인을 담당합니다. 대시보드로 출시 권한을 대신하지 마세요.

prefill/decode 분리·KV 전송·prefix 라우팅·offload는 효율 대신 통신·취소 상태를 늘립니다. adapter·양자화·추측 생성도 격리·보정·계산을 추가합니다. 먼저 단일 노드의 불변성과 병목을 측정하세요. 이식 성능·공정성·감사 가능한 삭제·긴 문맥 품질·대규모 복구는 열린 문제입니다.

최적화가 옮기는 자원을 봅니다. 양자화는 가중치·정밀도를 줄이지만 보정·커널이 필요하고 KV가 자동 감소하지 않습니다. prefix cache는 의미 유사성이 아닌 호환 공통 prefix가 조건입니다. prefill/decode 분리는 KV전송을 더하며1 GiB를10 GiB/s로 옮기는 하한만0.1초입니다. 추측 decode는 초안·검증을 하므로 수용률·검증 비용이 중요합니다. 원래 병목·옮긴 작업·새 장애·단순 설계가 이기는 조건을 설명해야 합니다.

실습과 검증

전체 소스 다운로드

1. CPU 전체 과정 실행

Python 3.11 독립 환경에서 압축을 풀고 작업합니다. 원본 CC0 합성 기록 100개는 파이프라인 확인용입니다. 정규화·중복 제거·안정 해시 분할 후 토큰 쌍을 만듭니다. 시드 42, SGD로 다음 문자 교차 엔트로피를 줄이며 Attention은 없습니다. NLL<4는 이 실습만의 승인 기준입니다.

python3.11 -m venv .venv
. .venv/bin/activate
pip install -r requirements.txt
python pipeline.py prepare --source corpus.jsonl --root ./run
python pipeline.py train --root ./run --steps 400
python pipeline.py promote --root ./run
python serve.py --root ./run --port 8000
# In another terminal
curl -s http://127.0.0.1:8000/health
curl -s http://127.0.0.1:8000/v1/completions -H 'Content-Type: application/json' \
  -d '{"prompt":"A model","max_tokens":16}'
curl -N http://127.0.0.1:8000/v1/completions -H 'Content-Type: application/json' \
  -d '{"prompt":"A model","max_tokens":16,"stream":true}'

2. CPU 버전 빌드·배치

Docker, kubectl, fsGroup 지원 기본 StorageClass, NetworkPolicy 지원 CNI가 필요합니다. kind는 로컬 이미지를 로드하고 다른 클러스터는 레지스트리 push 후 두 image 필드를 바꿉니다. restricted·UID10001·API 토큰 미탑재·비공개 Service입니다. 단일 RWO와 Recreate는 단순성을 위해 가용성을 희생합니다. 첫 승인 전 재시작은 예상되나 운영에서는 승인 후 배치합니다. 공개 인터넷에 노출하지 마세요.

docker build -t tokenlab-ai:local .
# For kind only; otherwise push image to your registry and edit YAML
kind load docker-image tokenlab-ai:local
kubectl apply -f kubernetes.yaml
kubectl -n tokenlab-ai wait --for=condition=complete job/train-v1 --timeout=600s
kubectl -n tokenlab-ai rollout status deployment/model-v1 --timeout=300s
kubectl -n tokenlab-ai port-forward service/model-api 8000:8000
# Then run the curl commands above; Ctrl-C stops the local tunnel.

3. 실제 Transformer 학습으로 전환

선택 경로는 학습 기록만으로 byte-BPE를 학습하고 무작위 초기화 2층 GPT-2를 훈련합니다. 4헤드·차원128·문맥128·AdamW 3e-4입니다. padding 라벨은 -100이며 GPT-2 내부에서 이동하므로 중복 이동하지 않습니다. 옵티마이저·RNG를 저장하고 safetensors·토크나이저·설정을 내보냅니다. 토큰 가중 검증 NLL 승인 후 approved/를 만들며 기존 릴리스를 덮어쓰지 않습니다. 이 경로는 미실행입니다.

# Separate environment recommended; optional path not executed here
pip install -r requirements-transformer.txt
python transformer.py --root ./run --steps 200
python transformer.py --root ./run --steps 400 --resume
python approve_transformer.py --root ./run --max-nll 4.0
# Optional training Job (existing namespace/PVC required)
docker build -f Dockerfile.transformer -t tokenlab-transformer:lab .
kind load docker-image tokenlab-transformer:lab
kubectl -n tokenlab-ai scale deployment model-v1 --replicas=0
kubectl apply -f transformer-job.yaml
kubectl -n tokenlab-ai wait --for=condition=complete job/transformer-train --timeout=7200s

4. GPU 추론: 별도 검증이 필요한 통합

선택 Job은 같은 artifacts PVC를 사용하므로 노드 간 RWO 충돌을 피하려 CPU Deployment를 중지합니다. vLLM은 승인 모델과 비공개 Service를 사용합니다. 0.14.0 문서에 GPT2LMHeadModel이 있지만 이 내보내기는 미검증입니다. UID·캐시·보안 컨텍스트를 restricted에 맞추고 정책을 약화하지 마세요. 호환 드라이버·device plugin·GPU·스토리지가 필요합니다.

실측·실패 사례·공정 비교

CPU 초기 NLL 3.73767 nat/token, 400스텝 후 1.70074, 검증 1.70306입니다. bigram 손실이며 Transformer 벤치마크가 아닙니다. 연속400과 재개200+200의 바이트 일치, HTTP/SSE 종료, 잘못된 예산, 산출물 변조를 확인합니다. 직접 재현하고 공급업체 비교에 쓰지 마세요.

python verify.py
python mechanism_math.py
# PASS: loss descent, exact resume, artifact integrity, HTTP generation, SSE, invalid input

클러스터에서는 학습 중단·후보 변조·미지 문자·동시성 고갈·SSE 연결 해제·readiness 실패를 시험합니다. 데이터·토크나이저·정밀도·길이·도착 부하·하드웨어를 고정하고 대기·TTFT·토큰 간 지연·실패·비용·품질을 함께 보고합니다. 빠른 실패는 개선이 아닙니다. 단일 복제본은 무중단 전환을 입증하지 못합니다.

독창적 면접 연습 · 실제 기업 기출 아님

1. 가중치를 복원해도 재개 결과가 다른 이유는?

힌트 1

Adam과 다음 배치를 생각하세요.

힌트 2

RNG·모멘트·스케줄러·데이터 커서·병렬 구조가 다음 갱신에 영향을 줍니다.

답과 분석

추론 내보내기와 재개 체크포인트는 다릅니다. 데이터 지문·옵티마이저·RNG를 복원하고 정확 일치 또는 통계적 동등성을 정의합니다. 하드웨어 간 GPU 정확 일치는 보장되지 않습니다. 연속 실행과 중단 실행을 비교하세요.

채점: 1 구성요소 명명, 2 상태 설명, 3 장애 추적, 4 올바른 복구와 한계, 5 공정한 반례와 절충 근거.

2. 14 GB 모델이 24 GB GPU에서 실패하는 이유는?

힌트 1

가중치는 메모리의 일부입니다.

힌트 2

KV·활성화·런타임 예약·단편화를 포함하세요.

답과 분석

32층·KV8헤드·헤드차원128·BF16이면 128 KiB/token입니다. 8192토큰 8시퀀스는 KV만 8 GiB이며 14십진GB 가중치가 추가됩니다. 허용 토큰을 제한하고 피크를 측정하세요. 가중치 양자화가 KV 양자화를 뜻하지 않습니다.

채점: 1 구성요소 명명, 2 상태 설명, 3 장애 추적, 4 올바른 복구와 한계, 5 공정한 반례와 절충 근거.

3. 첫 토큰 전송 후 재시도해야 하나요?

힌트 1

클라이언트가 이미 출력을 봤나요?

힌트 2

재생성은 텍스트 중복·변경·중복 과금을 유발할 수 있습니다.

답과 분석

관측된 스트림을 투명하게 재생성하지 마세요. 동일 이벤트 재개 프로토콜이 없다면 중단을 알리고 클라이언트가 새 요청을 시작합니다. 출력 전 재시도도 전체 기한 내 제한합니다. 연결 해제 시 작업과 KV를 해제합니다. ID만으로 멱등성이 생기지 않습니다.

채점: 1 구성요소 명명, 2 상태 설명, 3 장애 추적, 4 올바른 복구와 한계, 5 공정한 반례와 절충 근거.

전체 구현 파일 (코드 주석은 영어)

mechanism_math.py

mechanism_math.py

"""Deterministic checks for the article's synthetic arithmetic. Standard library only.
No cluster, model benchmark, GPU, network or stochastic experiment.
"""
import math
p0=0.5
loss0=-math.log(p0)
loss1=math.log(math.exp(-0.05)+math.exp(0.05))-0.05
assert abs(loss0-0.69314718056)<1e-10
assert abs(loss1-0.64439666007)<1e-10 and loss1<loss0
# First AdamW moment correction with a scalar gradient.
g=0.5;beta1=0.9;beta2=0.999
m=(1-beta1)*g;v=(1-beta2)*g*g
assert math.isclose(m/(1-beta1),g)
assert math.isclose(v/(1-beta2),g*g)
assert 4*128*512*4==1024**2
assert 2*(4-1)*8/4/25==0.48
slots=16*sum(math.ceil(t/16) for t in [17,31])
assert slots==64 and slots-17-31==16
assert 2*32*8*128*2*8192==1024**3
assert sum([20,10,80,150,10])==270
assert 1/(10-8)==0.5 and 1/(10-9.5)==2
print('PASS: gradient step, AdamW bias correction, logits bytes, ring budget, KV blocks, TTFT and queue arithmetic')
pipeline.py

pipeline.py

"""Transparent language-model lifecycle. Python 3.11 + numpy 2.3.5.
The model is a learned bigram softmax, not a Transformer or general assistant.
"""
import argparse, hashlib, json, os, tempfile
from pathlib import Path
import numpy as np

def digest(b): return hashlib.sha256(b).hexdigest()
def atomic(path, data):
    path=Path(path); path.parent.mkdir(parents=True,exist_ok=True)
    fd,tmp=tempfile.mkstemp(dir=path.parent)
    with os.fdopen(fd,'wb') as f: f.write(data); f.flush(); os.fsync(f.fileno())
    os.replace(tmp,path)
def prepare(source,out):
    records=[json.loads(x) for x in Path(source).read_text().splitlines() if x.strip()]
    seen=set(); groups={'train':[],'validation':[]}
    for r in records:
        if r.get('license')!='CC0' or not isinstance(r.get('text'),str): raise ValueError('unsupported rights/schema')
        text=' '.join(r['text'].split())
        if not text: raise ValueError('empty text')
        h=digest(text.encode())
        if h in seen: continue
        seen.add(h)
        # Split before windows; one source record never crosses splits.
        groups['validation' if int(h[:8],16)%5==0 else 'train'].append({'id':r['id'],'text':text,'sha256':h})
    if not all(groups.values()): raise ValueError('both splits required')
    payload=json.dumps(groups,sort_keys=True).encode()
    atomic(Path(out)/'dataset.json',payload)
    atomic(Path(out)/'data-manifest.json',json.dumps({'sha256':digest(payload),'source_sha256':digest(Path(source).read_bytes()),'split':'content-hash modulo 5','counts':{k:len(v) for k,v in groups.items()}},indent=2).encode())
    return groups

def pairs(records,vocab):
    lookup={c:i+2 for i,c in enumerate(vocab)}; xs=[];ys=[]
    for r in records:
        ids=[0]+[lookup[c] for c in r['text']]+[1]
        xs.extend(ids[:-1]);ys.extend(ids[1:])
    return np.array(xs),np.array(ys)
def loss(w,x,y):
    z=w[x]; z=z-z.max(axis=1,keepdims=True)
    return float(np.mean(np.log(np.exp(z).sum(axis=1))-z[np.arange(len(x)),y]))
def train(root,steps=400,resume=False):
    root=Path(root); raw=(root/'dataset.json').read_bytes();ds=json.loads(raw)
    # Vocabulary belongs to training data. Fixture is ASCII; production needs UNK policy.
    vocab=sorted(set(''.join(r['text'] for r in ds['train'])))
    if any(c not in vocab for r in ds['validation'] for c in r['text']): raise ValueError('validation has unknown characters')
    x,y=pairs(ds['train'],vocab); vx,vy=pairs(ds['validation'],vocab)
    rng=np.random.default_rng(42);w=np.zeros((len(vocab)+2,)*2);start=0
    cp=root/'checkpoint.npz'
    if resume and cp.exists():
        with np.load(cp,allow_pickle=False) as c:
            if str(c['data_hash'])!=digest(raw): raise ValueError('dataset changed during resume')
            w=c['weights'];start=int(c['step']);rng.bit_generator.state=json.loads(str(c['rng']))
    initial=loss(w,x,y)
    for step in range(start,steps):
        ix=rng.integers(0,len(x),size=128); xx=x[ix];yy=y[ix]
        z=w[xx];z-=z.max(axis=1,keepdims=True);p=np.exp(z);p/=p.sum(axis=1,keepdims=True)
        p[np.arange(len(xx)),yy]-=1;g=np.zeros_like(w);np.add.at(g,xx,p/len(xx));w-=3*g
        if (step+1)%50==0 or step+1==steps:
            import io
            buf=io.BytesIO();np.savez(buf,weights=w,step=step+1,rng=json.dumps(rng.bit_generator.state),data_hash=digest(raw));atomic(cp,buf.getvalue())
    model={'architecture':'bigram-softmax-v1','vocab':vocab,'weights':w.tolist(),'data_sha256':digest(raw),'steps':steps,'seed':42}
    modelraw=json.dumps(model,separators=(',',':')).encode();atomic(root/'model.json',modelraw)
    metrics={'initial_train_nll':initial,'train_nll':loss(w,x,y),'validation_nll':loss(w,vx,vy),'model_sha256':digest(modelraw),'steps':steps}
    atomic(root/'metrics.json',json.dumps(metrics,indent=2).encode());print(json.dumps(metrics));return metrics

def promote(root):
    root=Path(root);m=json.loads((root/'metrics.json').read_text()); raw=(root/'model.json').read_bytes()
    if digest(raw)!=m['model_sha256'] or not np.isfinite(m['validation_nll']) or m['validation_nll']>=4: raise ValueError('release gate failed')
    # This threshold only validates the declared teaching fixture, not language quality.
    atomic(root/'release.json',json.dumps({'model_sha256':digest(raw),'data_sha256':digest((root/'dataset.json').read_bytes()),'artifact':'model.json','gate':'fixture validation NLL < 4; not a safety evaluation'},indent=2).encode())

if __name__=='__main__':
    p=argparse.ArgumentParser();p.add_argument('action',choices=['prepare','train','promote']);p.add_argument('--root',default='/work');p.add_argument('--source',default='corpus.jsonl');p.add_argument('--steps',type=int,default=400);p.add_argument('--resume',action='store_true');a=p.parse_args()
    if a.action=='prepare': prepare(a.source,a.root)
    elif a.action=='train': train(a.root,a.steps,a.resume)
    else: promote(a.root)
serve.py

serve.py

"""Local/private teaching API; no public ingress, TLS or identity provider."""
import argparse, hashlib, json, threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
import numpy as np

def load(root):
    root=Path(root);release=json.loads((root/'release.json').read_text());raw=(root/'model.json').read_bytes()
    if hashlib.sha256(raw).hexdigest()!=release['model_sha256']: raise ValueError('artifact integrity mismatch')
    return json.loads(raw),release['model_sha256']
def application(model,revision):
    w=np.array(model['weights']);vocab=model['vocab'];lookup={c:i+2 for i,c in enumerate(vocab)};slots=threading.BoundedSemaphore(2)
    class Handler(BaseHTTPRequestHandler):
        def log_message(self,*args): pass # No prompts in request logs.
        def respond(self,status,obj):
            raw=json.dumps(obj).encode();self.send_response(status);self.send_header('Content-Type','application/json');self.send_header('Content-Length',str(len(raw)));self.end_headers();self.wfile.write(raw)
        def do_GET(self):
            self.respond(200 if self.path=='/health' else 404,{'model_revision':revision})
        def do_POST(self):
            if self.path!='/v1/completions': return self.respond(404,{'error':'not found'})
            self.connection.settimeout(10)
            try:
                size=int(self.headers.get('Content-Length','0'))
                if not 0<size<=8192: return self.respond(413,{'error':'body limit'})
                body=json.loads(self.rfile.read(size))
                if not isinstance(body,dict): raise ValueError('object required')
                prompt=body.get('prompt','');limit=body.get('max_tokens',32)
                if not isinstance(prompt,str) or len(prompt)>512 or type(limit)!=int or not 1<=limit<=128: raise ValueError('invalid prompt or token limit')
                if any(c not in lookup for c in prompt): raise ValueError('unknown character')
                if type(body.get('stream',False))!=bool: raise ValueError('stream must be boolean')
            except (ValueError,TypeError,TimeoutError): return self.respond(400,{'error':'invalid request'})
            if not slots.acquire(blocking=False): return self.respond(429,{'error':'capacity'})
            try:
                token=lookup[prompt[-1]] if prompt else 0;rng=np.random.default_rng(42);out=[]
                if body.get('stream'):
                    self.send_response(200);self.send_header('Content-Type','text/event-stream');self.send_header('Cache-Control','no-cache');self.send_header('Connection','close');self.end_headers();self.close_connection=True
                for _ in range(limit):
                    z=w[token].copy();z[0]=-np.inf;p=np.exp(z-np.max(z));p/=p.sum();token=int(rng.choice(len(p),p=p))
                    if token==1: break
                    out.append(vocab[token-2])
                    if body.get('stream'):
                        self.wfile.write(('data: '+json.dumps({'token':out[-1],'model_revision':revision})+'\n\n').encode());self.wfile.flush()
                if body.get('stream'): self.wfile.write(b'data: [DONE]\n\n');self.wfile.flush()
                else: self.respond(200,{'text':''.join(out),'completion_tokens':len(out),'model_revision':revision})
            except (BrokenPipeError,ConnectionResetError,TimeoutError): pass
            finally: slots.release()
    return Handler
if __name__=='__main__':
    p=argparse.ArgumentParser();p.add_argument('--root',default='/work');p.add_argument('--host',default='127.0.0.1');p.add_argument('--port',type=int,default=8000);a=p.parse_args()
    model,rev=load(a.root);ThreadingHTTPServer((a.host,a.port),application(model,rev)).serve_forever()
transformer.py

transformer.py

"""Optional real GPT-2 architecture training path; not run by Token Lab.
Python 3.11, torch 2.6.0, transformers 4.51.3, tokenizers 0.21.1.
Reads the SAME prepared dataset.json; trains its own byte BPE tokenizer.
A tiny random model demonstrates mechanics, not useful assistant capability.
"""
import argparse,json,os,random
from pathlib import Path
import torch
from tokenizers import ByteLevelBPETokenizer
from transformers import GPT2Config,GPT2LMHeadModel,PreTrainedTokenizerFast
p=argparse.ArgumentParser();p.add_argument('--root',default='/work');p.add_argument('--steps',type=int,default=200);p.add_argument('--resume',action='store_true');a=p.parse_args()
root=Path(a.root);ds=json.loads((root/'dataset.json').read_text());torch.manual_seed(42);random.seed(42)
# CPU default for broad compatibility; set DEVICE=cuda for a provisioned GPU.
device=os.environ.get('DEVICE','cpu');tokenizer=ByteLevelBPETokenizer()
tokenizer.train_from_iterator((r['text'] for r in ds['train']),vocab_size=512,min_frequency=2,special_tokens=['<bos>','<eos>','<pad>'])
tok=PreTrainedTokenizerFast(tokenizer_object=tokenizer._tokenizer,bos_token='<bos>',eos_token='<eos>',pad_token='<pad>')
config=GPT2Config(vocab_size=len(tok),n_positions=128,n_ctx=128,n_embd=128,n_layer=2,n_head=4,bos_token_id=tok.bos_token_id,eos_token_id=tok.eos_token_id,pad_token_id=tok.pad_token_id)
model=GPT2LMHeadModel(config).to(device);optimizer=torch.optim.AdamW(model.parameters(),lr=3e-4)
rows=[tok(r['text'],max_length=126,truncation=True)['input_ids']+[tok.eos_token_id] for r in ds['train']]
import hashlib
fingerprint=hashlib.sha256((root/'dataset.json').read_bytes()).hexdigest();cp=root/'transformer-checkpoint.pt';start=0
if a.resume and cp.exists():
    state=torch.load(cp,map_location='cpu',weights_only=True)
    if state['data_hash']!=fingerprint: raise ValueError('dataset mismatch')
    model.load_state_dict(state['model']);optimizer.load_state_dict(state['optimizer']);start=state['step'];torch.set_rng_state(state['cpu_rng']);random.setstate(state['python_rng'])
    if device.startswith('cuda'): torch.cuda.set_rng_state_all(state['cuda_rng'])
model.train()
for step in range(start,a.steps):
    chosen=random.choices(rows,k=4);width=max(map(len,chosen));ids=torch.full((4,width),tok.pad_token_id,dtype=torch.long,device=device);mask=torch.zeros_like(ids)
    for i,row in enumerate(chosen): ids[i,:len(row)]=torch.tensor(row,device=device);mask[i,:len(row)]=1
    labels=ids.clone();labels[mask==0]=-100
    optimizer.zero_grad(set_to_none=True);loss=model(input_ids=ids,attention_mask=mask,labels=labels).loss
    loss.backward();torch.nn.utils.clip_grad_norm_(model.parameters(),1);optimizer.step()
    if (step+1)%50==0 or step+1==a.steps:
        state={'model':model.state_dict(),'optimizer':optimizer.state_dict(),'step':step+1,'cpu_rng':torch.get_rng_state(),'python_rng':random.getstate(),'cuda_rng':torch.cuda.get_rng_state_all() if device.startswith('cuda') else [],'data_hash':fingerprint}
        tmp=root/'checkpoint.tmp';torch.save(state,tmp);os.replace(tmp,cp)
        print(json.dumps({'step':step+1,'training_loss':float(loss.detach())}))
export=root/'transformer-candidate';export.mkdir(exist_ok=True)
model.save_pretrained(export,safe_serialization=True);tok.save_pretrained(export)
# Candidate only: no release pointer is changed. Evaluate before promotion.
(export/'lineage.json').write_text(json.dumps({'data_sha256':fingerprint,'seed':42,'steps':a.steps,'status':'candidate-not-approved'}))
approve_transformer.py

approve_transformer.py

"""Held-out next-token NLL gate for this synthetic fixture only. Not a safety gate.
Unexecuted optional Transformer path. Uses CPU; no paid APIs or uploaded data.
"""
import argparse,hashlib,json,math,os,shutil
from pathlib import Path
import torch
from transformers import AutoTokenizer, GPT2LMHeadModel
p=argparse.ArgumentParser();p.add_argument('--root',default='/work');p.add_argument('--max-nll',type=float,required=True);a=p.parse_args()
r=Path(a.root);src=r/'transformer-candidate';dst=r/'approved'
if dst.exists(): raise ValueError('use a fresh release directory; never overwrite a served artifact')
data=json.loads((r/'dataset.json').read_text());lineage=json.loads((src/'lineage.json').read_text())
assert lineage['data_sha256']==hashlib.sha256((r/'dataset.json').read_bytes()).hexdigest()
tok=AutoTokenizer.from_pretrained(src,local_files_only=True);model=GPT2LMHeadModel.from_pretrained(src,local_files_only=True).eval()
total=0.;n=0
with torch.no_grad():
    for row in data['validation']:
        ids=tok(row['text'],max_length=126,truncation=True)['input_ids']+[tok.eos_token_id]
        x=torch.tensor([ids]);loss=model(input_ids=x,labels=x).loss.item()
        total+=loss*(len(ids)-1);n+=len(ids)-1
nll=total/n
print(json.dumps({'validation_nll':nll,'tokens':n,'threshold':a.max_nll}))
if not math.isfinite(nll) or nll>=a.max_nll: raise ValueError('candidate rejected; approved version unchanged')
files={f.name:hashlib.sha256(f.read_bytes()).hexdigest() for f in src.iterdir() if f.is_file()}
staging=r/'approval-staging'
if staging.exists(): shutil.rmtree(staging)
shutil.copytree(src,staging)
(staging/'release-manifest.json').write_text(json.dumps({'files':files,'validation_nll':nll,'gate':'synthetic fixture only','data_sha256':lineage['data_sha256']},indent=2))
os.replace(staging,dst) # Atomic directory rename on this one filesystem, not object-store transaction.
verify.py

verify.py

"""Actual local training/resume/integrity/API checks; no cluster required."""
import importlib.util,json,tempfile,threading,urllib.request,urllib.error
from pathlib import Path
from http.server import ThreadingHTTPServer
import numpy as np
from pipeline import prepare,train,promote
from serve import load,application
here=Path(__file__).parent
with tempfile.TemporaryDirectory() as t:
    a=Path(t)/'a';b=Path(t)/'b'
    for root in (a,b):prepare(here/'corpus.jsonl',root)
    metrics=train(a);train(b,200);train(b,400,True)
    assert (a/'model.json').read_bytes()==(b/'model.json').read_bytes(),'resume differs'
    assert metrics['train_nll']<metrics['initial_train_nll'];promote(a)
    model,revision=load(a);server=ThreadingHTTPServer(('127.0.0.1',0),application(model,revision))
    thread=threading.Thread(target=server.serve_forever,daemon=True);thread.start()
    url=f'http://127.0.0.1:{server.server_port}'
    def post(body):
        request=urllib.request.Request(url+'/v1/completions',data=json.dumps(body).encode(),headers={'Content-Type':'application/json'})
        return urllib.request.urlopen(request,timeout=5).read()
    assert json.loads(urllib.request.urlopen(url+'/health').read())['model_revision']==revision
    result=json.loads(post({'prompt':'Data ','max_tokens':16}));assert result['completion_tokens']<=16 and result['model_revision']==revision
    stream=post({'prompt':'Data ','max_tokens':16,'stream':True});assert stream.endswith(b'data: [DONE]\n\n')
    try:post({'prompt':'Data ','max_tokens':0});raise AssertionError('invalid request accepted')
    except urllib.error.HTTPError as e:assert e.code==400
    server.shutdown();server.server_close()
    (a/'model.json').write_text('{}')
    try:load(a);raise AssertionError('tamper accepted')
    except ValueError:pass
print('PASS: loss descent, exact resume, artifact integrity, HTTP generation, SSE, invalid input')
kubernetes.yaml

kubernetes.yaml

apiVersion: v1
kind: Namespace
metadata:
  name: tokenlab-ai
  labels:
    pod-security.kubernetes.io/enforce: restricted
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata: {name: artifacts, namespace: tokenlab-ai}
spec:
  accessModes: [ReadWriteOnce]
  resources:
    requests: {storage: 1Gi}
---
apiVersion: batch/v1
kind: Job
metadata: {name: train-v1, namespace: tokenlab-ai}
spec:
  backoffLimit: 1
  activeDeadlineSeconds: 600
  template:
    metadata:
      labels: {app: trainer}
    spec:
      restartPolicy: Never
      automountServiceAccountToken: false
      securityContext: {runAsNonRoot: true, runAsUser: 10001, runAsGroup: 10001, fsGroup: 10001, seccompProfile: {type: RuntimeDefault}}
      containers:
      - name: train
        image: tokenlab-ai:local
        imagePullPolicy: IfNotPresent
        command: [sh, -ec]
        args:
        - python pipeline.py prepare --source corpus.jsonl --root /work && python pipeline.py train --root /work --resume && python pipeline.py promote --root /work
        resources:
          requests: {cpu: '1', memory: 256Mi}
          limits: {cpu: '2', memory: 512Mi}
        securityContext: {allowPrivilegeEscalation: false, readOnlyRootFilesystem: true, capabilities: {drop: [ALL]}}
        volumeMounts:
        - {name: artifacts, mountPath: /work}
      volumes:
      - name: artifacts
        persistentVolumeClaim: {claimName: artifacts}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: model-v1, namespace: tokenlab-ai}
spec:
  replicas: 1
  strategy: {type: Recreate}
  selector:
    matchLabels: {app: model-v1}
  template:
    metadata:
      labels: {app: model-v1}
    spec:
      automountServiceAccountToken: false
      securityContext: {runAsNonRoot: true, runAsUser: 10001, runAsGroup: 10001, fsGroup: 10001, seccompProfile: {type: RuntimeDefault}}
      containers:
      - name: server
        image: tokenlab-ai:local
        imagePullPolicy: IfNotPresent
        resources:
          requests: {cpu: '250m', memory: 128Mi}
          limits: {cpu: '1', memory: 256Mi}
        ports: [{containerPort: 8000}]
        startupProbe:
          httpGet: {path: /health, port: 8000}
          failureThreshold: 30
          periodSeconds: 2
        readinessProbe:
          httpGet: {path: /health, port: 8000}
          periodSeconds: 5
        livenessProbe:
          httpGet: {path: /health, port: 8000}
          periodSeconds: 15
        securityContext: {allowPrivilegeEscalation: false, readOnlyRootFilesystem: true, capabilities: {drop: [ALL]}}
        volumeMounts:
        - {name: artifacts, mountPath: /work, readOnly: true}
      volumes:
      - name: artifacts
        persistentVolumeClaim: {claimName: artifacts}
---
apiVersion: v1
kind: Service
metadata: {name: model-api, namespace: tokenlab-ai}
spec:
  selector: {app: model-v1}
  ports: [{port: 8000, targetPort: 8000}]
  type: ClusterIP
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: {name: private-model, namespace: tokenlab-ai}
spec:
  podSelector: {}
  policyTypes: [Ingress, Egress]
  ingress:
  - from:
    - podSelector:
        matchLabels: {role: authorized-client}
    ports: [{protocol: TCP, port: 8000}]
  egress: []
transformer-job.yaml

transformer-job.yaml

# Optional, not executed here. First create namespace/PVC from kubernetes.yaml.
apiVersion: batch/v1
kind: Job
metadata:
  name: transformer-train
  namespace: tokenlab-ai
spec:
  backoffLimit: 1
  activeDeadlineSeconds: 7200
  template:
    metadata:
      labels:
        app: trainer
    spec:
      restartPolicy: Never
      automountServiceAccountToken: false
      securityContext:
        runAsNonRoot: true
        runAsUser: 10001
        runAsGroup: 10001
        fsGroup: 10001
        seccompProfile:
          type: RuntimeDefault
      containers:
      - name: train
        image: tokenlab-transformer:lab
        imagePullPolicy: IfNotPresent
        command:
        - sh
        - -c
        args:
        - python pipeline.py prepare --source corpus.jsonl --root /work && python transformer.py
          --root /work --steps 200 --resume && python approve_transformer.py --root
          /work --max-nll 4.0
        resources:
          requests:
            cpu: '2'
            memory: 2Gi
          limits:
            cpu: '4'
            memory: 4Gi
        securityContext:
          allowPrivilegeEscalation: false
          readOnlyRootFilesystem: true
          capabilities:
            drop:
            - ALL
        volumeMounts:
        - name: artifacts
          mountPath: /work
      volumes:
      - name: artifacts
        persistentVolumeClaim:
          claimName: artifacts
gpu-serving.yaml

gpu-serving.yaml

# Optional unexecuted serving reference. Populate /models/approved first.
# Replace the image tag with a verified digest in your registry before production.
apiVersion: apps/v1
kind: Deployment
metadata: {name: transformer-v1, namespace: tokenlab-ai}
spec:
  replicas: 1
  strategy: {type: Recreate}
  selector:
    matchLabels: {app: transformer-v1}
  template:
    metadata:
      labels: {app: transformer-v1}
    spec:
      automountServiceAccountToken: false
      containers:
      - name: vllm
        image: vllm/vllm-openai:v0.14.0
        args: [--model, /models/approved, --served-model-name, tokenlab-transformer, --max-model-len, '128', --dtype, float32, --gpu-memory-utilization, '0.5', --max-num-seqs, '8']
        resources:
          requests: {cpu: '2', memory: 4Gi}
          limits: {cpu: '4', memory: 8Gi, nvidia.com/gpu: '1'}
        ports: [{containerPort: 8000}]
        startupProbe:
          httpGet: {path: /health, port: 8000}
          failureThreshold: 180
          periodSeconds: 10
        readinessProbe:
          httpGet: {path: /health, port: 8000}
        volumeMounts:
        - {name: models, mountPath: /models, readOnly: true}
        - {name: shm, mountPath: /dev/shm}
      volumes:
      - name: models
        persistentVolumeClaim: {claimName: artifacts}
      - name: shm
        emptyDir: {medium: Memory, sizeLimit: 1Gi}
# Integrate into a separately hardened GPU namespace: the public image's UID,
# writable cache locations, device access and driver/CUDA matrix must be checked.
# Do not apply blindly to the restricted CPU namespace above. See README.

---
apiVersion: v1
kind: Service
metadata: {name: transformer-api, namespace: tokenlab-ai}
spec:
  selector: {app: transformer-v1}
  ports: [{port: 8000, targetPort: 8000}]
Dockerfile

Dockerfile

FROM python:3.11.14-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY pipeline.py serve.py corpus.jsonl ./
USER 10001:10001
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1
CMD ["python", "serve.py", "--host", "0.0.0.0"]
Dockerfile.transformer

Dockerfile.transformer

FROM python:3.11.14-slim
WORKDIR /app
COPY requirements-transformer.txt .
RUN pip install --no-cache-dir -r requirements-transformer.txt
COPY pipeline.py transformer.py approve_transformer.py corpus.jsonl ./
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 TOKENIZERS_PARALLELISM=false
USER 10001:10001
CMD ["python", "transformer.py", "--root", "/work"]
선수 지식을 이해하기

방법을 뒷받침하는 공통 기초를 복습하고 예제와 확인 문제로 이해의 빈틈을 찾습니다.

자기회귀 디코딩은 앞선 토큰을 조건으로 다음 토큰을 생성합니다. 인과 Transformer에서는 모델과 접두사가 같으면 과거 키와 값을 재사용할 수 있습니다. KV 캐시는 답변이 아니라 내부 텐서입니다. 층·배치·위치·KV 헤드·차원·숫자당 바이트를 세어야 합니다.

답을 보기 전에 추론하기

2개 층, 배치 1, 토큰 4개, KV 헤드 2개, 차원 3, 숫자당 2바이트라면 K와 V는 몇 바이트인가요?

단계별 해설

2×2×1×4×2×3×2=192바이트입니다. 첫 2는 K와 V를 뜻합니다. 가중치·임시 버퍼·할당 오버헤드·패딩은 제외합니다. 문맥을 두 배로 늘려도 GPU 전체 메모리가 두 배가 되는 것은 아닙니다.

실제 응용과의 연결

GQA는 쿼리보다 KV 헤드를 적게 둡니다. 이는 구조 선택이지 임의 캐시 삭제가 아닙니다. 접두사 재사용에는 토큰·위치·모델·관련 설정의 일치가 필요합니다.

이해를 입증하는 방법

캐시 유무 출력을 허용 오차 내에서 비교하고 접두사가 바뀌면 무효화되는지 확인하세요. 실제 텐서와 할당 메모리, prefill과 decode를 구분하세요. 용량 계산기는 하드웨어 성능 벤치마크가 아닙니다.

완전한 Python 예제 실행

Python 3.10+ · 표준 라이브러리만 · 결정적 계산으로 시드 불필요 · 통신 없음. 저장 후 아래 명령을 실행하세요. 교육용 확인이며 모델 벤치마크가 아닙니다.

Python 다운로드 · kv.py
python3 kv.py
# Python 3.10+; standard library; deterministic; no network.
def kv_bytes(layers, batch, tokens, kv_heads, head_dim, bytes_per_value):
    dimensions = [layers, batch, tokens, kv_heads, head_dim, bytes_per_value]
    if any(not isinstance(x, int) or x < 0 for x in dimensions):
        raise ValueError("nonnegative integer dimensions required")
    size = 2  # K and V
    for dimension in dimensions:
        size *= dimension
    return size

assert kv_bytes(2, 1, 4, 2, 3, 2) == 192
assert kv_bytes(2, 1, 8, 2, 3, 2) == 384
assert kv_bytes(2, 1, 0, 2, 3, 2) == 0
print("KV payload=192 bytes; doubled context=384 bytes")

예상 출력

KV payload=192 bytes; doubled context=384 bytes

선수 지식 복습 →

기초 해설 수정:

다음 학습 단계

논문 버전을 고정하고 작은 메커니즘과 음성 대조를 재현해 한계를 설명하세요.

구현과 검증 → · 학습 경로 계속 →

예측, 검증, 근거 기록

답을 보기 전에 결과를 예측하세요. 연습 후 차이와 전이 테스트를 기록합니다. 로컬에 저장되며 언어판 간 공유됩니다.

학습 기록 열기 / 내보내기 / 지우기 →

수학 검토 범위는 강의별로 기록합니다. 논문의 실증 재현 인증은 아닙니다. 의심되는 오류를 노트에 남겨 주세요. 검토 범위