0. 먼저 큰 그림

Transformer attention의 기본 수식은 거의 같습니다.

PyTorch의 scaled_dot_product_attention도 바로 이 계산을 수행한다고 설명합니다. 차이는 이 수식을 그대로 순진하게 계산하느냐, 아니면 GPU 메모리 접근과 커널 융합을 최적화해서 더 빠르고 메모리 효율적으로 계산하느냐입니다. (PyTorch Documentation)

1. eager

정의

Hugging Face 문서 기준으로 "eager"는 manual implementation of the attention, 즉 일반적인 수동 구현 attention입니다. (Hugging Face)

어떤 알고리즘인가?

가장 전통적인 방식입니다.

대략 흐름은:

1. (QK^T) 계산
2. scaling
3. mask 더하기
4. softmax
5. (V)와 곱하기

즉, attention 행렬을 비교적 “정직하게” 계산하는 방식이라고 보면 됩니다. PyTorch 블로그에서 말하는 SDPA의 fallback인 math implementation과 비슷한 성격의, 가장 일반적이고 하드웨어 중립적인 방식으로 이해하면 됩니다. (PyTorch)

특징

• 호환성 최고
• 디버깅이 쉬움
• 보통 가장 느림
• 메모리도 더 많이 먹는 편

언제 쓰나?

• FlashAttention 설치가 안 될 때
• 모델/환경 호환성이 애매할 때
• “일단 돌아가기만 하면 된다”가 중요할 때

한 줄 느낌

가장 기본형 / 가장 안전 / 보통 가장 느림

2. sdpa

정의

Hugging Face 문서에서는 "sdpa"를 PyTorch built-in implementation of scaled dot product attention이라고 설명합니다. 즉 torch.nn.functional.scaled_dot_product_attention을 사용하는 방식입니다. (Hugging Face)

어떤 알고리즘인가?

이름 그대로 Scaled Dot-Product Attention입니다. 중요한 점은, sdpa가 단일 구현 하나를 뜻하는 게 아니라, PyTorch가 내부에서 가장 적절한 backend를 고르는 인터페이스라는 점입니다.

PyTorch는 SDPA 내부에서 세 가지 계열 backend를 사용할 수 있다고 설명합니다.

• Flash Attention
• Memory-Efficient Attention
• Math implementation fallback (PyTorch)

즉 sdpa는 “이 attention을 계산해줘”라는 상위 인터페이스이고, 실제 아래에서는 상황에 따라 최적화된 구현을 탈 수 있습니다. PyTorch 문서도 “automatically select the most optimal implementation”이라고 설명합니다. (PyTorch Documentation)

특징

• 별도 flash-attn 패키지 없이도 되는 경우가 많음
• 보통 eager보다 빠름
• PyTorch가 내부 최적 backend를 골라줌
• 실무적으로 가장 무난

언제 쓰나?

• 대부분의 일반적인 추론/학습
• 설치 스트레스 없이 성능도 어느 정도 챙기고 싶을 때
• 네 상황처럼 flash_attention_2가 안 될 때

한 줄 느낌

가장 밸런스 좋음 / 기본 추천

3. flash_attention_2

정의

Hugging Face 문서 기준으로 "flash_attention_2"는 Dao-AILab/flash-attention 구현을 사용합니다. 그리고 설명상 작은 타일(block) 단위로 계산을 나눠 fast on-chip memory를 활용합니다. (Hugging Face)

어떤 알고리즘인가?

핵심 아이디어는 attention 행렬 전체를 크게 메모리에 만들지 않고, tile 단위로 잘게 쪼개서 SRAM/shared memory 같은 빠른 on-chip memory를 최대한 활용하는 것입니다. 그래서 HBM/global memory 왕복을 줄여 속도와 메모리 효율을 크게 높입니다. (Hugging Face)

쉽게 말하면:

• 일반 방식: 큰 attention matrix를 상대적으로 많이 드나듦
• FlashAttention-2: 메모리 traffic을 줄이도록 재구성된 fused kernel

특징

• 보통 매우 빠름
• 메모리 효율 좋음
• 긴 시퀀스에서 특히 강점
• 하지만 설치/빌드 난이도가 있음
• GPU 제약이 있음

FlashAttention-2 CUDA 지원은 현재 Ampere, Ada, Hopper GPU 중심이며 예시로 A100, RTX 3090, RTX 4090, H100을 듭니다. dtype도 fp16/bf16 중심입니다. (GitHub)

언제 쓰나?

• GPU가 Ampere 이상이고
• Linux/CUDA 환경이 맞고
• 최대 성능이 중요할 때

한 줄 느낌

