파이토치 트랜스포머를 활용한 자연어 처리와 컴퓨터비전 심층학습 (ebook)

도서 카드뉴스

윤대희

어반베이스의 머신러닝 팀 리더로 근무하면서 컴퓨터비전과 딥러닝을 활용해 2D 도면을 3D로 변환하는 프로젝트를 진행했다. 현재는 카카오스타일의 Vision&NLP 팀 리더로 데이터 리터러시, 데이터 패브릭, MLOps 등 관련 프로젝트를 진행하고 있다. 머신러닝·딥러닝을 비롯해 데이터 품질 관리, 데이터 통합, 비즈니스 인텔리전스 등 데이터 통합에 관심이 있으며, 기술 공유 및 확장 플러그인 배포 등으로 개인이나 조직이 기술을 보다 쉽게 이용하고 활용할 수 있도록 도움을 주고 있다. 저서로 《C#과 파이썬을 활용한 OpenCV 4 프로그래밍》(위키북스, 2021)이 있다.

김동화

고려대학교에서 산업경영공학 박사 학위를 취득했다. 데이터 기반으로 제조, IT, 금융 분야에서 발생하는 다양한 기술적 문제를 해결했으며, 머신러닝·딥러닝 분야에 총 6편의 SCI 논문을 게재했다. 현재는 카카오스타일의 Vision&NLP 팀에서 컴퓨터비전과 딥러닝을 담당하며 패션 속성 추출, 유사 이미지 추천 및 코디 추천을 위한 다양한 이커머스 플랫폼 과제를 진행하고 있다. 컴퓨터비전, 자연어 처리, 멀티모달 학습을 연구하고 활용하는 데 관심이 있다.

송종민

동국대학교에서 전자전기공학 석사 학위를 취득했다. 아크릴 회사에서 선임 연구원으로 근무하면서 빅데이터 포렌식 및 AI 모델 소형화 프로젝트를 진행했다. 현재는 카카오스타일의 Vision&NLP 팀에서 컴퓨터비전과 딥러닝을 담당하며 이미지 데이터 분석, 유사 이미지 추천, 모델 서빙 및 배포 자동화 관련 프로젝트를 진행하고 있다. 인공지능 기술을 활용한 생산성 향상과 비용 최적화에 관심이 있다.

진현두

학부생 시절 머신러닝 한번 공부해 보지 않겠냐는 선배의 권유로 데이터 사이언티스트의 길로 들어섰다. 대학원 시절 특허를 비롯한 텍스트 데이터를 이용한 경험을 바탕으로 주식회사 공팔리터의 AI Lab에서 커머스 리뷰 데이터를 이용한 여러 모델을 구축했다. 현재는 공팔리터에서의 경험을 이용해 카카오스타일의 Vision&NLP 팀에서 사용자 리뷰, 상품 정보 등 텍스트 데이터를 활용한 딥러닝 프로젝트를 진행하고 있다. AI 콜로키엄, AWS Community Day 등에서 발표하며 경험을 나누는 것의 즐거움을 배웠다. 지능형 검색 시스템과 Virtual Try-On 등에 관심이 있다.

• [1부] 파이토치 시작하기
•  
• ▣ 01장: 인공지능과 방법론
• 인공지능이란?
• __인공지능 역사
• __인공지능 활용 분야
• 머신러닝 시스템
• __지도 학습
• __비지도 학습
• __준지도 학습
• __강화 학습
• 머신러닝 아키텍처
• __데이터 준비
• __모델링
• __모델 평가
• __모델 배포
• MLOps
•  
• ▣ 02장: 파이토치 설치
• 파이토치란?
• 파이토치 특징
• 파이토치 설치
• __파이토치 CPU 설치
• __파이토치 GPU 설치
• __Google Colaboratory
•  
• ▣ 03장: 파이토치 기초
• 텐서
• __텐서 생성
• __텐서 속성
• __차원 변환
• __자료형 설정
• __장치 설정
• __장치 변환
• __넘파이 배열의 텐서 변환
• __텐서의 넘파이 배열 변환
• 가설
• __머신러닝에서의 가설
• __통계적 가설 검정 사례
• 손실 함수
• __제곱 오차
• __오차 제곱합
• __평균 제곱 오차
• __교차 엔트로피
• 최적화
• __경사 하강법
• __학습률
• __최적화 문제
• __단순 선형 회귀: 넘파이
• __단순 선형 회귀: 파이토치
• 데이터세트와 데이터로더
• __데이터세트
• __데이터로더
• __다중 선형 회귀
• 모델/데이터세트 분리
• __모듈 클래스
• __비선형 회귀
• __모델 평가
• __데이터세트 분리
• 모델 저장 및 불러오기
• __모델 전체 저장/불러오기
• __모델 상태 저장/불러오기
• __체크포인트 저장/불러오기
• 활성화 함수
• __이진 분류
• __시그모이드 함수
• __이진 교차 엔트로피
• __이진 분류: 파이토치
• __비선형 활성화 함수
• 순전파와 역전파
• __순전파 계산
• __오차 계산
• __역전파 계산
• __갱신 결과 비교
• 퍼셉트론
• __단층 퍼셉트론
• __다층 퍼셉트론
• __퍼셉트론 모델 실습
•  
• ▣ 04장: 파이토치 심화
• 과대적합과 과소적합
• __과대적합과 과소적합 문제 해결
• 배치 정규화
• __정규화 종류
• __배치 정규화 풀이
• 가중치 초기화
• __상수 초기화
• __무작위 초기화
• __제이비어 & 글로럿 초기화
• __카이밍 & 허 초기화
• __직교 초기화
• __가중치 초기화 실습
• 정칙화
• __L1 정칙화
• __L2 정칙화
• __가중치 감쇠
• __모멘텀
• __엘라스틱 넷
• __드롭아웃
• __그레이디언트 클리핑
• 데이터 증강 및 변환
• __텍스트 데이터
• __이미지 데이터
• 사전 학습된 모델
• __백본
• __전이 학습
• __특징 추출 및 미세 조정
•  
• [2부] 자연어 처리
•  
• ▣ 05장: 토큰화
• 단어 및 글자 토큰화
• __단어 토큰화
• __글자 토큰화
• 형태소 토큰화
• __형태소 어휘 사전
• __KoNLPy
• __NLTK
• __spaCy
• 하위 단어 토큰화
• __바이트 페어 인코딩
• __워드피스
•  
• ▣ 06장: 임베딩
• 언어 모델
• __자기회귀 언어 모델
• __통계적 언어 모델
• N-gram
• TF-IDF
• __단어 빈도
• __문서 빈도
• __역문서 빈도
• __TF-IDF
• Word2Vec
• __단어 벡터화
• __CBoW
• __Skip-gram
• __계층적 소프트맥스
• __네거티브 샘플링
• __모델 실습: Skip-gram
• __모델 실습: Gensim
• fastText
• __모델 실습
• 순환 신경망
• __순환 신경망
• __장단기 메모리
• __모델 실습
• 합성곱 신경망
• __합성곱 계층
• __활성화 맵
• __풀링
• __완전 연결 계층
• __모델 실습
•  
• ▣ 07장: 트랜스포머
• Transformer
• __입력 임베딩과 위치 인코딩
• __특수 토큰
• __트랜스포머 인코더
• __트랜스포머 디코더
• __모델 실습
• GPT
• __GPT-1
• __GPT-2
• __GPT-3
• __GPT 3.5
• __GPT-4
• __모델 실습
• BERT
• __사전 학습 방법
• __모델 실습
• BART
• __사전 학습 방법
• __미세 조정 방법
• __모델 실습
• ELECTRA
• __사전 학습 방법
• __모델 실습
• T5
• __모델 실습
•  
• [3부] 컴퓨터 비전
•  
• ▣ 08장: 이미지 분류
• AlexNet
• __LeNet-5와 AlexNet
• __모델 학습
• __모델 추론
• VGG
• __AlexNet과 VGG-16
• __모델 구조 및 데이터 시각화
• __미세 조정 및 모델 학습
• ResNet
• __ResNet의 특징
• __모델 구현
• Grad-CAM
• __클래스 활성화 맵
• __Grad-CAM
•  
• ▣ 09장: 객체 탐지
• Faster R-CNN
• __R-CNN
• __Fast R-CNN
• __Faster R-CNN
• __모델 학습 과정
• __모델 실습
• SSD
• __멀티 스케일 특징 맵
• __기본 박스
• __모델 학습 과정
• __모델 실습
• FCN
• __업샘플링
• __모델 구조
• __모델 실습
• Mask R-CNN
• __특징 피라미드 네트워크
• __관심 영역 정렬
• __마스크 분류기
• __모델 실습
• YOLO
• __YOLOv1
• __YOLOv2
• __YOLOv3
• __YOLOv4 / YOLOv5
• __YOLOv6 / YOLOv7
• __모델 실습: YOLOv8
•  
• ▣ 10장: 비전 트랜스포머
• ViT
• __합성곱 모델과 ViT 모델 비교
• __ViT의 귀납적 편향
• __ViT 모델
• __패치 임베딩
• __인코더 계층
• __모델 실습
• Swin Transformer
• __ViT와 스윈 트랜스포머 차이
• __스윈 트랜스포머 모델 구조
• __모델 실습
• CvT
• __합성곱 토큰 임베딩
• __어텐션에 대한 합성곱 임베딩
• __모델 실습
•  
• [4부] 서비스 모델링
•  
• ▣ 11장: 모델 배포
• 모델 경량화
• __양자화
• __지식 증류
• __텐서 분해
• __ONNX
• 모델 서빙
• __모델 서빙 웹 프레임워크
• __포스트맨
• 도커 배포
• __도커란?
• __빌드 및 배포
• 데모 애플리케이션
• __스트림릿
• __애플리케이션 배포
• __파이토치 모델 연동
•  
• ▣ 부록A: 파이토치 라이트닝
• __모델 학습
• __트레이너 클래스
• ▣ 부록B: 허깅 페이스
• __PreTrainedConfig 클래스
• __PreTrainedModel 클래스
• __PreTrainedTokenizer 클래스
• __PreTrainedFeatureExtractor 클래스
• __PreTrainedImageProcessor 클래스
• __Auto 클래스
• __트레이너 클래스
•  
• ▣ 부록C: 파이토치 이미지 모델
• __모델 생성
• __사전 학습된 모델
• __미세 조정
•  
• ▣ 부록D: 파이토치 컴파일러
• ▣ 부록E: 메모리 부족

• GitHub 저장소: https://github.com/wikibook/pytorchtrf
• ZIP 형식으로 다운로드: https://github.com/wikibook/pytorchtrf/archive/refs/heads/main.zip

초판 1쇄

• 3쪽, 본문 8번째 줄

  데이터의 양과 질이 결과에 큰 영향을 미친다.

  ==>

  데이터의 양과 품질이 모델 성능에 중요한 영향을 미친다.

• 14쪽, 본문 7번째 줄

  데이터들의 군집 중심에서 가장 가까운 군집으로 뭉쳐진다.

  ==>

  데이터는 각 군집 중심과 가장 가까운 군집으로 할당된다.

• 68쪽, 수식 3.8의 4번째 줄을 다음 수식으로 교체

  $$ = W_{i} - \alpha \times \frac{2}{n} \sum_{i=1}^{n} [ \{ Y_i - (W_i \times x + b_i) \} \times (-x) ] $$

• 122쪽, 본문 12번째 줄

  활성화 함수는 비선형 구조를 가져 역전파 과정에서 미분값을 통해 학습이 진행될 수 있게 한다. 활성화 함수가 선형 구조라면, 미분 과정에서 항상 상수가 나오므로 학습을 진행하기가 어렵다. 다시 말해 활성화 함수는 입력을 정규화(Normalization)하는 과정으로 볼 수 있다.

  ==>

  활성화 함수는 비선형성을 추가하여 신경망이 복잡한 패턴을 학습할 수 있도록 한다. 만약, 활성화 함수가 선형 함수라면 신경망의 각 계층을 거쳐도 결국 하나의 선형 변환으로 귀결되므로 다층 구조의 의미가 사라진다. 또한 활성화 함수는 입력 값을 변환하여 신경망이 더 효과적으로 학습할 수 있도록 돕는다. 예를 들어, ReLU(Rectified Linear Unit) 함수는 음수를 0으로 만들고 양수는 그대로 유지하여 중요한 특징을 강조하는 역할을 한다.

• 138쪽, 수식 3.24를 다음 수식으로 교체

  $$ LeakyReLU(x) = \begin{cases} 0 & \text{if: }x > 0 \\\ \text{negative_slope} \times x & \text{else: } otherwise \end{cases} $$

• 140쪽, 수식 3.26을 다음 수식으로 교체

  $$ ELU(x) = \begin{cases} x & \text{if: }x > 0 \\\ \text{negative_slope} \times (e^x - 1) & \text{else: } otherwise \end{cases} $$

• 144쪽, 수식 3.29의 첫 번째 줄

  $$ z_1 \ \ \ W_1x_1 + W_2x_2 + b_1 $$

  ==>

  $$ z_1 = W_1x_1 + W_2x_2 + b_1 $$

• 144쪽, 수식 3.29의 4번째 줄

  $$ z_2 \ \ \ W_3x_1 + W_4x_2 + b_2 $$

  ==>

  $$ z_2 = W_3x_1 + W_4x_2 + b_2 $$

• 144쪽, 수식 3.30의 첫 번째 줄

  $$ \sigma_1 = \frac{1}{1 + e^{z1}} $$

  ==>

  $$ \sigma_{1} = \frac{1}{1 + e^{-z_{1}}} $$

• 144쪽, 수식 3.30의 4번째 줄

  $$ \sigma_2 = \frac{1}{1 + e^{z2}} $$

  ==>

  $$ \sigma_{2} = \frac{1}{1 + e^{-z_{2}}} $$

• 145쪽, 수식 3.31의 첫 번째 줄

  $$ z_{3} \ \ \ W_{5} \sigma_{1} + W_{6} \sigma_{2} + b_{3} $$

  ==>

  $$ z_{3} = W_{5} \sigma_{1} + W_{6} \sigma_{2} + b_{3} $$

• 147쪽, 수식 3.36의 2번째 줄

  $$ = -\frac{\partial}{\partial\sigma3}(y\log{(\sigma3}) + (1-y)\log(1-\sigma3)) $$

  ==>

  $$ = -\frac{\partial}{\partial\sigma_3}(y\log{(\sigma_3}) + (1-y)\log(1-\sigma_3)) $$

• 148쪽, 수식 3.37의 밑에서 2번째 줄

  $$ = 0.3043 - 1.7106 \times 0.2428 \times 0.0000 $$

  ==>

  $$ = -0.3043 - 1.7106 \times 0.2428 \times 1.0000 $$

• 155쪽, 페이지 하단 각주 23

  활성화 함수가 계단 함수라면 퍼셉트론이라 부르며, 계단 함수가 아니면 인공 신경망으로 부른다. 현재 예제는 활성화 함수에 시그모이드를 적용했으므로 인공 신경망이다.

  ==>

  활성화 함수가 계단 함수라면 퍼셉트론이라고 부르며, 다층 구조와 비선형 활성화 함수를 사용하면 인공 신경망이라고 부른다. 현재 예제는 활성화 함수에 시그모이드를 적용했으므로 인공 신경망이다.

• 186쪽, 수식 4.17을 다음 수식으로 교체

  $$ \text{Elastic-Net} = \alpha \times L_1 + (1 - \alpha) \times L_2 $$

• 192쪽, 페이지 하단 '자연어 처리 데이터 증강 라이브러리 설치' 명령어를 다음 내용으로 교체

  pip install numpy requests nlpaug transformers==4.33.2 sacremoses nltk