빠르지만 설치와 호환성 조건이 까다로운 고성능 옵션

4. flash_attention_3

정의

Hugging Face 문서에서는 "flash_attention_3"가 FlashAttention-2를 개선한 버전이며, 연산 overlap과 더 강한 fusion을 통해 성능을 높인다고 설명합니다. 그리고 Transformers에서는 Dao-AILab의 flash-attention/hopper 구현을 가리킵니다. (Hugging Face)

어떤 알고리즘인가?

기본 철학은 FlashAttention-2와 같습니다. 즉:

• attention을 메모리 효율적으로 tile/block 단위 계산
• GPU의 on-chip memory 적극 활용
• kernel fusion 극대화

여기에 FlashAttention-3는 특히 Hopper 세대 GPU에서 더 잘 맞도록 설계된 최적화가 들어간 형태로 이해하면 됩니다. Hugging Face 문서도 FlashAttention-2 대비 overlap/fusion 개선을 명시합니다. (Hugging Face)

특징

• 이론상 4개 중 가장 공격적인 고성능 옵션
• 하지만 지원 환경이 가장 까다로움
• Hopper 계열 중심

관련 요구사항 자료에서는 Hopper GPUs, CUDA 12.3 이상, 그리고 CUDA 12.8 권장이라고 적혀 있습니다. (GitHub)

언제 쓰나?

• H100 같은 Hopper GPU가 있고
• 최신 CUDA 환경을 맞출 수 있고
• 최고 성능이 필요할 때

한 줄 느낌

Hopper 전용에 가까운 초고성능 옵션

5. 4개를 한 번에 비교

이 비교는 Hugging Face의 backend 설명, PyTorch의 SDPA 설명, FlashAttention 저장소의 요구사항을 바탕으로 정리한 것입니다. (Hugging Face)

6. “알고리즘이 다르다”는 말이 정확히는 무슨 뜻인가?

엄밀히 말하면 attention의 수학적 정의는 거의 같습니다. 차이는 주로 다음입니다.

eager

• 수학식을 비교적 직접 구현
• 중간 텐서를 더 명시적으로 생성하는 경향

sdpa

• 같은 attention 수식을 PyTorch의 통합 API로 계산
• 내부에서 더 좋은 구현을 선택 가능

flash_attention_2, flash_attention_3

• 같은 attention 결과를 목표로 하지만
• GPU 메모리 이동량을 줄이도록 계산 순서와 kernel 구조를 재설계
• 핵심은 속도/메모리 최적화

즉, 수학 문제는 비슷하고, 공학적 구현이 다르다 라고 보면 가장 정확합니다. (PyTorch Documentation)

7. 네 상황에서 뭘 고르면 되냐

네가 지금 flash-attn 설치에서 막혔으니까:

1순위

attn_implementation="sdpa"

이게 제일 좋습니다. Transformers도 torch>=2.1.1이면 기본적으로 SDPA를 우선 사용한다고 설명합니다. (Hugging Face)

2순위

attn_implementation="eager"

이건 속도는 손해 보더라도 제일 안전합니다. (Hugging Face)

3순위

flash_attention_2

• GPU, CUDA, torch, flash-attn 버전이 딱 맞을 때만

4순위

flash_attention_3

• 사실상 Hopper급 환경 아니면 보통 우선순위 낮음 (GitHub)

8. 아주 짧게 비유하면

• eager: 교과서 방식으로 직접 계산
• sdpa: PyTorch가 알아서 최적 구현 선택
• flash_attention_2: 고성능 GPU용 특수 최적화 엔진
• flash_attention_3: 더 최신 GPU(Hopper)용 초고성능 엔진

• sdpa = PyTorch가 제공하는 공식 어텐션 API/백엔드 경로
• flash_attention_2 = Dao-AILab의 외부 FlashAttention-2 커스텀 구현을 직접 쓰는 방식

입니다. Transformers 문서도 attn_implementation으로 "sdpa"는 F.scaled_dot_product_attention를, "flash_attention_2"는 Dao-AILab flash-attention 패키지를 쓴다고 설명합니다. 그리고 torch>=2.1.1에서는 기본적으로 SDPA가 사용될 수 있다고 적혀 있어요. (Hugging Face)

조금 더 풀어서 말하면:

sdpa는 PyTorch 안에 있는 표준 창구예요. 코드에서는 그냥 scaled_dot_product_attention를 호출하고, 내부적으로 PyTorch가 상황에 따라 어떤 커널을 쓸지 선택할 수 있습니다. PyTorch 문서에도 SDPA는 여러 backend를 가질 수 있고, sdpa_kernel로 backend를 고를 수 있다고 나옵니다. 가능한 backend enum에는 FLASH_ATTENTION, EFFICIENT_ATTENTION, MATH, CUDNN_ATTENTION 등이 있습니다. 즉 sdpa는 하나의 단일 알고리즘 이름이라기보다, PyTorch의 통합 인터페이스에 가깝습니다. (PyTorch Documentation)