• 233쪽, 본문 6번째 줄

  문자열 데이터 형태는 split 메서드를 이용하여

  ==>

  문자열은 split 메서드를 이용하여

• 237쪽, 본문 13번째 줄

  모델은 ‘그는’, ‘나는’, ‘그녀는’과 같은 데이터를 같은 의미 단위로 인식하지 못하고 학습을 진행한다.

  ==>

  모델은 ‘그는’, ‘나는’, ‘그녀는’을 개별 토큰으로 인식하게 되어 각 단어의 공통 구성 요소를 학습하지 못한다.

• 237쪽, 본문 15번째 줄

  어휘 사전을 구축한다면 [’-는’, ‘-에게’, ‘그’, ‘나’]와 같은 정보에서 ‘그녀’의 토큰 정보만 새로 학습해 ‘그녀는’이나 ‘그녀에게’와 같은 어휘를 쉽게 학습할 수 있다.

  ==>

  어휘 사전을 구축한다면 [’-는’, ‘-에게’, ‘그’, ‘나’, ‘그녀’]와 같이 분리되며, 새로 학습한 '그녀' 형태소를 통해 '그녀는', '그녀에게' 등의 조합을 인식할 가능성이 높아진다.

• 240쪽, 본문 2번째 줄

  명사 추출(kkma.sentences) 기능을 제공한다.

  ==>

  문장 추출(kkma.sentences) 기능을 제공한다

• 258쪽, 수식 5.1을 다음 수식으로 교체

  $$ score = \frac{f(x,y)}{f(x) \times f(y)} $$

• 258쪽, 본문 밑에서 8번째 줄

  $ \frac{9}{17 * 9} \simeq 0.06 $이 된다.

  ==>

  $ \frac{9}{17 \times 9} \simeq 0.06 $이 된다.

• 262쪽, 출력 결과를 다음 내용으로 교체

  인코더 형식 : <class 'tokenizers.Encoding'>
  단일 문장 토큰화 : ['안녕하세요', ',', '토', '##크', '##나이', '##저', '##가', '잘', '학습', '##되었', '##군요', '!']
  여러 문장 토큰화 : [['이렇게', '입력', '##값을', '리스트', '##로', '받아서'], ['쉽게', '토', '##크', '##나이', '##저', '##를', '사용할', '수', '있다', '##ㅂ니다']]
  단일 문장 정수 인코딩 : [8760, 11, 8693, 8415, 16269, 7536, 7488, 7842, 15016, 8670, 8734, 0]
  여러 문장 정수 인코딩 : [[8187, 19643, 13834, 28119, 7495, 12607], [9739, 8693, 8415, 16269, 7536, 7510, 14129, 7562, 8157, 7489]]
  정수 인코딩에서 문장 변환 : 안녕하세요, 토크나이저가 잘 학습되었군요!

• 266쪽, 그림 6.1을 다음 그림으로 교체

  

• 273쪽, 수식 6.5를 다음 수식으로 교체

  $$ {\text {TF}}(t, d) = {\text {count}}(t, d) $$

• 273쪽, 수식 6.6을 다음 수식으로 교체

  $$ {\text {DF}}(t, D) = {\text {count}}(t \in d: d \in D) $$

• 274쪽, 수식 6.7을 다음 수식으로 교체

  $$ {\text {IDF}}(t, D) = log\left(\frac{{\text {count}}(D)}{1 + {\text {DF}}(t, D)}\right) $$

  • 274쪽, 수식 6.8을 다음 수식으로 교체

  $$ {\text {TF-IDF}}(t, d, D) = {\text {TF}}(t, d) \times {\text {IdF}}(t, D) $$

• 291쪽, 예제 6.8을 다음 코드로 교체(변수명 변경)

  import torch
  from torch.utils.data import TensorDataset, DataLoader
  
  index_pairs = torch.tensor(index_pairs)
  center_indexes = index_pairs[:, 0]
  context_indexes = index_pairs[:, 1]
  
  dataset = TensorDataset(center_indexes, context_indexes)
  dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

• 293쪽, 예제 6.11의 밑에서 4번째 줄

  token = vocab[30]

  ==>

  token = vocab[index]

• 293쪽, 수식 6.10을 다음 수식으로 교체

  $$ {\text {cosine similarity}}(a, b) = \frac{a \cdot b}{\lVert a \rVert \lVert b \rVert } $$

• 303쪽, 예제 6.16의 3~12줄을 다음 코드로 교체(max_final_vocab 인수 추가)

  fastText = FastText(
      sentences=tokens,
      vector_size=128,
      window=5,
      min_count=5,
      sg=1,
      max_final_vocab=20000,
      epochs=3,
      min_n=2,
      max_n=6
  )

• 313쪽, 본문 4번째 줄

  [ 계층 수 × 양방향 여부 + 1, 배치 크기, 은닉 상태 크기 ]로 구성된다.

  ==>

  [ 계층 수 × (양방향 여부 + 1), 배치 크기, 은닉 상태 크기 ]로 구성된다.

• 314쪽, 그림 6.18을 다음 그림으로 교체

  

• 315쪽, 그림 6.19를 다음 그림으로 교체

  

• 317쪽, 그림 6.20을 다음 그림으로 교체

  

• 318쪽, 그림 6.21을 다음 그림으로 교체

  

• 318쪽, 수식 6.14의 첫 번째 줄을 다음 수식으로 교체

  $$ g_{t} = {\text {tanh}}(W_{x}^{(g)} x_t + W_{x}^{(g)}h_{t-1} + b^{g}) $$

• 318쪽, 수식 6.14의 2번째 줄을 다음 수식으로 교체

  $$ i_{t} = {\text {sigmoid}}(W_{x}^{(g)} x_t + W_{x}^{(g)}h_{t-1} + b^{g}) $$

• 318쪽, 본문 첫 번째 줄

  기억 게이트는 $ g_i $와 $ i_t $로 구성돼 있으며 망각 게이트와 동일한 연산으로 계산된다. $ g_i $는 활성화 함수로

  ==>

  기억 게이트는 $ g_t $와 $ i_t $로 구성돼 있으며 망각 게이트와 동일한 연산으로 계산된다. $ g_t $는 활성화 함수로

• 318쪽, 본문 3번째 줄

  $ g_i $는 -1에서 1 사이의 값을

  ==>

  $ g_t $는 -1에서 1 사이의 값을

• 318쪽, 본문 4번째 줄

  $ g_i $만으로는

  ==>

  $ g_t $만으로는

• 318쪽, 수식 6.15를 다음 수식으로 교체

  $$ c_t = f_t \odot c_{t - 1} + g_t \odot i_t $$

• 319쪽, 그림 6.22를 다음 그림으로 교체

  

• 318쪽, 수식 6.14를 다음 수식으로 교체

  $$ g_t = tanh(W_x^{(g)} x_t + W_x^{(g)} h_{t-1} + b^{(g)}) $$

  $$ i_t = sigmoid(W_x^{(i)} x_t + W_x^{(i)} h_{t-1} + b^{(i)}) $$

• 321쪽, 예제 코드의 5번째 줄

  ouput_size = 256

  ==>

  output_size = 256

• 321쪽, 예제 코드의 12번째 줄

  hidden_size=ouput_size,

  ==>

  hidden_size=output_size,

• 321쪽, 예제 코드의 밑에서 첫 번째 줄

  proj_size if proj_size > 0 else ouput_size,

  ==>

  proj_size if proj_size > 0 else output_size,

• 322쪽, 예제 코드의 2번째 줄

  c_0 = torch.rand(num_layers * (int(bidirectional) + 1), batch_size, ouput_size)

  ==>

  c_0 = torch.rand(num_layers * (int(bidirectional) + 1), batch_size, output_size)