반면 flash_attention_2는 외부 패키지 flash_attn이 반드시 설치되어 있어야 하는 직접 지정 방식입니다. Transformers가 이 옵션을 받으면 Dao-AILab 구현을 쓰려 하고, 네 로그처럼 패키지가 없으면 바로 ImportError가 납니다. Hugging Face 문서도 FlashAttention-2 사용 시 관련 패키지 설치가 필요하고, fp16 또는 bf16 dtype에서 사용해야 한다고 안내합니다. (Hugging Face)

차이를 한 줄로 정리하면:

• sdpa: 설치가 더 쉽고, PyTorch 기본 경로라서 가장 무난
• flash_attention_2: 잘 맞으면 더 빠르거나 메모리 효율이 좋을 수 있지만, 설치/호환 조건이 더 까다로움 (PyTorch Documentation)

네 상황에서는 왜 sdpa를 추천했냐면, 지금은 flash_attn 설치가 안 끝난 상태라서 flash_attention_2를 강제로 쓰면 모델이 아예 로드되지 않아요. 반대로 sdpa는 PyTorch 쪽 기능이라 추가 외부 패키지 없이 바로 돌아갈 가능성이 높습니다. 이건 네 현재 환경에서 가장 현실적인 우회 방법이에요. (Hugging Face)

체감 차이는 보통 이렇게 이해하면 됩니다.

• 속도/메모리 최적화 최우선 → flash_attention_2 시도
• 일단 안정적으로 실행 → sdpa

코드도 차이는 한 줄뿐이에요.

attn_implementation="sdpa"

또는

attn_implementation="flash_attention_2"

네가 원하면 다음 답변에서 “sdpa가 내부적으로 flash kernel을 쓰는 경우”까지 포함해서, eager / sdpa / flash_attention_2를 표처럼 딱 비교해줄게.

라는 의미

1. 어디에 쓰이냐

특히 이런 코드에서 영향이 있어:

from some_module import *

이때 __all__이 있으면 그 목록에 들어 있는 이름들만 import 돼.

예를 들면:

__all__ = ["SiglipProcessor"]

이면

from some_module import *

했을 때 SiglipProcessor만 들어오는 거야.

2. 왜 쓰냐

이유는 보통 3가지야.

(1) 이 파일의 공식 공개 API를 표시

이 파일 안에 변수, 함수, 클래스가 여러 개 있을 수 있는데 그중에서 “사용자가 써도 되는 공식 대상”을 정해주는 거야.

즉:

• 내부 구현용 이름은 숨기고
• 외부 사용자에게 보여줄 핵심만 지정

(2) import * 제어

와일드카드 import 시 뭐가 들어올지 통제하기 위해서.

(3) 문서화/가독성

이 파일의 핵심 public object가 뭔지 한눈에 보이게 해.

즉 이 파일에서는 “대표 클래스는 SiglipProcessor입니다” 라고 선언하는 느낌이야.

3. 지금 코드에서 왜 이게 있냐

네가 본 파일은 아마 processor 정의 파일이라서 핵심 공개 대상이 SiglipProcessor 하나인 거야.

예를 들어 파일 안에는 내부적으로:

• import된 것들
• helper
• decorator
• base class 관련 이름

이런 게 섞여 있을 수 있는데, 외부에서 이 파일을 사용할 때는 결국 SiglipProcessor가 핵심이잖아.

그래서:

__all__ = ["SiglipProcessor"]

라고 적어둔 거야.

4. 예시로 보면 쉬워

x = 10

class A:
    pass

class B:
    pass

__all__ = ["A"]

이 상태에서:

from mymodule import *

하면 A만 들어오고 x, B는 안 들어올 수 있어.

5. 중요한 점

이건 클래스를 만드는 코드가 아니고, 모듈이 외부에 어떤 이름을 공개할지 정하는 변수야.

즉:

• SiglipProcessor를 생성하는 코드도 아니고
• return도 아니고
• 실행 로직도 아님

그냥 모듈 수준의 설정이야.

6. 아주 짧게 정리

__all__ = ["SiglipProcessor"]

= “이 파일에서 공식적으로 export할 이름은 SiglipProcessor다”

import requests
from transformers import AutoProcessor, AutoModel
import torch