• 322쪽, 본문 밑에서 7번째 줄

  [ 계층 수 × 양방향 여부 + 1, 배치 크기, 은닉 상태 크기 ]를 갖는다.

  ==>

  [ 계층 수 × (양방향 여부 + 1), 배치 크기, 은닉 상태 크기 ]를 갖는다.

• 343쪽, 수식 6.18을 다음 수식으로 교체

  $$ L_{out} = \lfloor \frac{L_{in} + 2 \times {\text {padding}} - {\text {dilation}} \times ({\text {kernel_size}} - 1) - 1}{{\text {stride}}} + 1 \rfloor $$

• 343쪽, 수식 6.19의 첫 번째 줄을 다음 수식으로 교체

  $$ L_{in} = 6, {\text {kernel_size}} = 3, {\text {stride}} = 1, {\text {padding}} = 0, {\text {dilation}} = 1 $$

• 346쪽, 수식 6.20을 다음 수식으로 교체

  $$ L_{out} = \lfloor \frac{L_{in} + 2 \times {\text {padding}} - {\text {kernel_size}} }{{\text {stride}}} + 1 \rfloor $$

• 355쪽, 본문 첫 번째 줄

  2017년 코넬 대학의

  ==>

  2017년 구글의

• 355쪽, 본문 3번째 줄

  기존의 순환 신경망과 같은 순차적 방식이 아닌 병렬로 입력 시퀀스를 처리하는 기능이다.

  ==>

  기존의 순환 신경망처럼 순차적으로 데이터를 처리하는 방식이 아니라, 입력 시퀀스를 병렬로 처리할 수 있다는 점이다.

• 355쪽, 본문 8번째 줄

  이로 인해 모델이 재귀나 합성곱 연산 없이

  ==>

  이로 인해 모델이 순환 구조나 합성곱 연산 없이

• 358쪽, 그림 7.2를 다음 그림으로 교체

  

• 359쪽, 본문 7번째 줄

  마스크 멀티 헤드 어텐션

  ==>

  마스크 멀티 헤드 어텐션

• 364쪽, 그림 7.5를 다음 그림으로 교체

  

• 364쪽, 본문 밑에서 6번째 줄

  위치 인코딩이 적용된 소스 데이터의 입력 임베딩을 입력받는다.

  ==>

  위치 인코딩이 적용된 입력 임베딩을 입력받는다.

• 364쪽, 본문 밑에서 3번째 줄

  현재 시점에서 참조하고자 하는 정보의 위치를 나타내는 벡터로, 인코더의 각 시점마다 생성된다. 현재 시점에서 질문이 되는 벡터를 의미하며 이 벡터를 기준으로 다른 시점의 정보를 참조한다.

  ==>

  현재 시점에서 다른 토큰들과의 관계를 평가하는 기준 역할을 한다.

• 365쪽, 본문 첫 번째 줄

  쿼리 벡터와 비교되는 대상으로 쿼리 벡터를 제외한 입력 시퀀스에서 탐색되는 벡터가 된다. 키 벡터는 인코더의 각 시점에서 생성된다.

  ==>

  입력 시퀀스의 모든 시점에서 생성되며, 쿼리 벡터와 비교하여 유사도를 계산하는 역할을 한다.

• 365쪽, 본문 3번째 줄

  쿼리 벡터와 키 벡터로 생성된 어텐션 스코어를 얼마나 반영할지 설정하는 가중치 역할을 한다.

  ==>

  입력 시퀀스의 각 시점에서 생성되며, 어텐션 가중치를 적용하여 최종 출력을 만드는 역할을 한다.

• 365쪽, 본문 5번째 줄

  각 벡터는 의도한 의미의 값을 갖게 된다. 쿼리와 키 벡터의 연관성은 내적 연산으로 [N, S, S] 어텐션 스코어 맵을 사용한다.

  ==>

  각 벡터는 서로 다른 의미를 가지도록 조정된다. 어텐션 메커니즘에서는 쿼리와 키 벡터의 내적 연산을 통해 [N,S,S] 크기의 어텐션 스코어 맵을 만든다. 이 스코어를 소프트맥스로 정규화한 후, 값 벡터에 가중치를 적용하여 최종 출력을 생성한다.

• 365쪽, 본문 12번째 줄

  이러한 과정을 반복해 셀프 어텐션된 스코어 맵을 생성한다.

  ==>

  이렇게 계산된 어텐션 가중치를 적용하여 최종 어텐션 출력을 생성한다.

• 365쪽, 본문 밑에서 7번째 줄

  입력받는 [N, S, d] 텐서에 k개의 셀프 어텐션 벡터를 생성하고자 한다면 헤드에 대한 차원 축을 생성해 [N, k, S, d/k] 텐서 형태를 구성한다.

  ==>

  멀티 헤드 어텐션에서는 입력 [N, S, d]를 k개의 어텐션 헤드로 나누어 [N,k,S,d/k] 형태로 변환한 후, 각 헤드가 독립적으로 어텐션을 수행한다.

• 365쪽, 본문 밑에서 3번째 줄

  덧셈 & 정규화는 멀티 헤드 어텐션을 통과하기 이전의 입력값 [N, S, d] 텐서와 통과한 이후의 출력값 [N, S, d] 텐서를 더함으써로 학습 시 발생하는 기울기 소실을 완화한다. 그리고 이 값에 임베딩 차원 축으로 정규화하는 계층 정규화를 적용한다.

  ==>

  잔차 연결 & 정규화는 멀티 헤드 어텐션을 통과한 출력값 [N, S, d] 텐서와 멀티 헤드 어텐션에 입력되기 이전의 입력값 [N, S, d] 텐서를 잔차 연결(Residual Connection)을 통해 더하여 정보 손실을 방지하고, 정보 흐름을 유지한다. 그 후, 잔차 연결된 값에 계층 정규화(Layer Normalization)를 적용하여 학습 안정성을 높이고 수렴 속도를 개선한다.

• 366쪽, 본문 첫 번째 줄

  순방향 신경망은 두 가지 방법을 적용할 수 있는데, 선형 임베딩과 ReLU로 이뤄진 인공 신경망이나 1차원 합성곱이 사용된다. 이어서 다시 덧셈 & 정규화 과정이 수행된다.

  ==>

  트랜스포머 인코더에는 각 위치에서 독립적으로 작동하는 순방향 신경망이 포함된다. 순방향 신경망은 두 개의 선형 변환과 비선형 활성화 함수(ReLU 또는 GELU)로 구성되며, 입력 차원 [N,S,d]을 유지한 채 연산이 수행된다. 이어서 다시 잔차 연결 & 정규화 과정이 수행된다.

• 366쪽, 본문 3번째 줄

  여러 개의 트랜스포머 인코더 블록으로

  ==>

  여러 개의 인코더 블록으로

• 366쪽, 본문 5번째 줄

  마지막 인코더 블록에서 출력된 벡터는 디코더에서 사용되며, 디코더의 멀티 헤드 어텐션 모듈에서 참조되는 키, 값 벡터로 활용된다. 이런 방식으로 인코더와 디코더가 서로 정보를 공유한다.

  ==>

  인코더의 마지막 블록에서 생성된 벡터는 디코더의 입력으로 전달되며, 디코더의 인코더-디코더 어텐션(Encoder-Decoder Attention)에서 키(K)와 값(V) 벡터로 활용된다. 디코더는 첫 번째 멀티 헤드 어텐션에서 셀프 어텐션을 수행한 후, 두 번째 멀티 헤드 어텐션에서 인코더의 출력을 참조하여 최종 출력을 생성한다. 이렇게 인코더와 디코더가 서로 정보를 공유하며, 입력 정보를 처리한다.

• 366쪽, 본문 11번째 줄

  트랜스포머 모델에서 인코더의 멀티 헤드 어텐션 모듈은 인과성(Casuality)을 반영한 마스크 멀티 헤드 어텐션 모듈로 대체된다.

  ==>

  트랜스포머 모델에서 인코더의 멀티 헤드 어텐션 모듈은 마스크드 멀티 헤드 어텐션 모듈로 대체된다. 이 모듈은 셀프 어텐션을 수행하되, 미래 시점의 정보를 참조하지 않도록 인과성(Causality)을 보장하는 마스킹을 적용한다.