# model = AutoModel.from_pretrained("google/siglip-base-patch16-224")
# processor = AutoProcessor.from_pretrained("google/siglip-base-patch16-224")


from transformers import SiglipModel, SiglipProcessor

model = SiglipModel.from_pretrained("google/siglip-base-patch16-224")
processor = SiglipProcessor.from_pretrained("google/siglip-base-patch16-224")


url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)

candidate_labels = ["2 cats", "2 dogs"]
texts = [f'This is a photo of {label}.' for label in candidate_labels]
inputs = processor(text=texts, images=image, padding="max_length", return_tensors="pt")

with torch.no_grad():
    outputs = model(**inputs)

logits_per_image = outputs.logits_per_image
probs = torch.sigmoid(logits_per_image) # 시그모이드 활성화 함수를 적용한 확률입니다
print(f"{probs[0][0]:.1%} that image 0 is '{candidate_labels[0]}'")

• __init__ : 객체가 만들어질 때 처음 한 번 실행되는 초기화 함수
• __call__ : 이미 만들어진 객체를 함수처럼 호출할 때 실행되는 함수

즉 역할이 완전히 달라.

1. __init__

이건 객체를 만들 때 실행돼.

예시:

class Dog:
    def __init__(self, name):
        self.name = name
        print("init 실행")

d = Dog("Coco")

실행 흐름:

• Dog("Coco") 호출
• 객체 생성
• __init__(self, "Coco") 실행
• self.name = "Coco" 저장

여기서 __init__는 보통:

• 변수 저장
• 옵션 설정
• 초기 상태 만들기

를 담당해.

즉 “객체 세팅 담당” 이야.

2. __call__

이건 객체를 함수처럼 쓸 때 실행돼.

예시:

class Dog:
    def __init__(self, name):
        self.name = name

    def __call__(self):
        print(f"{self.name} is barking")

d = Dog("Coco")
d()

여기서:

• d = Dog("Coco") → __init__ 실행
• d() → __call__ 실행

즉 객체인데 함수처럼 부를 수 있게 해주는 메서드야.

3. 차이를 한 번에 보기

__init__

d = Dog("Coco")

이때 실행됨.

__call__

d()

이때 실행됨.

4. SigLIP 예시로 연결하면

예를 들어:

processor = SiglipProcessor(image_processor, tokenizer)

이때는 __init__가 실행돼.

무슨 뜻이냐면:

• image_processor 저장
• tokenizer 저장
• processor 객체 세팅

이걸 하는 거야.

반면:

inputs = processor(text=texts, images=image)

이건 processor(...)처럼 객체를 함수처럼 호출한 거니까 __call__이 실행되는 거야.

즉 여기서는:

• text를 tokenizer에 넣고
• image를 image_processor에 넣고
• 결과를 묶어서
• inputs를 반환

하는 식으로 동작해.

5. 비유

__init__

커피머신 설치

• 전원 연결
• 물 넣기
• 원두 넣기
• 설정 완료

__call__

커피 추출 버튼 누르기

• 아메리카노 만들기
• 결과 반환

즉:

• __init__ = 준비
• __call__ = 실행

6. 같이 있는 예제

class MyProcessor:
    def __init__(self, x):
        self.x = x
        print("init 실행")

    def __call__(self, y):
        print("call 실행")
        return self.x + y

p = MyProcessor(10)   # __init__
result = p(5)         # __call__

print(result)

실행 결과:

init 실행
call 실행
15

여기서:

• MyProcessor(10) → 객체 만들면서 __init__
• p(5) → 객체를 함수처럼 불러서 __call__

7. 정리

• __init__는 객체 생성 시 초기화
• __call__은 객체 호출 시 실행
• processor = SiglipProcessor(...) → __init__
• processor(...) → __call__

4) 언제 뭘 선택해?

정해진 자세/각도로 정확히 가서 멈추기: Position control 조이스틱/키보드로 부드럽게 움직이기, 베이스 주행(모바일 로봇), 연속 추종: Velocity control 접촉/힘 제어(삽입, 연마, 잡기): 보통 토크/임피던스(힘-위치 혼합) 쪽으로 확장

접지(grounding)란 인공 지능 시스템이 추상적 개념(일반적으로 자연어에서 파생됨)을 시각 데이터나 감각 입력과 같은 물리적 세계의 구체적 표현과 연결하는 능력을 의미한다.

컴퓨터 비전 분야에서 이는 모델이 단순히 텍스트를 처리하는 것이 아니라 "개를 산책시키는 사람"과 같은 구문을 분석하여 이미지나 영상 피드 내에서 해당 개체를 정확히 위치 파악할 수 있음을 뜻합니다.