• 366쪽, 본문 13번째 줄

  인코더의 멀티 헤드 어텐션 모듈과 유사하지만, 마스크 멀티 헤드 어텐션 모듈은 어텐션 스코어 맵을 계산할 때 첫 번째 쿼리 벡터가 첫 번째 키 벡터만을 바라볼 수 있게 마스크를 씌운다. 두 번째 쿼리 벡터는 첫 번째와 두 번째 키 벡터를 바라보게 마스크를 씌운다.

  ==>

  마스크드 멀티 헤드 어텐션 모듈에서 각 쿼리 벡터는 자기 자신과 그 이전의 키 벡터들만을 참조하도록 마스킹된다. 예를 들어 첫 번째 쿼리 벡터는 첫 번째 키 벡터만을 참조하며, 두 번째 쿼리 벡터는 첫 번째와 두 번째 키 벡터를 참조하며, 세 번째 쿼리 벡터는 첫 번째, 두 번째, 세 번째 키 벡터를 참조한다.

• 366쪽, 본문 밑에서 7번째 줄

  마스크 멀티 헤드 어텐션 모듈에서는

  ==>

  마스크드 멀티 헤드 어텐션 모듈에서는

• 366쪽, 본문 밑에서 3번째 줄

  이러한 방식으로 마스크 멀티 헤드 어텐션 모듈은

  ==>

  이러한 방식으로 마스크드 멀티 헤드 어텐션 모듈은

• 367쪽, 그림 7.6를 다음 그림으로 교체

  

• 369쪽, 페이지 상단 '토치 데이터 및 토치 텍스트 라이브러리 설치' 명령어를 다음 내용으로 교체

  pip install torchdata torchtext==0.15.2 portalocker

• 376쪽, 본문 14번째 줄

  소스, 타깃, 메모리 키 패딩 마스크(key_padding_mask)는

  ==>

  소스(src), 타깃(tgt), 메모리(memory) 키 패딩 마스크(*_key_padding_mask)는

• 390쪽, 그림 7.7을 다음 그림으로 교체

  

• 391쪽, 그림 7.8을 다음 그림으로 교체

  

• 392쪽, 그림 7.9를 다음 그림으로 교체

  

• 393쪽, 그림 7.10을 다음 그림으로 교체

  

• 404쪽, 예제 코드의 아래 22번째 줄 삭제

  criterion = nn.CrossEntropyLoss()

• 404쪽, 예제 코드의 밑에서 8번째 줄

  logits = outputs.logits

  ==>

  logits = outputs.logits
  loss = outputs.loss

• 404쪽, 예제 코드의 밑에서 6번째 줄 삭제

  loss = criterion(logits, labels)

• 404쪽, 예제 코드의 밑에서 첫 번째 줄

  val_loss += loss

  ==>

  val_loss += loss.item()

• 405쪽, 본문 1~6번째 줄

  GPT-2 문장 분류 모델 클래스로 학습하면 내부적으로 손실을 계산해 반환한다. 그러므로 train 함수로 모델 학습 시 손실은 모델 출력값(outputs)의 loss 속성으로 가져온다.

  모델 평가 시 교차 엔트로피 함수로 모델을 평가해 본다. 모델에서 반환하는 손실값이 아닌, 로짓(logits) 값과 레이블로 손실을 계산한다.

  추가로 calc_accuracy 함수로 모델의 정확도를 계산한다. 이 함수는 모델의 예측 결과와 실제 레이블을 비교하여 정확도를 계산하고 반환한다.

  ==>

  GPT-2 문장 분류 모델 클래스로 학습한다면 작업 종류에 따라 알맞은 손실을 계산해 반환한다. 예제는 다중 분류 작업이므로 자동으로 교차 엔트로피 함수를 사용하여 손실을 계산하며, 계산된 손실은 출력값(outputs)의 loss 속성으로 반환된다. train 함수에서는 이 loss 속성을 사용하여 모델을 학습한다.

  모델 평가 시에도 트레이너에서 반환된 손실을 사용한다. 추가로 정확도를 계산하기 위해 calc_accuracy 함수를 통해 모델의 정확도를 계산한다. 이 함수는 모델의 예측 결과와 실제 레이블을 비교하여 정확도를 계산하고 반환한다.

• 407쪽, 본문 밑에서 4번째 줄

  이를 효과적으로 재활용함으로써 학습 데이터의 양과 다양성을 고려한 높은 성능을 보인다.

  ==>

  사전 학습된 가중치를 다양한 자연어 처리 작업에 효과적으로 활용하여 높은 성능을 보인다.

• 407쪽, 그림 7.13을 다음 그림으로 교체

  

• 409쪽, 본문 밑에서 4번째 줄

  [MASK] 토큰 적용 방법은 텍스트 토큰 중 15%에 해당하는 단어를 대상으로 마스킹을 수행한다. 예를 들어 100개의 토큰 중에서 약 15%에 해당하는 15개의 단어를 마스킹한다.

  ==>

  [MASK] 토큰 적용 방법은 입력 토큰 중 15%를 선택하여 마스킹을 수행한다. 예를 들어, 100개의 토큰 중 약 15개가 마스킹된다.

• 409쪽, 본문 밑에서 첫 번째 줄

  나머지 10%는 실제 토큰을 그대로 사용한다.

  ==>

  나머지 10%는 실제 단어를 유지한다.

• 410쪽, 본문 13번째 줄

  세그먼트 인덱스 B를 부여한다고 가정한다. BERT 모델은 문장 구분 임베딩으로 문장 단위의 정보를 학습할 수 있게 된다.

  ==>

  세그먼트 인덱스 B를 부여한다고 가정한다. 이때 핵심은 각 토큰이 어떤 문장에 속하는지 모델이 알게 해주는 것이다. 즉, A, B 각각에 대한 임베딩을 학습하고, 각 토큰의 임베딩에 더해주게 된다. 그러므로 BERT 모델은 문장 구분 임베딩으로 문장 단위의 정보를 학습할 수 있게 된다.

• 419쪽, 본문 첫 번째 줄

  BART는 인코더와 디코더를 모두 사용하므로 트랜스포머와 유사한 구조를 가지고 있지만, 차이점이 존재한다. 트랜스포머에서는 인코더의 모든 계층과 디코더의 모든 계층 사이의 어텐션 연산을 수행했다면, BART는 인코더의 마지막 계층과 디코더의 각 계층 사이에만 어텐션 연산을 수행한다.

  ==>

  BART는 트랜스포머 구조를 사용한다는 점에서 BERT와 유사하지만, 차이점이 존재한다. 디코더가 없는 BERT와는 달리 BART는 트랜스포머와 동일하게 인코더의 마지막 계층과 디코더의 각 계층 사이에 어텐션 연산을 수행한다.

• 422쪽, 그림 7.18을 다음 그림으로 교체

  

• 429쪽, 본문 4번째 줄

  LCS는 두 문장 사이에 공통으로 존재하는 가장 긴 부분 문자열을 찾는 문제로, 문장의 구조적 유사성을 고려하고 가장 길게 연속되는 N-gram을 식별한다.

  ==>

  LCS는 두 문장에서 순서를 유지하면서 공통으로 존재하는 가장 긴 문자 시퀀스를 찾는 문제로, 연속되지 않더라도 순서가 보존되는 부분 수열을 찾아 문장의 구조적 유사성을 평가한다.

• 429쪽, 본문 밑에서 2번째 줄

  연속된 LCS에 가중치를 부여해 계산한다. 이 방법은 공통부분 문자열의 길이뿐만 아니라 해당 부분 문자열 내의 단어에 가중치를 부여해 평가하는 방식이다.

  ==>

  연속적으로 매칭되는 부분에 더 높은 가중치를 부여하는 방식이다. 이는 띄엄띄엄 매칭되는 것보다 연속적으로 매칭되는 경우가 원문의 의미를 더 잘 보존한다는 내용을 반영한 것이다.