V = 5V (전원 +)

G = GND (접지)

컴퓨터와 직접 연결하는 것이 아닌 보드를 통해서 연결한다.

리눅스에서 USB 시리얼 장치 권한을 임시로 풀어주는 명령어

''' sudo chmod 666 /dev/ttyACM0 sudo chmod 666 /dev/ttyACM1 '''

/dev/ttyACM0, /dev/ttyACM1 는 뭐야?

아두이노 서보 드라이버 보드 USB-시리얼 장치 마이크로컨트롤러(예: STM32, ESP 계열 일부) 로봇 컨트롤러를 USB로 연결했을 때 생기는 시리얼 통신 포트예요.

임시해결이여서 장치를 다시 뽑았다가 꽂으면 권한이 변경될 수 있음

MotorBus가 연결된 USB 포트가 어떤 것인지 자동으로 찾는절차

아래 사진과 같이 배선을 뽑고 모터 1개만 연결하고 앤터치고 하는 방식을 하는 이유?

각 모터의 ID를 개별적으로(안 꼬이게) 설정/확인

Calibrate를 진행하는 이유

모터가 같은 숫자 명령을 받아도, 실제 관절 각도는 서로 다를 수 있기 때문에 기준점을 맞추기 위함

공식 레포 follow 링크

• koch1.1 setting

• koch1.1 teleoperate

• cameras setting

• train.py github code

dot prodoct

vector norm

결과 :

값이 1에 가깝다면 유사하고, 0이라면 거의 무관한다.(직교함), -1이라면 반대방향이다.

로봇의 스팩을 보면서 반복정밀도 및 도발 범위의 정의가 궁금해서 정리겸 적어봄...

1) 반복 정밀도(Repeatability, 반복 위치정밀도)

• 뜻: 같은 목표 위치로 여러 번 이동했을 때, 그 위치에 “얼마나 비슷하게” 다시 도착하느냐

• 쉽게 말해: “매번 찍는 점이 얼마나 한곳에 모이냐”

• 보통 표기: ±0.02 mm 같은 형태

• 중요한 포인트:

  • “절대적으로 정확한 위치”가 아니라 ‘재현성’이 핵심
  • 예: 목표점이 실제로는 0.5mm 옆에 찍혀도, 매번 그 0.5mm 옆에 똑같이 찍히면 반복정밀도는 좋다

2) 도달 범위(Reach) / 작업 범위(Working Range, Envelope)

• 뜻: 로봇이 팔을 뻗어서 도달할 수 있는 최대 거리, 혹은 움직일 수 있는 공간(3D 영역)

• 쉽게 말해: “로봇이 어디까지 손이 닿나”

• 보통 표기:

  • Reach: 900 mm 같은 “거리”
  • Working envelope: “반경/높이/각도 제한” 포함한 가능 작업 공간

3) 차이점 한 줄 요약

• 반복 정밀도 = 같은 곳을 얼마나 똑같이 다시 찍나 (품질/정밀)
• 도달 범위 = 어디까지 갈 수 있나 (작업 가능 영역/크기)

4) 현장 감각 예시

• Reach 900mm: “작업대 끝까지 팔이 닿는다”
• Repeatability ±0.02mm: “그 위치를 100번 찍어도 흔들림이 매우 작다 → 조립/삽입(끼워넣기) 같은 정밀 작업에 유리”

원하면 너가 보는 로봇 스펙 표(예: Doosan, Dobot 등)에서 반복정밀도 수치랑 Reach 수치를 같이 적어주면, 그 수치가 실제 작업(픽앤플레이스/조립/나사/접촉작업)에서 어떤 의미인지 바로 해석해줄게.

https://github.com/jess-moss/koch-v1-1?tab=readme-ov-file

Look video

https://www.youtube.com/watch?v=U78QQ9wCdpY&list=PLo2EIpI_JMQu5zrDHe4NchRyumF2ynaUN&index=3

follower arm connection cable

leader arm connection cable

env setting

https://huggingface.co/docs/lerobot/koch

https://moveit.ai/install-moveit2/binary/

cd ws_moveit
ros2 launch moveit2_tutorials demo.launch.py

https://moveit.picknik.ai/main/doc/tutorials/pick_and_place_with_moveit_task_constructor/pick_and_place_with_moveit_task_constructor.html

sudo apt update sudo apt install --reinstall linux-firmware sudo update-initramfs -u sudo reboot

0) 개념 한 줄 요약

• tmux: SSH 끊겨도 작업(학습/스크립트) 계속 돌게 “터미널 세션”을 서버에 붙여두는 도구
• conda env: 파이썬/라이브러리 버전 충돌 막는 “개인/프로젝트 환경”