• 431쪽, 예제 코드의 밑에서 9번째 줄

  val_loss += loss

  ==>

  val_loss += loss.item()

• 448쪽, 예제 코드의 밑에서 11번째 줄

  val_loss += loss

  ==>

  val_loss += loss.item()

• 470쪽, 예제 코드의 11번째 줄

  std=[1.0/255.0, 1.0/255.0, 1.0/255.0]

  ==>

  std=[0.229, 0.224, 0.225]

• 471쪽, 예제 코드의 5번째 줄

  std=[1.0/255.0, 1.0/255.0, 1.0/255.0]

  ==>

  std=[0.229, 0.224, 0.225]

• 476쪽, 예제 코드의 21번째 줄

  std=[1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0],

  ==>

  std=[0.229, 0.224, 0.225]

• 479쪽, 본문 4번째 줄

  레즈넷은 이러한 기울기 소실 문제를 해결하기 위해 잔차 연결(Residual Connection), 항등 사상(Identity Mapping), 잔차 블록(Residual Block) 등을 통해 기울기 소실 문제를 해결하고 계산 효율성을 높였다.

  ==>

  레즈넷은 깊은 신경망 구조의 학습 효율화를 위해 잔차 연결(Residual Connection), 항등 사상(Identity Mapping), 잔차 블록(Residual Block) 등을 적용한 구조를 채택했다. 그 결과, 계산 효율성을 향상시킴과 동시에 기울기 소실 문제까지 부수적으로 해결할 수 있었다.

• 481쪽, 본문 2번째 줄

  계층이 깊어질수록 학습이 어렵기 때문에 얕은 모델을 먼저 학습한 후 항등 사상으로 초기화된 계층을 추가해 모델을 깊게 구성했다.

  ==>

  항등 사상 실험에서는 입력을 그대로 출력하는 항등 함수를 구현하는 여러 계층을 쌓아서, 이론적으로는 최소한 얕은 네트워크만큼의 성능은 보장되어야 하는 상황을 만들었다.

• 481쪽, 본문 5번째 줄

  이미 학습된 모델의 결과를 그대로 출력하는 구조이므로 성능이 하락하지 않을 것으로 생각했다.

  ==>

  추가된 계층들이 입력을 그대로 출력하는 항등 함수를 학습하기만 하면 되므로, 이론적으로는 얕은 네트워크의 성능을 유지할 수 있을 것으로 예상했다.

• 486쪽, 본문 5번째 줄

  앞서 설명한 VGG-16에서는 최댓값 풀링을 통해 특징 맵의 크기를 감소시켰다면, 레즈넷에서는 간격을 활용해 특징 맵의 크기를 감소시킨다.

  ==>

  앞서 설명한 VGG-16에서는 주로 최댓값 풀링을 통해 특징 맵의 크기를 감소시킨 반면, 레즈넷에서는 일부 합성곱 계층에서 간격을 2로 설정하여 특징 맵의 크기를 줄이고 다운샘플링 효과를 얻는다.

• 487쪽, 본문 2번째 줄

  더 많은 합성곱 계층과 확장(expansion) 변수를 사용한다. 레즈넷의 초기 버전에서는 확장 변수를 활용하지 않았지만, 레즈넷이 더 깊어지고 병목 블록이 등장하면서 추가됐다.

  병목 블록에서 사용되는 확장값은 병목 블록의 세 번째 합성곱 계층에서 사용된다. 이 값은 출력 차원 수를 늘려 더 많은 특징을 학습하고 성능을 높이기 위해 사용된다.

  ==>

  더 많은 합성곱 계층을 사용하며, 마지막 1×1 합성곱 계층에서 특징 맵의 차원 수를 확장(expansion)하는 방식을 사용한다. 즉, 1×1 합성곱으로 차원을 줄이고(reduce), 3x3 합성곱을 수행한 후, 다시 1×1 합성곱으로 차원을 복원하는 세 개의 합성곱 계층을 사용한다.

  레즈넷의 초기 버전에서는 병목 블록이 없었으며, 깊이가 깊어짐에 따라 연산량을 줄이기 위해 병목 블록이 도입되었다.

  병목 블록의 마지막 1×1 합성곱 계층은 입력으로 들어온 특징 맵의 차원 수를 확장하여 더 풍부한 특징을 표현하고, 최종적으로 성능을 향상시키는 역할을 한다.

• 507쪽, 본문 밑에서 2번째 줄

  영역 제안과 합성곱 모델을 결합하는 방식이므로 R-CNN(Regions Based CNN)이라고 부른다.

  ==>

  영역 제안과 합성곱 모델을 활용하는 방식이므로 R-CNN(Region-Based CNN)이라고 부른다.

• 509쪽, 본문 밑에서 6번째 줄

  후보 영역은 크기가 매우 다양하고 모든 후보 영역을 합성곱 모델에 전달하므로 연산량과 메모리 사용량이 많다.

  ==>

  후보 영역은 크기가 다양하며, 각각을 개별적으로 합성곱 신경망에 전달하기 때문에 연산량과 메모리 사용량이 많다.

• 510쪽, 본문 5번째 줄

  관심 영역을 잘라내 고정된 크기의

  ==>

  관심 영역을 특징 맵에서 추출한 후, 고정된 크기의

• 510쪽, 본문 밑에서 8번째 줄

  추출하는 방식을 사용한다. 이 방식은

  ==>

  추출할 수 있다. 이 방식은

• 510쪽, 본문 밑에서 4번째 줄

  관심 영역 추출과 특징 맵 변환을 동시에 수행해 모델의 매개변수를 공유할 수 있어, 더 경량화된 모델을 구성할 수 있다.

  ==>

  관심 영역 추출하는 과정과 특징 맵 생성을 동일한 합성곱 연산을 통해 수행하므로, 모델의 매개변수를 공유할 수 있어 연산 효율이 향상된다.

• 523쪽, 예제 코드의 10번째 줄

  self.iamge_path = os.path.join(root, directory)

  ==>

  self.image_path = os.path.join(root, directory)

• 524쪽, 예제 코드의 5번째 줄

  image_path = os.path.join(self.iamge_path, file_name)

  ==>

  image_path = os.path.join(self.image_path, file_name)

• 534쪽, 수식 9.10을 다음 수식으로 교체

  $$ {\text {Precision}} = \frac{TP}{TP+FP} $$

• 534쪽, 수식 9.11을 다음 수식으로 교체

  $$ {\text {Recall}} = \frac{TP}{TP+FN} $$

• 537쪽, 본문 밑에서 6번째 줄

  객체의 존재 여부를 판단한다.

  ==>

  예측의 정확도를 평가한다.

• 539쪽, 본문 7번째 줄

  이러한 구조로 인해 영역 제안 결과가 필요 없어져 병목 현상이 사라지고 빠른 추론이 가능해진다.

  ==>

  이러한 구조로 인해 별도의 영역 제안 과정이 필요 없어 병목 현상이 줄어들고 빠른 추론이 가능해진다.

• 539쪽, 본문 밑에서 3번째 줄

  각각의 합성곱 계층에 입력돼 객체의 위치와 클래스 정보로 변환된다.

  ==>

  각 계층에서 별도로 객체의 위치와 클래스 확률을 예측하는 데 사용된다.

• 540쪽, 본문 5번째 줄

  그리드의 좌푯값은 원본 이미지의 상대적인 위칫값으로, 이미지의 각 위치를 고정 크기의 그리드 셀로 분할한다.

  ==>

  그리드 셀의 위치는 원본 이미지에서 상대적인 좌푯값으로 표현되며, 이미지는 고정된 크기의 그리드 셀로 균등하게 분할된다.

• 540쪽, 본문 밑에서 5번째 줄

  기본 박스의 크기는 입력 이미지의 크기와 특징 맵의 크기를 고려해 초기 기본 박스의 크기를 설정한다.

  ==>

  기본 박스의 크기는 입력 이미지의 크기를 기준으로 특징 맵의 크기에 따라 상대적으로 결정된다.

• 542쪽, 본문 밑에서 11번째 줄

  객체 분류 결과를 클래스 점수로 정렬한 후 상위 N개의 객체 영역 샘플과 배경 영역 샘플을 1:3 비율로 추출한다.

  ==>

  객체 분류 결과를 기반으로 손실값이 높은 샘플을 우선적으로 선택하여, 객체 영역 샘플과 배경 영역 샘플을 1:3 비율로 추출한다.

• 566쪽, 본문 8번째 줄

  기존 Faster R-CNN은 객체의 대략적인 위치를 검출할 수 있지만, 객체의 모양을 정확히 파악하기에 어려움이 있었다. 이 문제는 객체를 고정된 크기로 변환하고 관심 영역 풀링을 수행하는 과정에서 발생하는 손실로 인하여 공간적 어긋남을 초래한다.

  ==>

  기존 Faster R-CNN은 객체의 대략적인 위치를 검출할 수 있지만, 고정된 크기로 변환하는 과정에서 발생하는 공간 정보 왜곡으로 인해 객체의 정확한 모양을 파악하는 데 어려움이 있었다.

• 566쪽, 본문 11번째 줄

  관심 영역 정렬이라는 방법을 사용해 공간적 어긋남을 최소화한다.

  ==>

  관심 영역 정렬을 적용하여 위치 정합 오류를 최소화했다.

• 566쪽, 본문 밑에서 6번째 줄

  Mask R-CNN은 객체 인스턴스 단위로 분할하여

  ==>

  Mask R-CNN은 객체별 개별 마스크를 예측하여

• 573쪽, 본문 9번째 줄

  (Positive ROI)에 대해서만 계산하며, 배경 ROI를 의미하는

  ==>

  (Positive RoI)에 대해서만 계산하며, 배경 RoI를 의미하는

• 576쪽, 예제 코드의 첫 번째 줄

  image_path = os.path.join(self.iamge_path, file_name)

  ==>

  image_path = os.path.join(self.image_path, file_name)

• 581쪽, 수식 9.17을 다음 수식으로 교체

  $$ {\text {IoU}}(P, G) = \frac{P \cap G}{P \cup G} $$

• 584쪽, 본문 5번째 줄

  YOLOv2는 2016년에 발표됐으며

  ==>

  YOLOv2는 2017년에 발표됐으며

• 584쪽, 그림 9.24를 다음 그림으로 교체

  

• 584쪽, 본문 밑에서 2번째 줄을 교체하고 각주 내용을 추가

  특징 맵을 4개로 분할하고 마지막 차원을 기준으로 재결합하는 방법을 사용했다.

  ==>

  패스스루(passthrough)^(각주) 계층을 사용해 고해상도 특징 맵을 저해상도 특징 맵과 결합함으로써 작은 물체에 대한 검출 성능을 향상시켰다.

  ---

  ^(각주) 패스스루: 고해상도 특징 맵 정보를 저해상도 맵에 결합하여 작은 객체 검출 성능을 향상시키는 데 사용되는 계층

• 586쪽, 본문 밑에서 3번째 줄

  특징 맵 간의 결합을 덧셈이 아닌 채널 단위로 수행해 더욱 효율적으로 정보를 전달한다. PAN은 Mask R-CNN에서도 사용되는 기술로 YOLOv4에 적용해 높은 검출 정확도와 성능을 보장한다.

  ==>

  특징 맵의 정보가 역방향으로도 원활히 전달되도록 상향식 경로 확장(Bottom-Up Path Augmentation)을 결합하여 다양한 크기의 객체에 대한 탐지 성능을 향상시킨다. PAN은 PANet에서 처음 제안된 기술로 YOLOv4에 적용해 높은 검출 정확도와 성능을 보장한다.

• 587쪽, 본문 4번째 줄

  모자이크 합성을 수행하면 이미지의 크기가 줄어들기 때문에 작은 객체 데이터를 효과적으로 수집할 수 있다.

  ==>

  모자이크 합성을 수행하면 다양한 배경과 위치에서 객체를 학습할 수 있어 데이터의 다양성을 높이고, 작은 객체에 대한 인식 성능을 개선할 수 있다.

• 587쪽, 본문 밑에서 5번째 줄

  YOLOv5는 YOLOv4의 모델 구조를 유지하고 파이토치 라이브러리로 이식하고 세부 사항을 조정했다.

  ==>

  YOLOv5는 YOLOv4와 마찬가지로 CSPNet 기반 백본을 사용하며, 파이토치 라이브러리로 개발되어 모델 성능과 추론 속도 향상을 위한 다양한 최적화 기법이 적용됐다.

• 588쪽, 본문 밑에서 2번째 줄

  모델 학습 시 여러 방향으로 순전파가 진행되며, 모델 추론 시 한 방향으로만 순전파가 진행된다.

  ==>

  모델 학습 시 여러 분기 구조로 다양한 특징을 학습하며, 모델 추론 시 모든 분기를 단일 합성곱 계층으로 결합해 단순화된 순전파를 진행한다.

• 590쪽, 본문 첫 번째 줄

  RepConv 잔차 연결의 연결선을 보면 항등 매핑으로 인해 첫 번째 특징 맵의 정보에 대해 덧셈 연산이 두 번 수행된다. 반대로 RepConvN 잔차 연결은 중복이 발생하지 않고 연산이 한 번만 수행되는 것을 확인할 수 있다.

  또한, YOLOv7은 학습 방법을 변경해 모델의 최종 출력인 주 출력(Lead Head)과 학습을 보조하는 보조 출력(Auxiliary Head)을 따로 구성한다.

  ==>

  그림 9.31의 좌측 이미지에서 RepConv의 연결선을 살펴보면, 첫 번째 특징 맵에서 항등 매핑과 잔차 연결을 통해 두 번의 덧셈 연산이 수행된다. 이로 인해 첫 번째 특징 맵에 대해 동일한 덧셈 연산에 대한 역전파가 두 번 발생한다. 그러므로 RepConv의 잔차 연결과 같은 구조는 학습 과정에서 불필요한 중복 역전파를 유발할 수 있다. 반면, 우측 이미지의 RepConvN 잔차 연결은 중복 없이 한 번만 연산이 수행되는 것을 확인할 수 있다.

  또한, YOLOv7은 모델 성능을 개선하기 위해 주 출력과 보조 출력(Auxiliary Head)을 따로 구성하여 학습을 진행한다.

• 601쪽, 본문 4번째 줄

  합성곱 계층 방법을 사용하지 않고 트랜스포머 모델에서 사용되는 셀프 어텐션을 적용한다.

  ==>

  합성곱 계층 방법을 최소화하고 트랜스포머 모델에서 사용되는 셀프 어텐션을 적용한다.

• 601쪽, 본문 6번째 줄

  ViT는 셀프 어텐션을 사용해 전체 이미지를 한 번에 처리하는 방식으로 구현됐다.

  ==>

  ViT는 이미지를 패치 단위로 분할하고, 셀프 어텐션을 사용해 전체 이미지의 관계를 학습하는 방식으로 구현됐다.

• 604쪽, 본문 3번째 줄

  합성곱 신경망의 임베딩은 이미지 패치 중 일부만 선택하여 학습하며, 이를 통해 이미지 전체의 특징을 추출한다.

  예를 들어, 고양이의 이미지에서 왼쪽 눈의 특징을 추출하고자 한다면 합성곱 신경망은 이미지에서 해당 부분만 선택해 학습한다.

  ==>

  합성곱 신경망은 이미지 전체를 훑으며 지역적인 특징을 추출하고, 이를 통해 이미지 전체의 특징을 표현하는 임베딩을 생성한다.

  예를 들어, 고양이의 이미지에서 왼쪽 눈의 특징을 추출하고자 한다면 합성곱 신경망은 왼쪽 눈 주변 영역을 훑으며 특징을 추출한다.