1) 서버 접속

ssh user@서버IP

2) tmux 세션 만들기 (작업방 만들기)

세션 이름을 정해서 생성:

tmux new -s exp1

이미 만들어둔 세션이 있으면 목록 확인:

tmux ls

3) conda 환경 준비/활성화

(1) 환경 생성(처음 한 번만)

conda create -n kunhee_env python=3.10 -y

(2) 환경 활성화(매번 작업 시작 시)

conda activate kunhee_env

(3) 지금 파이썬이 env 맞는지 확인(실수 방지)

which python
python -V

4) 학습/작업 실행

예시:

python train.py

로그를 파일로 남기고 싶으면(강추):

python train.py > train.log 2>&1

실시간으로 로그 보기:

tail -f train.log

5) tmux “분리(detach)” 해서 나가기 (작업은 계속 돌아감)

✅ 기본 키:

• Ctrl + b 누르고 (prefix)
• 손 떼고 d

즉: Ctrl+b → d

SSH를 끊어도(창 닫아도) tmux 안에서 실행 중인 학습은 계속 돌아요.

6) 나중에 다시 들어와서 이어보기(붙기)

다시 서버 접속 후:

세션 목록:

tmux ls

세션 붙기:

tmux attach -t exp1

7) conda deactivate 관련 핵심

• conda deactivate는 현재 터미널의 환경만 바꾸는 것
• 이미 돌고 있는 python train.py 같은 프로세스는 실행 시작 당시 환경을 물고 계속 실행됨
• 다만, 같은 tmux 창에서 새로 명령 실행할 땐 base로 실행될 수 있으니 주의

8) 자주 쓰는 tmux 단축키(기본 prefix = Ctrl+b)

• 분리(detach): Ctrl+b → d
• 창(윈도우) 새로 만들기: Ctrl+b → c
• 창 이동: Ctrl+b → n (다음), Ctrl+b → p (이전)
• 창 목록: Ctrl+b → w
• 현재 창 종료(프로세스 끝내기): exit 또는 Ctrl+d

9) “안 끊기게 돌리기” 추천 패턴(정석)

1. ssh 접속
2. tmux new -s exp1
3. conda activate kunhee_env
4. python train.py > train.log 2>&1
5. Ctrl+b → d 로 빠져나오기
6. 나중에 tmux attach -t exp1 로 확인

원하면 너 서버 상황에 맞춰 “가장 안전한 세팅”도 바로 잡아줄게.

• tmux 세션을 여러 개로 나눌지(실험별)
• 로그/체크포인트 폴더 구조를 어떻게 할지
• GPU 점유 확인(nvidia-smi)까지 한 번에 루틴으로 만들어줄까?

https://github.com/hyunwoongko/transformer/tree/master

질문 : 2번째로 들어갈때도 동일하게 input embeding부터???

질문 : 디코더에 처음은 출력이 없으니까 임의의 값을??? 그리고 훈련시 평가시 달라지는 것?

• why 이것을 사용했는가??

1) 문제점

과거의 문제점 층을 깊에 쌓을 수록 gradiant vinishing problem(미분을 하면서 미분값이 0으로 가서 결국 더 이상 네트워크가 업데이트 되지 않는 현상)이 존재

Residual block의 수식 (가장 기본형)

• 우리가 원래 원하던 함수: H(X)

• ResNet은 이를 직접 학습하지 않고, 잔차(residual), F(x)= H(x)−x 를 학습하게 변경

• y = x = F(x)

• 즉 이렇게 되면 “아무것도 안 하는(identity)” 해답이 필요할 때, F(x)=0만 만들면 되니까 최적화가 훨씬 쉬워진다는 게 핵심 주장입니다

2) 왜 skip connection이 학습을 쉽게 하나? (직관)

(1) “쉬운 길”이 생겨서 그라디언트가 덜 죽는다

(2) “필요한 변화만 추가로 학습”하게 만든다

질문 : 필요있고 없고는 역전파할때를 말하는 건지 순전파를 말하는 건지??

• 실제로는 순전파/역전파 둘 다에서 의미가 있어.

3) 통과 경로”가 생겨서 학습이 쉬워진다 보충 설명

부족한 개념 : 역전파 직접해보면서 0이되는지에 대한 부분을 이해가 필요할 듯 + 곱하기로

미분값이 적용되는지도 해볼 필요 있음

4-1) 2 layer (Sigmoid)

4-2) 2 layer ResNet (Sigmoid)

4-3) 2 layer ResNet (RELU)

RELU 함수