• 605쪽, 본문 2번째 줄

  트랜스포머 모델은 어텐션 거리(Attention Distance)2를 계산하여 오직 한 개의 ViT 레이어로 전체 이미지 정보를 쉽게 표현할 수 있다.

  ==>

  트랜스포머 모델은 어텐션 거리(Attention Distance)를 계산하여 이미지 내 모든 패치 간의 관계를 학습하고, 이를 통해 전체 이미지 정보를 표현한다. 따라서 좁은 수용 영역을 가진 합성곱 신경망에 비해 더 적은 수의 ViT 계층으로도 전체 이미지 정보를 효과적으로 표현할 수 있다.

• 606쪽, 그림 10.4를 다음 그림으로 교체

  

• 607쪽, 본문 5번째 줄

  이때 합성곱 신경망의 계층을 활용한다.

  ==>

  이때 이미지 패치를 선형 투영(Linear Projection)하여 벡터 형태로 변환한다.

• 607쪽, 수식 10.1을 다음 수식으로 교체

  $$ \mathrm{patch\ size}=\frac{\mathrm{image\ size}-\mathrm{kernel\ size}}{\mathrm{stride}} + 1 = \frac{9-3}{3} + 1 = 3 $$

• 608쪽, 본문 9번째 줄

  N개의 인코더 레이어를 반복적으로 적용한 후, 마지막 레이어에서는

  ==>

  N개의 인코더 계층을 반복적으로 적용한 후, 마지막 계층에서는

• 614쪽, 본문 5번째 줄

  ViT 모델을 미세 조정할 수 있지만,

  ==>

  ViT 모델을 미세 조정할 수도 있지만,

• 615쪽, 본문 7번째 줄

  수행한다면 $ \frac{(224 - 4)}{4} + 1 = 14 $이므로

  ==>

  수행한다면 $ \frac{(224 - 16)}{16} + 1 = 14 $이므로

• 624쪽, 본문 4번째 줄

  기존 트랜스포머를 기반으로

  ==>

  기존 ViT를 기반으로

• 624쪽, 본문 7번째 줄

  또한 트랜스포머의 셀프 어텐션은

  ==>

  또한 ViT의 셀프 어텐션은

• 624쪽, 본문 밑에서 2번째 줄

  이미지의 공간 정보가 완전히 보존되지 않을 수 있다.

  ==>

  패치 내의 세부적인 공간 정보가 손실될 수 있다.

• 625쪽, 본문 밑에서 4번째 줄

  스윈 트랜스포머는 로컬 윈도를 통해 계층마다 어텐션이 되는 패치의 크기와 개수를 계층적으로 다양하게 적용한다.

  ==>

  스윈 트랜스포머는 로컬 윈도를 사용하여 각 계층에서 어텐션이 적용되는 패치의 크기와 개수를 다양하게 구성함으로써 계층적인 특징 학습을 가능하게 한다.

• 630쪽, 본문 4번째 줄

  그러나 W-MSA 방식은 효율적인 배치 계산(Effieient Batch Computation)을 통해 연산량을 대폭 감소시켰다.

  이렇게 함으로써, 로컬 윈도에서 연산을 수행하는 과정에서도 배치 축을 사용할 수 있어서 연산 속도가 빨라지게 된다. 이를 통해 자연어 처리 작업에서 높은 성능을 보일 수 있게 됐다.

  SW-MSA 방식은 로컬 윈도 간의 셀프 어텐션을 수행하기 위해 W-MSA에서 사용된 로컬 윈도 개수가 많아 더 많은 셀프 어텐션 연산을 요구한다.

  ==>

  그러나 W-MSA 방식은 윈도우 내부에서의 병렬 연산을 통해 효율성을 높여 연산량을 대폭 감소시켰다. 로컬 윈도에서 병렬적으로 연산을 수행함으로써 전체 계산 속도를 향상시킨다. 스윈 트랜스포머는 이러한 효율적인 연산 방식을 통해 이미지 처리 작업에서 높은 성능을 보인다.

  SW-MSA 방식은 시프트된 윈도우 구성으로 인해 W-MSA보다 더 많은 셀프 어텐션 연산을 요구한다.

• 631쪽, 본문 3번째 줄

  이때, 이동된 위치에서 연산을 수행하지 않도록 어텐션 마스크를 사용해 방지한다.

  ==>

  이때, 순환 시프트로 인해 분리된 영역에서 발생하는 잘못된 연결을 방지하기 위해 어텐션 마스크를 사용한다.

• 634쪽, 본문 밑에서 3번째 줄

  j번째 패치의 어텐션 값에

  ==>

  j번째 패치까지 어텐션 값에

• 634쪽, 수식 10.2를 다음 수식으로 교체

  $$ \mathrm{Attention}(Q, K, V) = \mathrm{Softmax}(QK^T / \sqrt{d} + B) V $$

• 645쪽, 본문 밑에서 4번째 줄

  전체 정보를 학습했다.

  ==>

  전체 정보를 학습한다.

• 648쪽, 그림 10.16을 다음 그림으로 교체

  

• 663쪽, 본문 첫 번째 줄

  중요도에 상관없이 제거하는 방식이기 때문에

  ==>

  중요도를 고려하여 제거하는 방식이기 때문에

• 666쪽, 본문 4번째 줄

  인코더 레이어의

  ==>

  인코더 계층의

• 670쪽, 예제 코드의 5번째 줄

  std=[1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0],

  ==>

  std=[0.229, 0.224, 0.225],

• 670쪽, 예제 코드의 22~30번째 줄을 다음 코드로 교체(calibartion 표기 변경)

  calibration_dataset = ImageFolder(
      "../datasets/pet/test",
      transform=hyperparams["transform"]
  )
  calibration_dataloader = DataLoader(
      calibration_dataset,
      batch_size=hyperparams["batch_size"]
  )
  for i, (images, target) in enumerate(calibration_dataloader):

• 673쪽, 예제 코드의 첫 번째 줄

  std=[1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0],

  ==>

  std=[0.229, 0.224, 0.225],

• 680쪽, 본문 5번째 줄

  소프트맥스 함수는 입력값의 크기에 따라 출력값을 조절하는 특성을 가지며, 작은 값은 더 작게, 큰 값은 더 크게 만든다.

  ==>

  소프트맥스 함수는 입력값을 지수 함수로 변환하여 전체 입력값에 대한 확률 분포를 생성하며, 상대적으로 큰 입력값에 더 높은 확률을 할당하는 특성을 가진다.

• 680쪽, 본문 11번째 줄

  0 이상의 값을 사용한다.

  ==>

  0보다 큰 양수 값만 사용한다.

• 680쪽, 본문 밑에서 7번째 줄

  온도가 높을수록 학생 신경망의 성능이 향상되지만, 너무 높으면 학생 신경망이 학습되지 않을 수 있다.

  ==>

  온도가 높아지면 소프트맥스 출력값이 평탄해져 다양한 클래스 정보를 더 균등하게 학습할 수 있으나, 너무 높을 경우 학습이 비효율적으로 될 수 있다.

• 696쪽, 예제 코드의 밑에서 12번째 줄

  std=[1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0],

  ==>

  std=[0.229, 0.224, 0.225],

• 708쪽, 예제 코드의 6번째 줄

  std=[1.0 / 255.0, 1.0 / 255.0, 1.0 / 255.0],

  ==>

  std=[0.229, 0.224, 0.225],

• 751쪽, 본문 밑에서 5번째 줄

  mindsKR 데이터셋의

  ==>

  mindsKR 데이터세트의

• 751쪽, 본문 밑에서 4번째 줄

  벡터로 변환해

  ==>

  벡터로 변환하고, 이를