• 0이 나오면 프레임워크에 따라서 0 또는 1 사용 아마도 1사용할 듯

시그모이드 함수

• 시그모이드(sigmoid) 함수는 실수 전체 입력을 0~1 사이 값으로 “눌러서” 내보내는 S자 형태 함수야. 확률처럼 해석하기 좋아서 예전엔 분류 신경망 출력층/은닉층에 많이 썼어.

지수함수 이해

시그모이드 함수의 미분

• Title: Attention Is All You Need
• Authors / Venue / Year: Vaswani et al., NeurIPS 2017 (arXiv v7: 2023-08-02 표기)
• Link: https://arxiv.org/abs/1706.03762
• Read Date: 2026/02/06

2) 한 줄 요약 (Contribution in 1 sentence)

RNN/Conv 없이 “Self-Attention만”으로 인코더-디코더를 구성한 Transformer를 제안해, 번역에서 더 높은 성능과 더 빠른 병렬 학습을 달성했다.

3) Summary (핵심 내용 정리)

A. 문제 정의 (왜 RNN을 버렸나?)

• 기존 RNN 기반 시퀀스 모델은 시간축으로 순차 계산이 필수 → 학습 병렬화가 어렵고 긴 문장에서 비효율적.
• Attention은 거리와 상관없이 의존성 학습이 가능했지만, 대부분 RNN과 “같이” 쓰였음.
• Transformer는 아예 recurrence/conv를 제거하고 attention만으로 시퀀스 변환을 수행.

B. 모델 전체 구조 (그림으로 이해)

• Figure 1 (p.3): Transformer 전체 아키텍처

  • Encoder: (Self-Attention → FFN) 을 N=6층 쌓음
  • Decoder: (Masked Self-Attention → Encoder-Decoder Attention → FFN) 을 N=6층 쌓음
  • 각 서브레이어마다 Residual + LayerNorm: LayerNorm(x + Sublayer(x))
  • 디코더의 self-attention은 미래 토큰을 못 보게 mask(autoregressive 보장).

C. 핵심 아이디어 3개

1. Scaled Dot-Product Attention (기본 attention)
2. Multi-Head Attention (여러 표현공간을 병렬로 보게)
3. Positional Encoding (RNN/Conv가 없으니 “순서 정보”를 주입)

4) Include formulas and images to aid understanding (수식 + 그림 포인트)

(1) Scaled Dot-Product Attention — Eq.(1)

논문 핵심 수식:

• Q(Query): “지금 내가 찾고 싶은 것”
• K(Key): “각 토큰이 가진 주소/특징”
• V(Value): “각 토큰이 가진 실제 내용 벡터”
• (\sqrt{d_k}) 로 나누는 이유: (d_k) 가 커지면 내적 값이 커져 softmax가 포화되고 gradient가 작아지는 문제를 완화.
• Figure 2 (p.4) 왼쪽이 이 과정을 그림으로 보여줌.

(2) Multi-Head Attention — “한 번에 여러 시선”

• 논문 설정(베이스): h=8, (d_\text{model}=512), 그래서 각 head는 (d_k=d_v=64).
• 의미: “문법 관계”, “장거리 의존성”, “대명사 지시(anaphora)” 같은 패턴을 서로 다른 head가 분담해서 배운다.
• Figure 2 (p.4) 오른쪽이 Multi-Head를 시각화.

(3) Position-wise Feed-Forward Network — Eq.(2)

• 각 토큰 위치에 독립적으로 동일한 FFN 적용(= 커널 1짜리 conv 2번과 유사).
• 베이스 설정: (d_\text{model}=512), (d_{ff}=2048).

(4) Positional Encoding (사인/코사인) — 순서 정보 주입

• Figure 1 (p.3) 에서 임베딩에 positional encoding을 더하는 흐름이 나옴.
• 장점: 학습 길이보다 더 긴 시퀀스에도 외삽 가능할 수 있다고 설명.

(5) Learning rate schedule — Eq.(3) (워밍업 핵심)

• 초기 warmup_steps=4000 동안 선형 증가, 이후 (1분의 루트 step)로 감소.

(6) “그림으로 이해” 포인트 (논문 내 시각자료)

• Figure 1 (p.3): Encoder/Decoder 블록 구조(모델 전체 지도)
• Figure 2 (p.4): Scaled Dot-Product / Multi-Head Attention 메커니즘
• Figure 35 (p.1315): attention head들이 장거리 의존성, 대명사 지시 등 서로 다른 역할을 학습하는 시각화

5) Results (숫자 중심으로 꼭 남길 것)

• WMT14 En→De: 28.4 BLEU (Transformer big), 기존 최고 대비 +2 BLEU 이상 향상
• WMT14 En→Fr: 41.8 BLEU (big), 단일 모델 SOTA 주장
• 학습 비용/시간: big 모델이 8×P100에서 3.5일, base는 12시간(100k steps)로 보고

6) English vocabulary learned (단어/표현 + 뜻 + 예문)

아래는 이 논문에서 “자주 나오고, 연구 글에서 재사용되는” 표현 위주로 정리했어.

1. sequence transduction

• 뜻: 시퀀스 → 시퀀스로 변환(번역/요약 등)
• 예문: The Transformer is a model for sequence transduction tasks.
• 해석: Transformer는 시퀀스 변환 작업을 위한 모델이다.

2. eschew / dispensing with

• 뜻: (특히 일부러) 피하다 / 없애다
• 예문: The Transformer dispenses with recurrence and convolutions entirely.
• 해석: Transformer는 recurrence와 convolution을 완전히 제거한다.

3. recurrence

• 뜻: 순환 구조(RNN처럼 이전 상태를 다음으로 전달)
• 예문: Without recurrence, the model becomes highly parallelizable.
• 해석: recurrence가 없으면 모델은 병렬화가 쉬워진다.

4. parallelizable / preclude

• 뜻: 병렬화 가능한 / ~를 불가능하게 하다(막다)
• 예문: Sequential computation precludes parallelization within training examples.
• 해석: 순차 계산은 한 샘플 내부 병렬화를 막는다.

5. compatibility function

• 뜻: query와 key가 “얼마나 잘 맞는지” 점수화하는 함수
• 예문: Weights are computed by a compatibility function of the query with the key.
• 해석: 가중치는 query와 key의 적합도 함수로 계산된다.

6. scaled dot-product

• 뜻: 스케일링된 내적(softmax 포화 방지 목적)
• 예문: We divide by (\sqrt{d_k}) to counteract small gradients.
• 해석: 작은 그래디언트 문제를 줄이기 위해 (\sqrt{d_k})로 나눈다.

7. masking / illegal connections

• 뜻: 마스킹 / 허용되지 않는 연결
• 예문: We mask out values corresponding to illegal connections.
• 해석: 불법 연결에 해당하는 값들은 마스킹한다.

8. auto-regressive

• 뜻: 자기회귀(이전 출력만 보고 다음 출력 생성)
• 예문: The decoder is auto-regressive and uses shifted-right outputs.
• 해석: 디코더는 자기회귀이며 출력 시퀀스를 한 칸 밀어 사용한다.

9. positional encoding / extrapolate

• 뜻: 위치 인코딩 / 학습 범위를 넘어 일반화(외삽)
• 예문: Sinusoidal encodings may allow extrapolation to longer sequences.
• 해석: 사인/코사인 인코딩은 더 긴 시퀀스로 외삽을 가능하게 할 수 있다.

10. ablation (study) (논문 표/실험 읽을 때 필수 단어)

• 뜻: 구성요소를 빼서 효과를 검증하는 실험
• 예문: Model variations indicate which components matter most.
• 해석: 모델 변형 실험은 어떤 구성요소가 중요한지 보여준다.

7) 내가 체크할 “개념-문장” (헷갈리기 쉬운 핵심 문장 3개)

1. “Self-attention reduces path length to O(1)”가 왜 중요한가?

• 해석 포인트: 멀리 떨어진 토큰 관계를 학습할 때, 정보(gradient)가 여러 층/시간을 거치는 “긴 경로”가 필요하면 어려워짐. Self-attention은 한 번에 전 위치를 볼 수 있어서 경로가 짧아진다.

2. “Masking ensures position i depends only on < i”

• 해석 포인트: 번역/생성에서는 미래 단어를 보면 “치팅”이 되므로, 디코더 self-attention에서 미래를 가려야 함.

3. “Scaling by √dk prevents extremely small gradients”

• 해석 포인트: 내적 값이 커지면 softmax가 포화 → gradient가 거의 0 → 학습이 안 됨 → 스케일링으로 완화.

원하면 다음 단계로, 너가 이해한 걸 기준으로 (1) Q/K/V를 2토큰 예제로 직접 숫자 계산하면서 Attention이 어떻게 나오는지, 그리고 (2) Multi-head가 왜 ‘평균내서 뭉개는 문제’를 줄이는지까지 “손계산 느낌”으로 같이 해볼 수 있어.

마지막은 너 스스로 논문 읽고 모르는 문장이나 단어를 같이 공부하는거지 그래서 미자막에 이제 잘 이해하고 논문읽고 단어 문장 공부하자 이렇게 말 해줘