diff --git a/chapter_computer-vision/fcn.md b/chapter_computer-vision/fcn.md
index ae366b8b..f46a9190 100644
--- a/chapter_computer-vision/fcn.md
+++ b/chapter_computer-vision/fcn.md
@@ -24,7 +24,7 @@ from torch.nn import functional as F
 
 ## 더 모델
 
-여기서는 완전 컨벌루션 네트워크 모델의 기본 설계에 대해 설명합니다.:numref:`fig_fcn`에서 볼 수 있듯이 이 모델은 먼저 CNN을 사용하여 이미지 특징을 추출한 다음 $1\times 1$ 컨벌루션 계층을 통해 채널 수를 클래스 수로 변환한 다음 마지막으로 도입된 전치된 컨벌루션을 통해 특징 맵의 높이와 너비를 입력 이미지의 높이와 너비로 변환합니다.:numref:`sec_transposed_conv`년에 있습니다.결과적으로 모델 출력값은 입력 영상과 높이와 너비가 동일하며, 여기서 출력 채널에는 동일한 공간 위치에 있는 입력 픽셀에 대한 예측된 클래스가 포함됩니다. 
+여기서는 완전 컨벌루션 네트워크 모델의 기본 설계에 대해 설명합니다.:numref:`fig_fcn`에서 볼 수 있듯이 이 모델은 먼저 CNN을 사용하여 이미지 특징을 추출한 다음 $1\times 1$ 컨벌루션 계층을 통해 채널 수를 클래스 수로 변환한 다음 마지막으로 도입된 전치된 컨벌루션을 통해 특징 맵의 높이와 너비를 입력 이미지의 높이와 너비로 변환합니다.:numref:`sec_transposed_conv`년에 있습니다.결과적으로 모델 출력값은 입력 영상과 높이와 너비가 동일하며, 여기서 출력 채널에는 동일한 공간 위치에 있는 입력 픽셀에 대한 예측된 클래스가 포함됩니다.
 
 ![Fully convolutional network.](../img/fcn.svg)
 :label:`fig_fcn`
@@ -68,7 +68,7 @@ X = torch.rand(size=(1, 3, 320, 480))
 net(X).shape
 ```
 
-다음으로 출력 채널 수를 Pascal VOC2012 데이터 세트의 클래스 수 (21) 로 변환하기 위해 $1\times 1$ 컨벌루션 계층을 사용합니다.**] 마지막으로, 입력 이미지의 높이와 너비로 다시 변경하려면 (**특징 맵의 높이와 너비를 32 배 증가**) 해야합니다.:numref:`sec_padding`에서 컨벌루션 계층의 출력 형상을 계산하는 방법을 생각해 보십시오.$(320-64+16\times2+32)/32=10$과 $(480-64+16\times2+32)/32=15$부터 보폭이 $32$인 전치된 컨벌루션 계층을 구성하여 커널의 높이와 너비를 $64$로 설정하고 패딩을 $16$로 설정합니다.일반적으로 스트라이드 $s$, 패딩 $s/2$ ($s/2$이 정수라고 가정) 및 커널 $2s$의 높이와 너비에 대해 전치된 컨벌루션이 입력값의 높이와 너비를 $s$배 증가시킨다는 것을 알 수 있습니다.
+다음으로 출력 채널 수를 Pascal VOC2012 데이터 세트의 클래스 수 (21) 로 변환하기 위해 $1\times 1$ 컨벌루션 계층을 사용합니다. 마지막으로, 입력 이미지의 높이와 너비로 다시 변경하려면 (**특징 맵의 높이와 너비를 32 배 증가**) 해야합니다.:numref:`sec_padding`에서 컨벌루션 계층의 출력 형상을 계산하는 방법을 생각해 보십시오.$(320-64+16\times2+32)/32=10$과 $(480-64+16\times2+32)/32=15$부터 보폭이 $32$인 전치된 컨벌루션 계층을 구성하여 커널의 높이와 너비를 $64$로 설정하고 패딩을 $16$로 설정합니다.일반적으로 스트라이드 $s$, 패딩 $s/2$ ($s/2$이 정수라고 가정) 및 커널 $2s$의 높이와 너비에 대해 전치된 컨벌루션이 입력값의 높이와 너비를 $s$배 증가시킨다는 것을 알 수 있습니다.
 
 ```{.python .input}
 num_classes = 21
@@ -89,9 +89,9 @@ net.add_module('transpose_conv', nn.ConvTranspose2d(num_classes, num_classes,
 
 우리는 전치된 컨벌루션 계층이 특징 맵의 높이와 너비를 증가시킬 수 있다는 것을 이미 알고 있습니다.이미지 처리에서 이미지를 확장해야 할 수도 있습니다 (예: *업샘플링*).
 *쌍선형 보간*
-일반적으로 사용되는 업샘플링 기법 중 하나입니다.또한 전치된 컨벌루션 계층을 초기화하는 데에도 자주 사용됩니다. 
+일반적으로 사용되는 업샘플링 기법 중 하나입니다.또한 전치된 컨벌루션 계층을 초기화하는 데에도 자주 사용됩니다.
 
-쌍선형 보간을 설명하기 위해 입력 영상이 주어지면 업샘플링된 출력 영상의 각 픽셀을 계산하려고 한다고 가정해 보겠습니다.좌표 $(x, y)$에서 출력 이미지의 픽셀을 계산하려면 먼저 $(x, y)$를 입력 이미지에 좌표 $(x', y')$로 매핑합니다. 예를 들어 입력 크기와 출력 크기의 비율에 따라 매핑합니다.매핑된 $x'$ and $y'$는 실수입니다.그런 다음 입력 영상에서 좌표 $(x', y')$에 가장 가까운 4개의 픽셀을 찾습니다.마지막으로, 좌표 $(x, y)$에서 출력 이미지의 픽셀은 입력 이미지 상의 이들 4개의 가장 가까운 픽셀과 $(x', y')$로부터의 상대적 거리에 기초하여 계산된다.  
+쌍선형 보간을 설명하기 위해 입력 영상이 주어지면 업샘플링된 출력 영상의 각 픽셀을 계산하려고 한다고 가정해 보겠습니다.좌표 $(x, y)$에서 출력 이미지의 픽셀을 계산하려면 먼저 $(x, y)$를 입력 이미지에 좌표 $(x', y')$로 매핑합니다. 예를 들어 입력 크기와 출력 크기의 비율에 따라 매핑합니다.매핑된 $x'$ and $y'$는 실수입니다.그런 다음 입력 영상에서 좌표 $(x', y')$에 가장 가까운 4개의 픽셀을 찾습니다.마지막으로, 좌표 $(x, y)$에서 출력 이미지의 픽셀은 입력 이미지 상의 이들 4개의 가장 가까운 픽셀과 $(x', y')$로부터의 상대적 거리에 기초하여 계산된다.
 
 쌍선형 보간의 업샘플링은 다음 `bilinear_kernel` 함수로 구성된 커널을 사용하여 전치된 컨벌루션 계층에 의해 구현될 수 있습니다.공간 제약으로 인해 알고리즘 설계에 대한 논의 없이 아래 `bilinear_kernel` 함수의 구현만 제공합니다.
 
@@ -179,7 +179,7 @@ print('output image shape:', out_img.shape)
 d2l.plt.imshow(out_img);
 ```
 
-완전 컨벌루션 네트워크에서는 쌍선형 보간의 업샘플링을 사용하여 전치된 컨벌루션 계층을 초기화합니다.$1\times 1$ 컨벌루션 계층의 경우 자비에르 초기화를 사용합니다.**]
+완전 컨벌루션 네트워크에서는 쌍선형 보간의 업샘플링을 사용하여 전치된 컨벌루션 계층을 초기화합니다.$1\times 1$ 컨벌루션 계층의 경우 자비에르 초기화를 사용합니다.
 
 ```{.python .input}
 W = bilinear_kernel(num_classes, num_classes, 64)
@@ -263,7 +263,7 @@ def label2image(pred):
     return colormap[X, :]
 ```
 
-테스트 데이터셋의 이미지는 크기와 모양이 다양합니다.이 모델은 스트라이드가 32인 전치된 컨벌루션 계층을 사용하므로 입력 영상의 높이 또는 너비를 32로 나눌 수 없는 경우 전치된 컨벌루션 계층의 출력 높이 또는 너비는 입력 영상의 모양에서 벗어납니다.이 문제를 해결하기 위해 이미지에서 높이와 너비가 32의 정수 배수 인 여러 직사각형 영역을 자르고 이러한 영역의 픽셀에 대해 개별적으로 순방향 전파를 수행 할 수 있습니다.이러한 직사각형 영역의 합집합은 입력 이미지를 완전히 덮어야 합니다.픽셀이 여러 직사각형 영역으로 덮여 있는 경우 동일한 픽셀에 대해 별도의 영역에 있는 전치된 컨벌루션 출력의 평균을 softmax 연산에 입력하여 클래스를 예측할 수 있습니다. 
+테스트 데이터셋의 이미지는 크기와 모양이 다양합니다.이 모델은 스트라이드가 32인 전치된 컨벌루션 계층을 사용하므로 입력 영상의 높이 또는 너비를 32로 나눌 수 없는 경우 전치된 컨벌루션 계층의 출력 높이 또는 너비는 입력 영상의 모양에서 벗어납니다.이 문제를 해결하기 위해 이미지에서 높이와 너비가 32의 정수 배수 인 여러 직사각형 영역을 자르고 이러한 영역의 픽셀에 대해 개별적으로 순방향 전파를 수행 할 수 있습니다.이러한 직사각형 영역의 합집합은 입력 이미지를 완전히 덮어야 합니다.픽셀이 여러 직사각형 영역으로 덮여 있는 경우 동일한 픽셀에 대해 별도의 영역에 있는 전치된 컨벌루션 출력의 평균을 softmax 연산에 입력하여 클래스를 예측할 수 있습니다.
 
 간단하게하기 위해 몇 개의 큰 테스트 이미지만 읽고 이미지의 왼쪽 상단에서 시작하여 예측을 위해 $320\times480$ 영역을 자릅니다.이러한 테스트 이미지의 경우 잘린 영역, 예측 결과 및 지상 진실을 행별로 인쇄합니다.
 
diff --git a/chapter_computer-vision/kaggle-cifar10.md b/chapter_computer-vision/kaggle-cifar10.md
index cdba95eb..5383ebb9 100644
--- a/chapter_computer-vision/kaggle-cifar10.md
+++ b/chapter_computer-vision/kaggle-cifar10.md
@@ -1,11 +1,11 @@
 # 카글의 이미지 분류 (CIFAR-10)
 :label:`sec_kaggle_cifar10`
 
-지금까지 딥 러닝 프레임워크의 상위 수준 API를 사용하여 텐서 형식의 이미지 데이터 세트를 직접 얻었습니다.그러나 사용자 지정 이미지 데이터셋은 이미지 파일 형태로 제공되는 경우가 많습니다.이 섹션에서는 원시 이미지 파일부터 시작하여 단계별로 구성, 읽기 및 텐서 형식으로 변환합니다. 
+지금까지 딥 러닝 프레임워크의 상위 수준 API를 사용하여 텐서 형식의 이미지 데이터 세트를 직접 얻었습니다.그러나 사용자 지정 이미지 데이터셋은 이미지 파일 형태로 제공되는 경우가 많습니다.이 섹션에서는 원시 이미지 파일부터 시작하여 단계별로 구성, 읽기 및 텐서 형식으로 변환합니다.
 
-우리는 컴퓨터 비전에서 중요한 데이터셋인 :numref:`sec_image_augmentation`의 CIFAR-10 데이터세트를 실험했습니다.이 섹션에서는 이전 섹션에서 배운 지식을 적용하여 CIFAR-10 이미지 분류의 Kaggle 경쟁을 연습합니다.(**대회의 웹 주소는 https://www.kaggle.com/c/cifar-10 **입니다) 
+우리는 컴퓨터 비전에서 중요한 데이터셋인 :numref:`sec_image_augmentation`의 CIFAR-10 데이터세트를 실험했습니다.이 섹션에서는 이전 섹션에서 배운 지식을 적용하여 CIFAR-10 이미지 분류의 Kaggle 경쟁을 연습합니다.(**대회의 웹 주소는 https://www.kaggle.com/c/cifar-10 입니다**)
 
-:numref:`fig_kaggle_cifar10`는 대회 웹 페이지의 정보를 보여줍니다.결과를 제출하려면 Kaggle 계정을 등록해야 합니다. 
+:numref:`fig_kaggle_cifar10`는 대회 웹 페이지의 정보를 보여줍니다.결과를 제출하려면 Kaggle 계정을 등록해야 합니다.
 
 ![CIFAR-10 image classification competition webpage information. The competition dataset can be obtained by clicking the "Data" tab.](../img/kaggle-cifar10.png)
 :width:`600px`
@@ -41,18 +41,18 @@ import shutil
 
 경쟁 데이터셋은 훈련 세트와 테스트 세트로 나뉘며, 여기에는 각각 50000개 및 300,000개의 이미지가 포함되어 있습니다.테스트 세트에서는 10000개의 이미지가 평가에 사용되고 나머지 290000 개의 이미지는 평가되지 않습니다. 속임수를 쓰기 어렵게 만들기 위해 포함됩니다.
 *테스트 세트의 결과가 수동으로* 표시됩니다.
-이 데이터셋의 이미지는 모두 png 색상 (RGB 채널) 이미지 파일이며 높이와 너비는 모두 32픽셀입니다.이미지는 비행기, 자동차, 새, 고양이, 사슴, 개, 개구리, 말, 보트 및 트럭과 같은 총 10 개의 범주를 포함합니다.:numref:`fig_kaggle_cifar10`의 왼쪽 상단 모서리에는 데이터셋에 있는 비행기, 자동차 및 새의 일부 이미지가 표시됩니다. 
+이 데이터셋의 이미지는 모두 png 색상 (RGB 채널) 이미지 파일이며 높이와 너비는 모두 32픽셀입니다.이미지는 비행기, 자동차, 새, 고양이, 사슴, 개, 개구리, 말, 보트 및 트럭과 같은 총 10 개의 범주를 포함합니다.:numref:`fig_kaggle_cifar10`의 왼쪽 상단 모서리에는 데이터셋에 있는 비행기, 자동차 및 새의 일부 이미지가 표시됩니다.
 
 ### 데이터세트 다운로드
 
-Kaggle에 로그인 한 후 :numref:`fig_kaggle_cifar10`에 표시된 CIFAR-10 이미지 분류 경쟁 웹 페이지에서 “데이터”탭을 클릭하고 “모두 다운로드”버튼을 클릭하여 데이터 세트를 다운로드 할 수 있습니다.`../data`에서 다운로드한 파일의 압축을 풀고 그 안에 `train.7z` 및 `test.7z`의 압축을 풀면 다음 경로에서 전체 데이터 세트를 찾을 수 있습니다. 
+Kaggle에 로그인 한 후 :numref:`fig_kaggle_cifar10`에 표시된 CIFAR-10 이미지 분류 경쟁 웹 페이지에서 “데이터”탭을 클릭하고 “모두 다운로드”버튼을 클릭하여 데이터 세트를 다운로드 할 수 있습니다.`../data`에서 다운로드한 파일의 압축을 풀고 그 안에 `train.7z` 및 `test.7z`의 압축을 풀면 다음 경로에서 전체 데이터 세트를 찾을 수 있습니다.
 
 * `../data/cifar-10/train/[1-50000].png`
 * `../data/cifar-10/test/[1-300000].png`
 * `../data/cifar-10/trainLabels.csv`
 * `../data/cifar-10/sampleSubmission.csv`
 
-여기서 `train` 및 `test` 디렉토리에는 각각 교육 및 테스트 이미지가 포함되어 있습니다. `trainLabels.csv`은 교육 이미지에 대한 레이블을 제공하고 `sample_submission.csv`은 샘플 제출 파일입니다. 
+여기서 `train` 및 `test` 디렉토리에는 각각 교육 및 테스트 이미지가 포함되어 있습니다. `trainLabels.csv`은 교육 이미지에 대한 레이블을 제공하고 `sample_submission.csv`은 샘플 제출 파일입니다.
 
 더 쉽게 시작할 수 있도록 [**처음 1000개의 훈련 이미지와 5개의 무작위 테스트 이미지가 포함된 데이터세트의 소규모 샘플을 제공합니다.**] Kaggle 경쟁의 전체 데이터세트를 사용하려면 다음 `demo` 변수를 `False`로 설정해야 합니다.
 
@@ -486,7 +486,7 @@ df['label'] = df['label'].apply(lambda x: train_valid_ds.classes[x])
 df.to_csv('submission.csv', index=False)
 ```
 
-위의 코드는 `submission.csv` 파일을 생성하며, 이 파일의 형식은 Kaggle 경쟁사의 요구 사항을 충족합니다.결과를 Kaggle에 제출하는 방법은 :numref:`sec_kaggle_house`의 방법과 유사합니다. 
+위의 코드는 `submission.csv` 파일을 생성하며, 이 파일의 형식은 Kaggle 경쟁사의 요구 사항을 충족합니다.결과를 Kaggle에 제출하는 방법은 :numref:`sec_kaggle_house`의 방법과 유사합니다.
 
 ## 요약
 
diff --git a/chapter_computer-vision/multiscale-object-detection.md b/chapter_computer-vision/multiscale-object-detection.md
index b92c6a11..8e0615b3 100644
--- a/chapter_computer-vision/multiscale-object-detection.md
+++ b/chapter_computer-vision/multiscale-object-detection.md
@@ -1,12 +1,12 @@
 # 멀티스케일 객체 감지
 :label:`sec_multiscale-object-detection`
 
-:numref:`sec_anchor`에서는 입력 이미지의 각 픽셀을 중심으로 여러 앵커 상자를 생성했습니다.기본적으로 이러한 앵커 박스는 이미지의 여러 영역의 샘플을 나타냅니다.그러나*모든* 픽셀에 대해 생성되는 경우 앵커 박스가 너무 많아 계산할 수 없습니다.$561 \times 728$ 입력 이미지를 생각해 보십시오.각 픽셀을 중심으로 다양한 모양을 가진 다섯 개의 앵커 박스가 생성되면 이미지에서 2백만 개가 넘는 앵커 박스 ($561 \times 728 \times 5$) 에 레이블을 지정하고 예측해야 합니다. 
+:numref:`sec_anchor`에서는 입력 이미지의 각 픽셀을 중심으로 여러 앵커 상자를 생성했습니다.기본적으로 이러한 앵커 박스는 이미지의 여러 영역의 샘플을 나타냅니다.그러나*모든* 픽셀에 대해 생성되는 경우 앵커 박스가 너무 많아 계산할 수 없습니다.$561 \times 728$ 입력 이미지를 생각해 보십시오.각 픽셀을 중심으로 다양한 모양을 가진 다섯 개의 앵커 박스가 생성되면 이미지에서 2백만 개가 넘는 앵커 박스 ($561 \times 728 \times 5$) 에 레이블을 지정하고 예측해야 합니다.
 
 ## 멀티스케일 앵커 박스
 :label:`subsec_multiscale-anchor-boxes`
 
-이미지에서 앵커 상자를 줄이는 것이 어렵지 않다는 것을 알 수 있습니다.예를 들어 입력 이미지에서 픽셀의 작은 부분을 균일하게 샘플링하여 중앙에 앵커 박스를 생성 할 수 있습니다.또한 다양한 축척에서 크기가 다른 여러 앵커 상자를 생성 할 수 있습니다.직관적으로 작은 물체는 큰 물체보다 이미지에 나타날 가능성이 더 큽니다.예를 들어 $1 \times 1$, $1 \times 2$ 및 $2 \times 2$ 객체는 $2 \times 2$ 이미지에 각각 4, 2 및 1개의 가능한 방식으로 나타날 수 있습니다.따라서 작은 앵커 박스를 사용하여 더 작은 물체를 감지하면 더 많은 영역을 샘플링할 수 있고, 큰 객체의 경우 더 적은 영역을 샘플링할 수 있습니다. 
+이미지에서 앵커 상자를 줄이는 것이 어렵지 않다는 것을 알 수 있습니다.예를 들어 입력 이미지에서 픽셀의 작은 부분을 균일하게 샘플링하여 중앙에 앵커 박스를 생성 할 수 있습니다.또한 다양한 축척에서 크기가 다른 여러 앵커 상자를 생성 할 수 있습니다.직관적으로 작은 물체는 큰 물체보다 이미지에 나타날 가능성이 더 큽니다.예를 들어 $1 \times 1$, $1 \times 2$ 및 $2 \times 2$ 객체는 $2 \times 2$ 이미지에 각각 4, 2 및 1개의 가능한 방식으로 나타날 수 있습니다.따라서 작은 앵커 박스를 사용하여 더 작은 물체를 감지하면 더 많은 영역을 샘플링할 수 있고, 큰 객체의 경우 더 적은 영역을 샘플링할 수 있습니다.
 
 여러 스케일로 앵커 박스를 생성하는 방법을 보여주기 위해 이미지를 읽어 보겠습니다.높이와 너비는 각각 561픽셀과 728픽셀입니다.
 
@@ -33,9 +33,9 @@ h, w = img.shape[:2]
 h, w
 ```
 
-:numref:`sec_conv_layer`에서는 컨벌루션 계층의 2차원 배열 출력값을 특징 맵이라고 부릅니다.특징 맵 모양을 정의하여 모든 이미지에서 균일하게 샘플링된 앵커 박스의 중심을 결정할 수 있습니다. 
+:numref:`sec_conv_layer`에서는 컨벌루션 계층의 2차원 배열 출력값을 특징 맵이라고 부릅니다.특징 맵 모양을 정의하여 모든 이미지에서 균일하게 샘플링된 앵커 박스의 중심을 결정할 수 있습니다.
 
-`display_anchors` 함수는 아래에 정의되어 있습니다.[**각 단위 (픽셀) 를 앵커 상자 중심으로 사용하여 형상 맵 (`fmap`) 에 앵커 박스 (`anchors`) 를 생성합니다.**] 앵커 박스 (`anchors`) 의 $(x, y)$축 좌표 값을 형상 맵 (`fmap`) 의 너비와 높이로 나눠졌기 때문에 이 값은 0과 1 사이입니다.피처 맵에서 앵커 박스의 상대적 위치를 나타냅니다. 
+`display_anchors` 함수는 아래에 정의되어 있습니다.[**각 단위 (픽셀) 를 앵커 상자 중심으로 사용하여 형상 맵 (`fmap`) 에 앵커 박스 (`anchors`) 를 생성합니다.**] 앵커 박스 (`anchors`) 의 $(x, y)$축 좌표 값을 형상 맵 (`fmap`) 의 너비와 높이로 나눠졌기 때문에 이 값은 0과 1 사이입니다.피처 맵에서 앵커 박스의 상대적 위치를 나타냅니다.
 
 앵커 박스 (`anchors`) 의 중심이 특징 맵 (`fmap`) 의 모든 유닛에 분산되어 있기 때문에 이러한 중심은 상대 공간 위치의 관점에서 임의의 입력 이미지에*균일하게* 분포되어야 합니다.보다 구체적으로, 특징 맵 `fmap_w` 및 `fmap_h`의 너비와 높이를 각각 고려할 때 다음 함수는 모든 입력 이미지에서 `fmap_h` 행과 `fmap_w` 열의 픽셀을 샘플링합니다*.균일하게 샘플링된 픽셀을 중심으로 `s` (목록 `s`의 길이가 1이라고 가정) 및 다른 종횡비 (`ratios`) 의 앵커 상자가 생성됩니다.
 
@@ -76,7 +76,7 @@ display_anchors(fmap_w=4, fmap_h=4, s=[0.15])
 display_anchors(fmap_w=2, fmap_h=2, s=[0.4])
 ```
 
-마지막으로 [**피처 맵의 높이와 너비를 절반으로 줄이고 앵커 박스 스케일을 0.8**로 늘립니다].이제 앵커 박스의 중심이 이미지의 중심입니다.
+마지막으로 [**피처 맵의 높이와 너비를 절반으로 줄이고 앵커 박스 스케일을 0.8로 늘립니다**].이제 앵커 박스의 중심이 이미지의 중심입니다.
 
 ```{.python .input}
 #@tab all
@@ -85,15 +85,15 @@ display_anchors(fmap_w=1, fmap_h=1, s=[0.8])
 
 ## 멀티스케일 감지
 
-다중 스케일 앵커 박스를 생성했기 때문에 다양한 스케일에서 다양한 크기의 물체를 감지하는 데 사용할 것입니다.다음에서는 :numref:`sec_ssd`에서 구현할 CNN 기반 다중 스케일 객체 감지 방법을 소개합니다. 
+다중 스케일 앵커 박스를 생성했기 때문에 다양한 스케일에서 다양한 크기의 물체를 감지하는 데 사용할 것입니다.다음에서는 :numref:`sec_ssd`에서 구현할 CNN 기반 다중 스케일 객체 감지 방법을 소개합니다.
 
-어떤 규모에서 $c$ 형상 $h \times w$의 특징 맵이 있다고 가정해 보겠습니다.:numref:`subsec_multiscale-anchor-boxes`의 방법을 사용하여 $hw$ 세트의 앵커 상자를 생성합니다. 여기서 각 세트에는 중심이 동일한 $a$ 앵커 상자가 있습니다.예를 들어, :numref:`subsec_multiscale-anchor-boxes`의 실험의 첫 번째 척도에서 10개 (채널 수) $4 \times 4$개의 피처 맵이 주어지면 16개의 앵커 박스 세트를 생성했습니다. 각 세트에는 중심이 같은 3개의 앵커 박스가 포함되어 있습니다.다음으로 각 앵커 박스에는 지상 실측 경계 상자를 기반으로 클래스 및 오프셋이 지정됩니다.현재 척도에서 객체 감지 모델은 입력 이미지에서 $hw$ 세트의 앵커 박스 클래스와 오프셋을 예측해야 합니다. 이 경우 세트마다 중심이 다릅니다. 
+어떤 규모에서 $c$ 형상 $h \times w$의 특징 맵이 있다고 가정해 보겠습니다.:numref:`subsec_multiscale-anchor-boxes`의 방법을 사용하여 $hw$ 세트의 앵커 상자를 생성합니다. 여기서 각 세트에는 중심이 동일한 $a$ 앵커 상자가 있습니다.예를 들어, :numref:`subsec_multiscale-anchor-boxes`의 실험의 첫 번째 척도에서 10개 (채널 수) $4 \times 4$개의 피처 맵이 주어지면 16개의 앵커 박스 세트를 생성했습니다. 각 세트에는 중심이 같은 3개의 앵커 박스가 포함되어 있습니다.다음으로 각 앵커 박스에는 지상 실측 경계 상자를 기반으로 클래스 및 오프셋이 지정됩니다.현재 척도에서 객체 감지 모델은 입력 이미지에서 $hw$ 세트의 앵커 박스 클래스와 오프셋을 예측해야 합니다. 이 경우 세트마다 중심이 다릅니다.
 
-여기서 $c$ 특징 맵은 입력 이미지를 기반으로 CNN 순방향 전파에 의해 얻어진 중간 출력이라고 가정합니다.각 특징 맵에는 $hw$개의 서로 다른 공간 위치가 있으므로 동일한 공간 위치는 $c$ 단위를 갖는 것으로 생각할 수 있습니다.:numref:`sec_conv_layer`의 수용장 정의에 따르면, 특징 맵의 동일한 공간 위치에있는 이러한 $c$ 단위는 입력 이미지에서 동일한 수용 필드를 갖습니다. 동일한 수용 필드에서 입력 이미지 정보를 나타냅니다.따라서 동일한 공간 위치에 있는 피쳐 맵의 $c$ 단위를 이 공간 위치를 사용하여 생성된 $a$ 앵커 박스의 클래스 및 오프셋으로 변환할 수 있습니다.본질적으로 특정 수용 필드에서 입력 이미지의 정보를 사용하여 입력 이미지의 수용 필드에 가까운 앵커 박스의 클래스와 오프셋을 예측합니다. 
+여기서 $c$ 특징 맵은 입력 이미지를 기반으로 CNN 순방향 전파에 의해 얻어진 중간 출력이라고 가정합니다.각 특징 맵에는 $hw$개의 서로 다른 공간 위치가 있으므로 동일한 공간 위치는 $c$ 단위를 갖는 것으로 생각할 수 있습니다.:numref:`sec_conv_layer`의 수용장 정의에 따르면, 특징 맵의 동일한 공간 위치에있는 이러한 $c$ 단위는 입력 이미지에서 동일한 수용 필드를 갖습니다. 동일한 수용 필드에서 입력 이미지 정보를 나타냅니다.따라서 동일한 공간 위치에 있는 피쳐 맵의 $c$ 단위를 이 공간 위치를 사용하여 생성된 $a$ 앵커 박스의 클래스 및 오프셋으로 변환할 수 있습니다.본질적으로 특정 수용 필드에서 입력 이미지의 정보를 사용하여 입력 이미지의 수용 필드에 가까운 앵커 박스의 클래스와 오프셋을 예측합니다.
 
-서로 다른 레이어의 특징 맵에 입력 영상에 다양한 크기의 수용 필드가 있는 경우 이 맵을 사용하여 다양한 크기의 객체를 탐지할 수 있습니다.예를 들어, 출력 계층에 더 가까운 특징 맵의 단위가 더 넓은 수용 필드를 가지므로 입력 이미지에서 더 큰 객체를 감지할 수 있는 신경망을 설계할 수 있습니다. 
+서로 다른 레이어의 특징 맵에 입력 영상에 다양한 크기의 수용 필드가 있는 경우 이 맵을 사용하여 다양한 크기의 객체를 탐지할 수 있습니다.예를 들어, 출력 계층에 더 가까운 특징 맵의 단위가 더 넓은 수용 필드를 가지므로 입력 이미지에서 더 큰 객체를 감지할 수 있는 신경망을 설계할 수 있습니다.
 
-간단히 말해서, 다중 스케일 객체 감지를 위해 심층 신경망에 의해 여러 수준에서 이미지의 계층 적 표현을 활용할 수 있습니다.:numref:`sec_ssd`의 구체적인 예를 통해 이것이 어떻게 작동하는지 보여 드리겠습니다. 
+간단히 말해서, 다중 스케일 객체 감지를 위해 심층 신경망에 의해 여러 수준에서 이미지의 계층 적 표현을 활용할 수 있습니다.:numref:`sec_ssd`의 구체적인 예를 통해 이것이 어떻게 작동하는지 보여 드리겠습니다.
 
 ## 요약
 
diff --git a/chapter_convolutional-modern/alexnet.md b/chapter_convolutional-modern/alexnet.md
index 997a1ccc..19259a30 100644
--- a/chapter_convolutional-modern/alexnet.md
+++ b/chapter_convolutional-modern/alexnet.md
@@ -1,78 +1,78 @@
 # 심층 컨벌루션 신경망 (AlexNet)
 :label:`sec_alexnet`
 
-CNN은 LeNet이 도입 된 후 컴퓨터 비전 및 기계 학습 커뮤니티에서 잘 알려져 있었지만 현장을 즉시 지배하지는 못했습니다.LeNet은 초기의 소규모 데이터 세트에서 좋은 결과를 얻었지만 더 크고 현실적인 데이터 세트에 대해 CNN을 훈련시키는 성능과 타당성은 아직 확립되지 않았습니다.실제로 1990 년대 초반과 2012 년 유역 결과 사이의 많은 시간 동안 신경망은 지원 벡터 기계와 같은 다른 기계 학습 방법보다 능가하는 경우가 많습니다. 
+CNN은 LeNet이 도입 된 후 컴퓨터 비전 및 기계 학습 커뮤니티에서 잘 알려져 있었지만 현장을 즉시 지배하지는 못했습니다.LeNet은 초기의 소규모 데이터 세트에서 좋은 결과를 얻었지만 더 크고 현실적인 데이터 세트에 대해 CNN을 훈련시키는 성능과 타당성은 아직 확립되지 않았습니다.실제로 1990 년대 초반과 2012 년 유역 결과 사이의 많은 시간 동안 신경망은 지원 벡터 기계와 같은 다른 기계 학습 방법보다 능가하는 경우가 많습니다.
 
-컴퓨터 비전의 경우 이러한 비교는 공정하지 않을 수 있습니다.즉, 컨벌루션 네트워크에 대한 입력은 원시 또는 가볍게 처리된 (예: 센터링) 픽셀 값으로 구성되지만 실무자는 원시 픽셀을 기존 모델에 공급하지 않습니다.대신 일반적인 컴퓨터 비전 파이프라인은 기능 추출 파이프라인을 수동으로 엔지니어링하는 것으로 구성되었습니다.* 기능을 배우기* 대신 기능은*제작되었습니다*.대부분의 발전은 기능에 대한 더 영리한 아이디어를 얻는 데서 비롯되었으며 학습 알고리즘은 종종 나중에 고려되는 것으로 강등되었습니다. 
+컴퓨터 비전의 경우 이러한 비교는 공정하지 않을 수 있습니다.즉, 컨벌루션 네트워크에 대한 입력은 원시 또는 가볍게 처리된 (예: 센터링) 픽셀 값으로 구성되지만 실무자는 원시 픽셀을 기존 모델에 공급하지 않습니다.대신 일반적인 컴퓨터 비전 파이프라인은 기능 추출 파이프라인을 수동으로 엔지니어링하는 것으로 구성되었습니다.* 기능을 배우기* 대신 기능은*제작되었습니다*.대부분의 발전은 기능에 대한 더 영리한 아이디어를 얻는 데서 비롯되었으며 학습 알고리즘은 종종 나중에 고려되는 것으로 강등되었습니다.
 
-1990 년대에 일부 신경망 가속기를 사용할 수 있었지만 아직 많은 매개 변수를 가진 심층 다중 채널 다층 CNN을 만들기에는 충분히 강력하지 않았습니다.게다가 데이터 세트는 여전히 상대적으로 작았습니다.이러한 장애물에 더해 파라미터 초기화 휴리스틱, 확률적 경사 하강법의 영리한 변형, 비스쿼싱 활성화 함수 및 효과적인 정규화 기술을 포함한 신경망 훈련을 위한 핵심 트릭이 여전히 누락되었습니다. 
+1990 년대에 일부 신경망 가속기를 사용할 수 있었지만 아직 많은 매개 변수를 가진 심층 다중 채널 다층 CNN을 만들기에는 충분히 강력하지 않았습니다.게다가 데이터 세트는 여전히 상대적으로 작았습니다.이러한 장애물에 더해 파라미터 초기화 휴리스틱, 확률적 경사 하강법의 영리한 변형, 비스쿼싱 활성화 함수 및 효과적인 정규화 기술을 포함한 신경망 훈련을 위한 핵심 트릭이 여전히 누락되었습니다.
 
-따라서*엔드-투-엔드* (픽셀-분류) 시스템을 훈련시키는 대신 클래식 파이프라인은 다음과 같이 보입니다. 
+따라서*엔드-투-엔드* (픽셀-분류) 시스템을 훈련시키는 대신 클래식 파이프라인은 다음과 같이 보입니다.
 
 1. 흥미로운 데이터세트를 얻습니다.초기에는 이러한 데이터 세트에 값비싼 센서가 필요했습니다 (당시 1메가픽셀 이미지는 최첨단 이미지였습니다).
 2. 광학, 기하학, 기타 분석 도구에 대한 지식과 때로는 운이 좋은 대학원생의 우연한 발견을 기반으로 수작업으로 만든 기능으로 데이터 세트를 전처리하십시오.
 3. SIFT (스케일 불변 피쳐 변환) :cite:`Lowe.2004`, SURF (강력한 기능 속도 향상) :cite:`Bay.Tuytelaars.Van-Gool.2006` 또는 기타 여러 수동 조정 파이프라인과 같은 표준 기능 추출기 세트를 통해 데이터를 공급합니다.
 4. 결과 표현을 선호하는 분류자 (예: 선형 모델 또는 커널 방법) 에 덤프하여 분류기를 훈련시킵니다.
 
-머신 러닝 연구원들과 이야기를 나눴다면, 그들은 머신 러닝이 중요하고 아름답다고 믿었습니다.우아한 이론은 다양한 분류 자의 특성을 입증했습니다.기계 학습 분야는 번성하고 엄격하며 매우 유용했습니다.그러나 컴퓨터 비전 연구원과 이야기를 나누면 매우 다른 이야기를 듣게 될 것입니다.이미지 인식의 더러운 진실은 학습 알고리즘이 아닌 기능이 발전을 주도했다는 것입니다.컴퓨터 비전 연구원들은 약간 더 크거나 깨끗한 데이터 세트 또는 약간 개선 된 특징 추출 파이프 라인이 어떤 학습 알고리즘보다 최종 정확도에 훨씬 더 중요하다고 정당하게 믿었습니다. 
+머신 러닝 연구원들과 이야기를 나눴다면, 그들은 머신 러닝이 중요하고 아름답다고 믿었습니다.우아한 이론은 다양한 분류 자의 특성을 입증했습니다.기계 학습 분야는 번성하고 엄격하며 매우 유용했습니다.그러나 컴퓨터 비전 연구원과 이야기를 나누면 매우 다른 이야기를 듣게 될 것입니다.이미지 인식의 더러운 진실은 학습 알고리즘이 아닌 기능이 발전을 주도했다는 것입니다.컴퓨터 비전 연구원들은 약간 더 크거나 깨끗한 데이터 세트 또는 약간 개선 된 특징 추출 파이프 라인이 어떤 학습 알고리즘보다 최종 정확도에 훨씬 더 중요하다고 정당하게 믿었습니다.
 
 ## 학습 표현
 
-상황을 캐스팅하는 또 다른 방법은 파이프 라인의 가장 중요한 부분이 표현이라는 것입니다.그리고 2012년까지 표현은 기계적으로 계산되었습니다.실제로 새로운 기능 기능 세트를 엔지니어링하고 결과를 개선하며 방법을 작성하는 것이 종이 장르에서 두드러졌습니다.엄밀히 :cite:`Lowe.2004`, 서프 :cite:`Bay.Tuytelaars.Van-Gool.2006`, 호그 (배향 그래디언트의 히스토그램) :cite:`Dalal.Triggs.2005`, [bags of visual words](https://en.wikipedia.org/wiki/Bag-of-words_model_in_computer_vision) 및 이와 유사한 특징 추출기가 보금자리를 지배했습니다. 
+상황을 캐스팅하는 또 다른 방법은 파이프 라인의 가장 중요한 부분이 표현이라는 것입니다.그리고 2012년까지 표현은 기계적으로 계산되었습니다.실제로 새로운 기능 기능 세트를 엔지니어링하고 결과를 개선하며 방법을 작성하는 것이 종이 장르에서 두드러졌습니다.엄밀히 :cite:`Lowe.2004`, 서프 :cite:`Bay.Tuytelaars.Van-Gool.2006`, 호그 (배향 그래디언트의 히스토그램) :cite:`Dalal.Triggs.2005`, [bags of visual words](https://en.wikipedia.org/wiki/Bag-of-words_model_in_computer_vision) 및 이와 유사한 특징 추출기가 보금자리를 지배했습니다.
 
 얀 르쿤, 제프 힌튼, 요슈아 벵지오, 앤드류 응, 순이치 아마리, 유르겐 슈미드후버를 포함한 또 다른 연구원 그룹은 다른 계획을 가지고 있었다.그들은 특징 자체를 배워야 한다고 믿었습니다.또한 합리적으로 복잡하기 위해서는 특징을 학습 가능한 매개 변수를 가진 여러 공동으로 학습된 계층으로 계층적으로 구성되어야 한다고 믿었습니다.이미지의 경우 가장 낮은 계층이 가장자리, 색상 및 질감을 감지하기 위해 올 수 있습니다.실제로 알렉스 크리제프스키, 일리아 수츠케버, 제프 힌튼은 CNN의 새로운 변종을 제안했습니다.
 *알렉스넷*,
-2012 이미지넷 챌린지에서 탁월한 성능을 달성했습니다.알렉스넷은 획기적인 이미지넷 분류 논문 :cite:`Krizhevsky.Sutskever.Hinton.2012`의 첫 번째 저자인 알렉스 크리제프스키의 이름을 따서 명명되었습니다. 
+2012 이미지넷 챌린지에서 탁월한 성능을 달성했습니다.알렉스넷은 획기적인 이미지넷 분류 논문 :cite:`Krizhevsky.Sutskever.Hinton.2012`의 첫 번째 저자인 알렉스 크리제프스키의 이름을 따서 명명되었습니다.
 
-흥미롭게도 네트워크의 가장 낮은 계층에서 모델은 일부 기존 필터와 유사한 특징 추출기를 학습했습니다. :numref:`fig_filters`는 AlexNet 논문 :cite:`Krizhevsky.Sutskever.Hinton.2012`에서 재현되었으며 하위 수준 이미지 설명자를 설명합니다. 
+흥미롭게도 네트워크의 가장 낮은 계층에서 모델은 일부 기존 필터와 유사한 특징 추출기를 학습했습니다. :numref:`fig_filters`는 AlexNet 논문 :cite:`Krizhevsky.Sutskever.Hinton.2012`에서 재현되었으며 하위 수준 이미지 설명자를 설명합니다.
 
 ![Image filters learned by the first layer of AlexNet.](../img/filters.png)
 :width:`400px`
 :label:`fig_filters`
 
-네트워크의 상위 계층은 눈, 코, 풀잎 등과 같은 더 큰 구조를 나타내기 위해 이러한 표현을 기반으로 구축될 수 있습니다.더 높은 레이어라도 사람, 비행기, 개 또는 프리스비와 같은 전체 개체를 나타낼 수 있습니다.궁극적으로 최종 은닉 상태는 서로 다른 카테고리에 속하는 데이터를 쉽게 분리 할 수 있도록 내용을 요약하는 이미지의 간결한 표현을 학습합니다. 
+네트워크의 상위 계층은 눈, 코, 풀잎 등과 같은 더 큰 구조를 나타내기 위해 이러한 표현을 기반으로 구축될 수 있습니다.더 높은 레이어라도 사람, 비행기, 개 또는 프리스비와 같은 전체 개체를 나타낼 수 있습니다.궁극적으로 최종 은닉 상태는 서로 다른 카테고리에 속하는 데이터를 쉽게 분리 할 수 있도록 내용을 요약하는 이미지의 간결한 표현을 학습합니다.
 
-2012년에 여러 계층화된 CNN의 궁극적인 돌파구가 나왔지만, 핵심 연구원 그룹은 수년 동안 시각적 데이터의 계층적 표현을 배우려고 시도하면서 이 아이디어에 전념했습니다.2012년의 궁극적인 돌파구는 두 가지 핵심 요소에 기인할 수 있습니다. 
+2012년에 여러 계층화된 CNN의 궁극적인 돌파구가 나왔지만, 핵심 연구원 그룹은 수년 동안 시각적 데이터의 계층적 표현을 배우려고 시도하면서 이 아이디어에 전념했습니다.2012년의 궁극적인 돌파구는 두 가지 핵심 요소에 기인할 수 있습니다.
 
 ### 누락된 성분: 데이터
 
-계층이 많은 심층 모델은 볼록 최적화 (예: 선형 및 커널 방법) 를 기반으로 한 기존 방법보다 훨씬 뛰어난 성능을 발휘하는 영역에 들어가기 위해 많은 양의 데이터가 필요합니다.그러나 컴퓨터의 제한된 저장 용량, 센서의 상대적 비용 및 1990 년대의 비교적 엄격한 연구 예산을 고려할 때 대부분의 연구는 작은 데이터 세트에 의존했습니다.수많은 논문에서 UCI 데이터 세트 수집을 다루었으며, 그 중 다수에는 저해상도의 부자연스러운 설정에서 캡처된 수백 또는 수천 개의 이미지만 포함되어 있습니다. 
+계층이 많은 심층 모델은 볼록 최적화 (예: 선형 및 커널 방법) 를 기반으로 한 기존 방법보다 훨씬 뛰어난 성능을 발휘하는 영역에 들어가기 위해 많은 양의 데이터가 필요합니다.그러나 컴퓨터의 제한된 저장 용량, 센서의 상대적 비용 및 1990 년대의 비교적 엄격한 연구 예산을 고려할 때 대부분의 연구는 작은 데이터 세트에 의존했습니다.수많은 논문에서 UCI 데이터 세트 수집을 다루었으며, 그 중 다수에는 저해상도의 부자연스러운 설정에서 캡처된 수백 또는 수천 개의 이미지만 포함되어 있습니다.
 
-2009년에는 ImageNet 데이터세트가 발표되어 연구원들은 1000개의 서로 다른 개체 범주에서 각각 1000개의 1백만 개의 예제에서 모델을 학습하도록 도전했습니다.이 데이터 세트를 도입 한 Fei-Fei Li가 이끄는 연구원들은 Google 이미지 검색을 활용하여 각 카테고리에 대한 대규모 후보 세트를 사전 필터링하고 Amazon Mechanical Turk 크라우드 소싱 파이프 라인을 사용하여 각 이미지에 대해 관련 카테고리에 속하는지 확인했습니다.이 규모는 전례가 없었습니다.ImageNet Challenge라고 불리는 관련 경쟁은 컴퓨터 비전 및 머신 러닝 연구를 추진하여 연구자들이 이전에 고려했던 것보다 더 큰 규모로 가장 잘 수행 된 모델을 식별하도록 도전했습니다. 
+2009년에는 ImageNet 데이터세트가 발표되어 연구원들은 1000개의 서로 다른 개체 범주에서 각각 1000개의 1백만 개의 예제에서 모델을 학습하도록 도전했습니다.이 데이터 세트를 도입 한 Fei-Fei Li가 이끄는 연구원들은 Google 이미지 검색을 활용하여 각 카테고리에 대한 대규모 후보 세트를 사전 필터링하고 Amazon Mechanical Turk 크라우드 소싱 파이프 라인을 사용하여 각 이미지에 대해 관련 카테고리에 속하는지 확인했습니다.이 규모는 전례가 없었습니다.ImageNet Challenge라고 불리는 관련 경쟁은 컴퓨터 비전 및 머신 러닝 연구를 추진하여 연구자들이 이전에 고려했던 것보다 더 큰 규모로 가장 잘 수행 된 모델을 식별하도록 도전했습니다.
 
 ### 누락된 성분: 하드웨어
 
-딥 러닝 모델은 컴퓨팅 사이클의 열렬한 소비자입니다.훈련에는 수백 개의 epoch가 필요할 수 있으며, 각 반복에는 계산 비용이 많이 드는 선형 대수 연산의 여러 계층을 통해 데이터를 전달해야 합니다.이것이 1990 년대와 2000 년대 초반에보다 효율적으로 최적화 된 볼록 대물렌즈를 기반으로 한 간단한 알고리즘이 선호되는 주된 이유 중 하나입니다. 
+딥 러닝 모델은 컴퓨팅 사이클의 열렬한 소비자입니다.훈련에는 수백 개의 epoch가 필요할 수 있으며, 각 반복에는 계산 비용이 많이 드는 선형 대수 연산의 여러 계층을 통해 데이터를 전달해야 합니다.이것이 1990 년대와 2000 년대 초반에보다 효율적으로 최적화 된 볼록 대물렌즈를 기반으로 한 간단한 알고리즘이 선호되는 주된 이유 중 하나입니다.
 
 *그래픽 처리 장치* (GPU) 는 게임 체인저로 입증되었습니다.
-딥 러닝을 실현 가능하게 만드는 것입니다.이 칩은 컴퓨터 게임에 도움이되도록 그래픽 처리를 가속화하기 위해 오랫동안 개발되었습니다.특히 많은 컴퓨터 그래픽 작업에 필요한 높은 처리량의 $4 \times 4$ 매트릭스-벡터 제품에 최적화되었습니다.다행히도 이 수학은 컨벌루션 계층을 계산하는 데 필요한 수학과 매우 유사합니다.그 무렵 NVIDIA와 ATI는 일반 컴퓨팅 작업을 위해 GPU를 최적화하기 시작했으며, 이를 범용 GPU* (GPGPU) 로 마케팅하기 시작했습니다. 
+딥 러닝을 실현 가능하게 만드는 것입니다.이 칩은 컴퓨터 게임에 도움이되도록 그래픽 처리를 가속화하기 위해 오랫동안 개발되었습니다.특히 많은 컴퓨터 그래픽 작업에 필요한 높은 처리량의 $4 \times 4$ 매트릭스-벡터 제품에 최적화되었습니다.다행히도 이 수학은 컨벌루션 계층을 계산하는 데 필요한 수학과 매우 유사합니다.그 무렵 NVIDIA와 ATI는 일반 컴퓨팅 작업을 위해 GPU를 최적화하기 시작했으며, 이를 범용 GPU* (GPGPU) 로 마케팅하기 시작했습니다.
 
-직감을 제공하기 위해 최신 마이크로 프로세서 (CPU) 의 코어를 고려하십시오.각 코어는 높은 클럭 주파수에서 실행되며 대용량 캐시 (최대 수 메가 바이트의 L3) 를 자랑합니다.각 코어는 분기 예측자, 심층 파이프라인 및 다양한 프로그램을 실행할 수 있는 기타 종소리와 휘파람을 사용하여 광범위한 명령을 실행하는 데 적합합니다.그러나 이러한 명백한 강도는 아킬레스 건이기도합니다. 범용 코어는 제작 비용이 매우 비쌉니다.많은 칩 영역, 정교한 지원 구조 (메모리 인터페이스, 코어 간 캐싱 로직, 고속 상호 연결 등) 가 필요하며 단일 작업에서 비교적 좋지 않습니다.최신 랩톱에는 최대 4 개의 코어가 있으며 고급 서버도 비용 효율적이지 않기 때문에 64 코어를 초과하는 경우는 거의 없습니다. 
+직감을 제공하기 위해 최신 마이크로 프로세서 (CPU) 의 코어를 고려하십시오.각 코어는 높은 클럭 주파수에서 실행되며 대용량 캐시 (최대 수 메가 바이트의 L3) 를 자랑합니다.각 코어는 분기 예측자, 심층 파이프라인 및 다양한 프로그램을 실행할 수 있는 기타 종소리와 휘파람을 사용하여 광범위한 명령을 실행하는 데 적합합니다.그러나 이러한 명백한 강도는 아킬레스 건이기도합니다. 범용 코어는 제작 비용이 매우 비쌉니다.많은 칩 영역, 정교한 지원 구조 (메모리 인터페이스, 코어 간 캐싱 로직, 고속 상호 연결 등) 가 필요하며 단일 작업에서 비교적 좋지 않습니다.최신 랩톱에는 최대 4 개의 코어가 있으며 고급 서버도 비용 효율적이지 않기 때문에 64 코어를 초과하는 경우는 거의 없습니다.
 
-이에 비해 GPU는 $100 \sim 1000$ 개의 작은 처리 요소 (NVIDIA, ATI, ARM 및 기타 칩 공급 업체마다 세부 사항이 다소 다름) 로 구성되며 종종 더 큰 그룹으로 그룹화됩니다 (NVIDIA는 워프라고 부름).각 코어는 상대적으로 약하고 때로는 1GHz 이하의 클록 주파수에서 실행되기도하지만 CPU보다 GPU를 훨씬 빠르게 만드는 것은 이러한 코어의 총 수입니다.예를 들어 NVIDIA의 최근 Volta 세대는 특수 명령을 위해 칩당 최대 120 TFlops를 제공하며 (보다 일반적인 용도의 경우 최대 24 TFlops) CPU의 부동 소수점 성능은 현재까지 1 TFlop을 초과하지 않았습니다.이것이 가능한 이유는 실제로 매우 간단합니다. 첫째, 전력 소비는 클럭 주파수에 따라*2차적* 증가하는 경향이 있습니다.따라서 4배 더 빠르게 실행되는 CPU 코어의 전력 예산 (일반적인 숫자) 의 경우 $1/4$의 속도로 16개의 GPU 코어를 사용할 수 있으므로 성능이 $16 \times 1/4 = 4$배입니다.또한 GPU 코어는 훨씬 단순하여 (실제로 오랫동안 범용 코드를 실행할 수 없었습니다*) 에너지 효율성이 향상됩니다.마지막으로 딥러닝의 많은 작업에는 높은 메모리 대역폭이 필요합니다.다시 말하지만 GPU는 CPU의 너비가 최소 10배 이상인 버스로 빛을 발합니다. 
+이에 비해 GPU는 $100 \sim 1000$ 개의 작은 처리 요소 (NVIDIA, ATI, ARM 및 기타 칩 공급 업체마다 세부 사항이 다소 다름) 로 구성되며 종종 더 큰 그룹으로 그룹화됩니다 (NVIDIA는 워프라고 부름).각 코어는 상대적으로 약하고 때로는 1GHz 이하의 클록 주파수에서 실행되기도하지만 CPU보다 GPU를 훨씬 빠르게 만드는 것은 이러한 코어의 총 수입니다.예를 들어 NVIDIA의 최근 Volta 세대는 특수 명령을 위해 칩당 최대 120 TFlops를 제공하며 (보다 일반적인 용도의 경우 최대 24 TFlops) CPU의 부동 소수점 성능은 현재까지 1 TFlop을 초과하지 않았습니다.이것이 가능한 이유는 실제로 매우 간단합니다. 첫째, 전력 소비는 클럭 주파수에 따라*2차적* 증가하는 경향이 있습니다.따라서 4배 더 빠르게 실행되는 CPU 코어의 전력 예산 (일반적인 숫자) 의 경우 $1/4$의 속도로 16개의 GPU 코어를 사용할 수 있으므로 성능이 $16 \times 1/4 = 4$배입니다.또한 GPU 코어는 훨씬 단순하여 (실제로 오랫동안 범용 코드를 실행할 수 없었습니다*) 에너지 효율성이 향상됩니다.마지막으로 딥러닝의 많은 작업에는 높은 메모리 대역폭이 필요합니다.다시 말하지만 GPU는 CPU의 너비가 최소 10배 이상인 버스로 빛을 발합니다.
 
-2012년으로 거슬러 올라갑니다.알렉스 크리제프스키와 일리아 수츠케버가 GPU 하드웨어에서 실행할 수 있는 심층 CNN을 구현했을 때 큰 돌파구가 생겼습니다.그들은 CNN, 컨벌루션 및 행렬 곱셈의 계산 병목 현상이 모두 하드웨어에서 병렬화 될 수있는 작업이라는 것을 깨달았습니다.3GB 메모리를 갖춘 두 개의 NVIDIA GTX 580을 사용하여 빠른 컨벌루션을 구현했습니다.코드 [cuda-convnet](https://code.google.com/archive/p/cuda-convnet/)는 몇 년 동안 업계 표준이었고 딥 러닝 붐의 첫 몇 년을 구동하기에 충분했습니다. 
+2012년으로 거슬러 올라갑니다.알렉스 크리제프스키와 일리아 수츠케버가 GPU 하드웨어에서 실행할 수 있는 심층 CNN을 구현했을 때 큰 돌파구가 생겼습니다.그들은 CNN, 컨벌루션 및 행렬 곱셈의 계산 병목 현상이 모두 하드웨어에서 병렬화 될 수있는 작업이라는 것을 깨달았습니다.3GB 메모리를 갖춘 두 개의 NVIDIA GTX 580을 사용하여 빠른 컨벌루션을 구현했습니다.코드 [cuda-convnet](https://code.google.com/archive/p/cuda-convnet/)는 몇 년 동안 업계 표준이었고 딥 러닝 붐의 첫 몇 년을 구동하기에 충분했습니다.
 
 ## 알렉스넷
 
-8 레이어 CNN을 채택한 AlexNet은 놀랍도록 큰 마진으로 이미지넷 대규모 시각 인식 챌린지 2012에서 우승했습니다.이 네트워크는 학습을 통해 얻은 기능이 수동으로 설계된 기능을 초월하여 컴퓨터 비전의 이전 패러다임을 깨뜨릴 수 있음을 처음으로 보여주었습니다. 
+8 레이어 CNN을 채택한 AlexNet은 놀랍도록 큰 마진으로 이미지넷 대규모 시각 인식 챌린지 2012에서 우승했습니다.이 네트워크는 학습을 통해 얻은 기능이 수동으로 설계된 기능을 초월하여 컴퓨터 비전의 이전 패러다임을 깨뜨릴 수 있음을 처음으로 보여주었습니다.
 
-알렉스넷과 르넷의 아키텍처는 :numref:`fig_alexnet`에서 알 수 있듯이 매우 유사합니다.이 모델을 두 개의 작은 GPU에 맞추기 위해 2012년에 필요했던 몇 가지 디자인 단점을 제거한 약간 간소화된 AlexNet 버전을 제공합니다. 
+알렉스넷과 르넷의 아키텍처는 :numref:`fig_alexnet`에서 알 수 있듯이 매우 유사합니다.이 모델을 두 개의 작은 GPU에 맞추기 위해 2012년에 필요했던 몇 가지 디자인 단점을 제거한 약간 간소화된 AlexNet 버전을 제공합니다.
 
 ![From LeNet (left) to AlexNet (right).](../img/alexnet.svg)
 :label:`fig_alexnet`
 
-AlexNet과 LeNet의 디자인 철학은 매우 유사하지만 중요한 차이점도 있습니다.첫째, 알렉스넷은 비교적 작은 LeNet5보다 훨씬 깊습니다.AlexNet은 8개의 계층으로 구성되어 있습니다. 5개의 컨벌루션 계층, 2개의 완전 연결 은닉 계층, 그리고 1개의 완전 연결 출력 계층입니다.둘째, AlexNet은 시그모이드 대신 ReLU를 활성화 함수로 사용했습니다.아래에서 자세히 살펴 보겠습니다. 
+AlexNet과 LeNet의 디자인 철학은 매우 유사하지만 중요한 차이점도 있습니다.첫째, 알렉스넷은 비교적 작은 LeNet5보다 훨씬 깊습니다.AlexNet은 8개의 계층으로 구성되어 있습니다. 5개의 컨벌루션 계층, 2개의 완전 연결 은닉 계층, 그리고 1개의 완전 연결 출력 계층입니다.둘째, AlexNet은 시그모이드 대신 ReLU를 활성화 함수로 사용했습니다.아래에서 자세히 살펴 보겠습니다.
 
 ### 아키텍처
 
-알렉스넷의 첫 번째 계층에서 컨벌루션 윈도우 모양은 $11\times11$입니다.ImageNet에 있는 대부분의 이미지는 MNIST 이미지보다 10배 이상 높고 넓기 때문에 ImageNet 데이터의 객체는 더 많은 픽셀을 차지하는 경향이 있습니다.따라서 객체를 캡처하려면 더 큰 컨볼루션 윈도우가 필요합니다.두 번째 레이어의 컨볼루션 윈도우 모양은 $5\times5$으로 축소되고 그 다음에는 $3\times3$가 이어집니다.또한 첫 번째, 두 번째 및 다섯 번째 컨벌루션 계층 다음에 윈도우 모양이 $3\times3$이고 스트라이드가 2인 최대 풀링 계층을 추가합니다.또한 AlexNet은 LeNet보다 10배 더 많은 컨볼루션 채널을 가지고 있습니다. 
+알렉스넷의 첫 번째 계층에서 컨벌루션 윈도우 모양은 $11\times11$입니다.ImageNet에 있는 대부분의 이미지는 MNIST 이미지보다 10배 이상 높고 넓기 때문에 ImageNet 데이터의 객체는 더 많은 픽셀을 차지하는 경향이 있습니다.따라서 객체를 캡처하려면 더 큰 컨볼루션 윈도우가 필요합니다.두 번째 레이어의 컨볼루션 윈도우 모양은 $5\times5$으로 축소되고 그 다음에는 $3\times3$가 이어집니다.또한 첫 번째, 두 번째 및 다섯 번째 컨벌루션 계층 다음에 윈도우 모양이 $3\times3$이고 스트라이드가 2인 최대 풀링 계층을 추가합니다.또한 AlexNet은 LeNet보다 10배 더 많은 컨볼루션 채널을 가지고 있습니다.
 
-마지막 컨벌루션 계층 뒤에는 4096개의 출력값을 갖는 두 개의 완전 연결 계층이 있습니다.이 두 개의 거대한 완전 연결 계층은 거의 1GB의 모델 파라미터를 생성합니다.초기 GPU의 제한된 메모리로 인해 원래 AlexNet은 이중 데이터 스트림 설계를 사용했기 때문에 두 GPU 각각이 모델의 절반만 저장하고 계산할 수 있습니다.다행히도 GPU 메모리는 현재 비교적 풍부하기 때문에 요즘 GPU에서 모델을 분리 할 필요가 거의 없습니다 (이 측면에서 AlexNet 모델 버전은 원본 논문에서 벗어납니다). 
+마지막 컨벌루션 계층 뒤에는 4096개의 출력값을 갖는 두 개의 완전 연결 계층이 있습니다.이 두 개의 거대한 완전 연결 계층은 거의 1GB의 모델 파라미터를 생성합니다.초기 GPU의 제한된 메모리로 인해 원래 AlexNet은 이중 데이터 스트림 설계를 사용했기 때문에 두 GPU 각각이 모델의 절반만 저장하고 계산할 수 있습니다.다행히도 GPU 메모리는 현재 비교적 풍부하기 때문에 요즘 GPU에서 모델을 분리 할 필요가 거의 없습니다 (이 측면에서 AlexNet 모델 버전은 원본 논문에서 벗어납니다).
 
 ### 활성화 함수
 
-게다가 AlexNet은 시그모이드 활성화 함수를 더 간단한 ReLU 활성화 함수로 변경했습니다.한편으로는 ReLU 활성화 함수의 계산이 더 간단합니다.예를 들어, 시그모이드 활성화 함수에서 지수 연산을 찾을 수 없습니다.반면에 ReLU 활성화 기능은 다른 매개 변수 초기화 방법을 사용할 때 모델 학습을 더 쉽게 만듭니다.시그모이드 활성화 함수의 출력값이 0 또는 1에 매우 가까우면 이러한 영역의 기울기가 거의 0이므로 역전파가 일부 모델 파라미터를 계속 업데이트할 수 없기 때문입니다.반면 양의 구간에서 ReLU 활성화 함수의 기울기는 항상 1입니다.따라서 모델 모수가 제대로 초기화되지 않으면 sigmoid 함수가 양의 구간에서 거의 0의 기울기를 얻을 수 있으므로 모델을 효과적으로 훈련시킬 수 없습니다. 
+게다가 AlexNet은 시그모이드 활성화 함수를 더 간단한 ReLU 활성화 함수로 변경했습니다.한편으로는 ReLU 활성화 함수의 계산이 더 간단합니다.예를 들어, 시그모이드 활성화 함수에서 지수 연산을 찾을 수 없습니다.반면에 ReLU 활성화 기능은 다른 매개 변수 초기화 방법을 사용할 때 모델 학습을 더 쉽게 만듭니다.시그모이드 활성화 함수의 출력값이 0 또는 1에 매우 가까우면 이러한 영역의 기울기가 거의 0이므로 역전파가 일부 모델 파라미터를 계속 업데이트할 수 없기 때문입니다.반면 양의 구간에서 ReLU 활성화 함수의 기울기는 항상 1입니다.따라서 모델 모수가 제대로 초기화되지 않으면 sigmoid 함수가 양의 구간에서 거의 0의 기울기를 얻을 수 있으므로 모델을 효과적으로 훈련시킬 수 없습니다.
 
 ### 용량 제어 및 전처리
 
@@ -227,7 +227,7 @@ for layer in net().layers:
 
 ## 데이터세트 읽기
 
-AlexNet은 이 백서에서 ImageNet에 대한 교육을 받았지만, 최신 GPU에서도 ImageNet 모델을 수렴하도록 훈련시키는 데 몇 시간 또는 며칠이 걸릴 수 있기 때문에 여기서는 Fashion-MNIST를 사용합니다.AlexNet을 [**Fashion-MNist**] 에 직접 적용할 때의 문제점 중 하나는 (**이미지의 해상도가 낮습니다**) ($28 \times 28$ 픽셀) (**ImageNet 이미지보다**) 작업을 수행하기 위해 (**$224 \times 224$**로 업샘플링) (일반적으로 현명한 관행은 아니지만 AlexNet에 충실하기 위해 여기서 수행합니다.아키텍처).`d2l.load_data_fashion_mnist` 함수에서 `resize` 인수를 사용하여 이 크기 조정을 수행합니다.
+AlexNet은 이 백서에서 ImageNet에 대한 교육을 받았지만, 최신 GPU에서도 ImageNet 모델을 수렴하도록 훈련시키는 데 몇 시간 또는 며칠이 걸릴 수 있기 때문에 여기서는 Fashion-MNIST를 사용합니다.AlexNet을 [**Fashion-MNist**] 에 직접 적용할 때의 문제점 중 하나는 (**이미지의 해상도가 낮습니다**) ($28 \times 28$ 픽셀) (**ImageNet 이미지보다**) 작업을 수행하기 위해 $224 \times 224$로 업샘플링 (일반적으로 현명한 관행은 아니지만 AlexNet에 충실하기 위해 여기서 수행합니다.아키텍처).`d2l.load_data_fashion_mnist` 함수에서 `resize` 인수를 사용하여 이 크기 조정을 수행합니다.
 
 ```{.python .input}
 #@tab all
diff --git a/chapter_convolutional-modern/batch-norm.md b/chapter_convolutional-modern/batch-norm.md
index 935e8389..f9229cc7 100644
--- a/chapter_convolutional-modern/batch-norm.md
+++ b/chapter_convolutional-modern/batch-norm.md
@@ -1,67 +1,67 @@
 # 배치 정규화
 :label:`sec_batch_norm`
 
-심층 신경망을 훈련시키는 것은 어렵습니다.그리고 합리적인 시간 내에 수렴하는 것은 까다로울 수 있습니다.이 섹션에서는 심층 네트워크 :cite:`Ioffe.Szegedy.2015`의 수렴을 지속적으로 가속화하는 인기 있고 효과적인 기술인*배치 정규화*에 대해 설명합니다.나중에 :numref:`sec_resnet`에서 다루는 잔차 블록과 함께 배치 정규화를 통해 실무자는 100개 이상의 계층으로 네트워크를 일상적으로 훈련시킬 수 있었습니다. 
+심층 신경망을 훈련시키는 것은 어렵습니다.그리고 합리적인 시간 내에 수렴하는 것은 까다로울 수 있습니다.이 섹션에서는 심층 네트워크 :cite:`Ioffe.Szegedy.2015`의 수렴을 지속적으로 가속화하는 인기 있고 효과적인 기술인*배치 정규화*에 대해 설명합니다.나중에 :numref:`sec_resnet`에서 다루는 잔차 블록과 함께 배치 정규화를 통해 실무자는 100개 이상의 계층으로 네트워크를 일상적으로 훈련시킬 수 있었습니다.
 
 ## 심층 네트워크 훈련
 
-배치 정규화에 동기를 부여하기 위해 특히 기계 학습 모델 및 신경망을 훈련시킬 때 발생하는 몇 가지 실질적인 문제를 검토해 보겠습니다. 
+배치 정규화에 동기를 부여하기 위해 특히 기계 학습 모델 및 신경망을 훈련시킬 때 발생하는 몇 가지 실질적인 문제를 검토해 보겠습니다.
 
-첫째, 데이터 전처리에 대한 선택은 종종 최종 결과에 큰 차이를 만듭니다.주택 가격 예측에 MLP를 적용한 것을 상기하십시오 (:numref:`sec_kaggle_house`).실제 데이터로 작업할 때 첫 번째 단계는 입력 피처를 표준화하여 각각의 평균이 0이고 분산이 1이 되도록 하는 것이었습니다.직관적으로 이 표준화는 파라미터*a priori*를 비슷한 규모로 배치하기 때문에 옵티마이저와 잘 어울립니다. 
+첫째, 데이터 전처리에 대한 선택은 종종 최종 결과에 큰 차이를 만듭니다.주택 가격 예측에 MLP를 적용한 것을 상기하십시오 (:numref:`sec_kaggle_house`).실제 데이터로 작업할 때 첫 번째 단계는 입력 피처를 표준화하여 각각의 평균이 0이고 분산이 1이 되도록 하는 것이었습니다.직관적으로 이 표준화는 파라미터*a priori*를 비슷한 규모로 배치하기 때문에 옵티마이저와 잘 어울립니다.
 
-둘째, 일반적인 MLP 또는 CNN의 경우 훈련 할 때 중간 계층의 변수 (예: MLP의 아핀 변환 출력) 는 입력에서 출력까지의 레이어를 따라, 동일한 계층의 단위에 걸쳐, 그리고 시간이 지남에 따라 매우 다양한 크기의 값을 취할 수 있습니다. 모델 업데이트로 인해매개 변수.배치 정규화의 발명자들은 그러한 변수의 분포에서 이러한 드리프트가 네트워크의 수렴을 방해 할 수 있다고 비공식적으로 가정했습니다.직관적으로 한 계층에 다른 계층의 100배인 변수 값이 있는 경우 학습률의 보상 조정이 필요할 수 있다고 추측할 수 있습니다. 
+둘째, 일반적인 MLP 또는 CNN의 경우 훈련 할 때 중간 계층의 변수 (예: MLP의 아핀 변환 출력) 는 입력에서 출력까지의 레이어를 따라, 동일한 계층의 단위에 걸쳐, 그리고 시간이 지남에 따라 매우 다양한 크기의 값을 취할 수 있습니다. 모델 업데이트로 인해매개 변수.배치 정규화의 발명자들은 그러한 변수의 분포에서 이러한 드리프트가 네트워크의 수렴을 방해 할 수 있다고 비공식적으로 가정했습니다.직관적으로 한 계층에 다른 계층의 100배인 변수 값이 있는 경우 학습률의 보상 조정이 필요할 수 있다고 추측할 수 있습니다.
 
-셋째, 더 깊은 네트워크는 복잡하고 쉽게 과적합할 수 있습니다.즉, 정규화가 더욱 중요해집니다. 
+셋째, 더 깊은 네트워크는 복잡하고 쉽게 과적합할 수 있습니다.즉, 정규화가 더욱 중요해집니다.
 
-배치 정규화는 개별 계층 (선택적으로 모든 계층) 에 적용되며 다음과 같이 작동합니다. 각 훈련 반복에서 먼저 평균을 빼고 표준 편차로 나누어 (배치 정규화의) 입력을 정규화합니다.현재 미니배치.다음으로 스케일 계수와 스케일 오프셋을 적용합니다.*배치 정규화*가 그 이름을 파생시키는 것은*배치* 통계를 기반으로하는*정규화* 때문입니다. 
+배치 정규화는 개별 계층 (선택적으로 모든 계층) 에 적용되며 다음과 같이 작동합니다. 각 훈련 반복에서 먼저 평균을 빼고 표준 편차로 나누어 (배치 정규화의) 입력을 정규화합니다.현재 미니배치.다음으로 스케일 계수와 스케일 오프셋을 적용합니다.*배치 정규화*가 그 이름을 파생시키는 것은*배치* 통계를 기반으로하는*정규화* 때문입니다.
 
-크기가 1인 미니 배치로 배치 정규화를 적용하려고 하면 아무것도 배울 수 없습니다.그 이유는 평균을 빼면 숨겨진 각 단위의 값이 0이 되기 때문입니다!짐작할 수 있듯이, 미니 배치가 충분히 큰 배치 정규화에 전체 섹션을 할애하고 있기 때문에 접근 방식이 효과적이고 안정적입니다.여기서 한 가지 요점은 배치 정규화를 적용할 때 배치 정규화를 사용하지 않는 것보다 배치 크기를 선택하는 것이 훨씬 더 중요할 수 있다는 것입니다. 
+크기가 1인 미니 배치로 배치 정규화를 적용하려고 하면 아무것도 배울 수 없습니다.그 이유는 평균을 빼면 숨겨진 각 단위의 값이 0이 되기 때문입니다!짐작할 수 있듯이, 미니 배치가 충분히 큰 배치 정규화에 전체 섹션을 할애하고 있기 때문에 접근 방식이 효과적이고 안정적입니다.여기서 한 가지 요점은 배치 정규화를 적용할 때 배치 정규화를 사용하지 않는 것보다 배치 크기를 선택하는 것이 훨씬 더 중요할 수 있다는 것입니다.
 
-공식적으로, 미니배치 $\mathcal{B}$의 배치 정규화 ($\mathrm{BN}$) 에 대한 입력을 $\mathbf{x} \in \mathcal{B}$으로 나타내면 배치 정규화는 다음 표현식에 따라 $\mathbf{x}$를 변환합니다. 
+공식적으로, 미니배치 $\mathcal{B}$의 배치 정규화 ($\mathrm{BN}$) 에 대한 입력을 $\mathbf{x} \in \mathcal{B}$으로 나타내면 배치 정규화는 다음 표현식에 따라 $\mathbf{x}$를 변환합니다.
 
 $$\mathrm{BN}(\mathbf{x}) = \boldsymbol{\gamma} \odot \frac{\mathbf{x} - \hat{\boldsymbol{\mu}}_\mathcal{B}}{\hat{\boldsymbol{\sigma}}_\mathcal{B}} + \boldsymbol{\beta}.$$
 :eqlabel:`eq_batchnorm`
 
 :eqref:`eq_batchnorm`에서 $\hat{\boldsymbol{\mu}}_\mathcal{B}$는 표본 평균이고 $\hat{\boldsymbol{\sigma}}_\mathcal{B}$은 미니배치 $\mathcal{B}$의 표본 표준 편차입니다.표준화를 적용한 후 결과로 생성되는 미니배치는 평균과 단위 분산이 0입니다.단위 분산 (다른 매직 넘버와 비교) 의 선택은 임의의 선택이기 때문에 일반적으로 요소별로
 *스케일 파라미터* $\boldsymbol{\gamma}$ 및*시프트 파라미터* $\boldsymbol{\beta}$
-$\mathbf{x}$와 같은 모양을 가지고 있습니다.$\boldsymbol{\gamma}$ 및 $\boldsymbol{\beta}$은 다른 모델 매개 변수와 공동으로 학습해야 하는 매개 변수입니다. 
+$\mathbf{x}$와 같은 모양을 가지고 있습니다.$\boldsymbol{\gamma}$ 및 $\boldsymbol{\beta}$은 다른 모델 매개 변수와 공동으로 학습해야 하는 매개 변수입니다.
 
-결과적으로 배치 정규화가 능동적으로 중심을 맞추고 주어진 평균과 크기로 다시 스케일링하기 때문에 중간 계층의 가변 크기는 훈련 중에 발산할 수 없습니다 ($\hat{\boldsymbol{\mu}}_\mathcal{B}$ 및 ${\hat{\boldsymbol{\sigma}}_\mathcal{B}}$를 통해).실무자의 직감이나 지혜의 한 부분은 배치 정규화가 더 공격적인 학습 속도를 허용하는 것처럼 보인다는 것입니다. 
+결과적으로 배치 정규화가 능동적으로 중심을 맞추고 주어진 평균과 크기로 다시 스케일링하기 때문에 중간 계층의 가변 크기는 훈련 중에 발산할 수 없습니다 ($\hat{\boldsymbol{\mu}}_\mathcal{B}$ 및 ${\hat{\boldsymbol{\sigma}}_\mathcal{B}}$를 통해).실무자의 직감이나 지혜의 한 부분은 배치 정규화가 더 공격적인 학습 속도를 허용하는 것처럼 보인다는 것입니다.
 
-공식적으로 다음과 같이 :eqref:`eq_batchnorm`에서 $\hat{\boldsymbol{\mu}}_\mathcal{B}$와 ${\hat{\boldsymbol{\sigma}}_\mathcal{B}}$을 계산합니다. 
+공식적으로 다음과 같이 :eqref:`eq_batchnorm`에서 $\hat{\boldsymbol{\mu}}_\mathcal{B}$와 ${\hat{\boldsymbol{\sigma}}_\mathcal{B}}$을 계산합니다.
 
 $$\begin{aligned} \hat{\boldsymbol{\mu}}_\mathcal{B} &= \frac{1}{|\mathcal{B}|} \sum_{\mathbf{x} \in \mathcal{B}} \mathbf{x},\\
 \hat{\boldsymbol{\sigma}}_\mathcal{B}^2 &= \frac{1}{|\mathcal{B}|} \sum_{\mathbf{x} \in \mathcal{B}} (\mathbf{x} - \hat{\boldsymbol{\mu}}_{\mathcal{B}})^2 + \epsilon.\end{aligned}$$
 
-경험적 분산 추정치가 사라질 수 있는 경우에도 0으로 나누기를 시도하지 않도록 분산 추정치에 작은 상수 $\epsilon > 0$를 추가합니다.추정치 $\hat{\boldsymbol{\mu}}_\mathcal{B}$ 및 ${\hat{\boldsymbol{\sigma}}_\mathcal{B}}$은 평균과 분산에 대한 잡음이 있는 추정치를 사용하여 스케일링 문제에 대응합니다.이 잡음이 문제가 될 것이라고 생각할 수도 있습니다.결과적으로 이것은 실제로 유익합니다. 
+경험적 분산 추정치가 사라질 수 있는 경우에도 0으로 나누기를 시도하지 않도록 분산 추정치에 작은 상수 $\epsilon > 0$를 추가합니다.추정치 $\hat{\boldsymbol{\mu}}_\mathcal{B}$ 및 ${\hat{\boldsymbol{\sigma}}_\mathcal{B}}$은 평균과 분산에 대한 잡음이 있는 추정치를 사용하여 스케일링 문제에 대응합니다.이 잡음이 문제가 될 것이라고 생각할 수도 있습니다.결과적으로 이것은 실제로 유익합니다.
 
-이는 딥 러닝에서 반복되는 주제로 판명되었습니다.이론적으로 아직 잘 특성화되지 않은 이유로 최적화의 다양한 노이즈 원인은 종종 훈련 속도가 빨라지고 과적합이 줄어 듭니다. 이러한 변형은 정규화의 한 형태로 작용하는 것으로 보입니다.일부 예비 연구에서 :cite:`Teye.Azizpour.Smith.2018` 및 :cite:`Luo.Wang.Shao.ea.2018`는 배치 정규화의 특성을 각각 베이지안 사전 및 벌칙과 관련시킵니다.특히 이것은 배치 정규화가 $50 \sim 100$ 범위의 중간 미니 배치 크기에 가장 적합한 이유에 대한 퍼즐을 밝힙니다. 
+이는 딥 러닝에서 반복되는 주제로 판명되었습니다.이론적으로 아직 잘 특성화되지 않은 이유로 최적화의 다양한 노이즈 원인은 종종 훈련 속도가 빨라지고 과적합이 줄어 듭니다. 이러한 변형은 정규화의 한 형태로 작용하는 것으로 보입니다.일부 예비 연구에서 :cite:`Teye.Azizpour.Smith.2018` 및 :cite:`Luo.Wang.Shao.ea.2018`는 배치 정규화의 특성을 각각 베이지안 사전 및 벌칙과 관련시킵니다.특히 이것은 배치 정규화가 $50 \sim 100$ 범위의 중간 미니 배치 크기에 가장 적합한 이유에 대한 퍼즐을 밝힙니다.
 
-훈련된 모델을 수정하면 평균과 분산을 추정하기 위해 전체 데이터셋을 사용하는 것이 더 좋다고 생각할 수 있습니다.훈련이 완료되면 동일한 이미지가 상주하는 배치에 따라 다르게 분류되기를 원하는 이유는 무엇입니까?훈련 중에는 모델을 업데이트할 때마다 모든 데이터 예제의 중간 변수가 변경되므로 이러한 정확한 계산은 불가능합니다.그러나 모델이 훈련되면 전체 데이터셋을 기반으로 각 계층 변수의 평균과 분산을 계산할 수 있습니다.실제로 이것은 배치 정규화를 사용하는 모델에 대한 표준 관행이므로 배치 정규화 계층은*훈련 모드* (미니배치 통계량으로 정규화) 와*예측 모드* (데이터셋 통계량으로 정규화) 에서 다르게 작동합니다. 
+훈련된 모델을 수정하면 평균과 분산을 추정하기 위해 전체 데이터셋을 사용하는 것이 더 좋다고 생각할 수 있습니다.훈련이 완료되면 동일한 이미지가 상주하는 배치에 따라 다르게 분류되기를 원하는 이유는 무엇입니까?훈련 중에는 모델을 업데이트할 때마다 모든 데이터 예제의 중간 변수가 변경되므로 이러한 정확한 계산은 불가능합니다.그러나 모델이 훈련되면 전체 데이터셋을 기반으로 각 계층 변수의 평균과 분산을 계산할 수 있습니다.실제로 이것은 배치 정규화를 사용하는 모델에 대한 표준 관행이므로 배치 정규화 계층은*훈련 모드* (미니배치 통계량으로 정규화) 와*예측 모드* (데이터셋 통계량으로 정규화) 에서 다르게 작동합니다.
 
-이제 배치 정규화가 실제로 어떻게 작동하는지 살펴볼 준비가 되었습니다. 
+이제 배치 정규화가 실제로 어떻게 작동하는지 살펴볼 준비가 되었습니다.
 
 ## 배치 정규화 계층
 
-완전 연결 계층과 컨벌루션 계층에 대한 배치 정규화 구현은 약간 다릅니다.아래에서 두 가지 사례에 대해 논의합니다.배치 정규화와 다른 계층 간의 주요 차이점 중 하나는 배치 정규화가 한 번에 전체 미니 배치에서 작동하기 때문에 다른 계층을 도입할 때 이전처럼 배치 차원을 무시할 수 없다는 것입니다. 
+완전 연결 계층과 컨벌루션 계층에 대한 배치 정규화 구현은 약간 다릅니다.아래에서 두 가지 사례에 대해 논의합니다.배치 정규화와 다른 계층 간의 주요 차이점 중 하나는 배치 정규화가 한 번에 전체 미니 배치에서 작동하기 때문에 다른 계층을 도입할 때 이전처럼 배치 차원을 무시할 수 없다는 것입니다.
 
 ### 완전 연결 레이어
 
-완전 연결 계층에 배치 정규화를 적용할 때 원본 논문에서는 아핀 변환 후와 비선형 활성화 함수 앞에 배치 정규화를 삽입합니다 (이후 응용 프로그램에서는 활성화 함수 바로 다음에 배치 정규화를 삽입할 수 있음) :cite:`Ioffe.Szegedy.2015`.완전히 연결된 계층에 대한 입력을 $\mathbf{x}$으로 표시하고, 아핀 변환을 $\mathbf{W}\mathbf{x} + \mathbf{b}$ (가중치 매개 변수 $\mathbf{W}$ 및 바이어스 매개 변수 $\mathbf{b}$) 으로 표시하고 활성화 함수를 $\phi$로 표시하면 배치 정규화가 가능하고 완전히 연결된 계층 출력의 계산을 표현할 수 있습니다.$\mathbf{h}$는 다음과 같습니다. 
+완전 연결 계층에 배치 정규화를 적용할 때 원본 논문에서는 아핀 변환 후와 비선형 활성화 함수 앞에 배치 정규화를 삽입합니다 (이후 응용 프로그램에서는 활성화 함수 바로 다음에 배치 정규화를 삽입할 수 있음) :cite:`Ioffe.Szegedy.2015`.완전히 연결된 계층에 대한 입력을 $\mathbf{x}$으로 표시하고, 아핀 변환을 $\mathbf{W}\mathbf{x} + \mathbf{b}$ (가중치 매개 변수 $\mathbf{W}$ 및 바이어스 매개 변수 $\mathbf{b}$) 으로 표시하고 활성화 함수를 $\phi$로 표시하면 배치 정규화가 가능하고 완전히 연결된 계층 출력의 계산을 표현할 수 있습니다.$\mathbf{h}$는 다음과 같습니다.
 
 $$\mathbf{h} = \phi(\mathrm{BN}(\mathbf{W}\mathbf{x} + \mathbf{b}) ).$$
 
-평균과 분산은 변환이 적용되는*동일한* 미니배치에서 계산됩니다. 
+평균과 분산은 변환이 적용되는*동일한* 미니배치에서 계산됩니다.
 
 ### 컨벌루션 계층
 
-마찬가지로 컨벌루션 계층을 사용하면 컨벌루션 뒤와 비선형 활성화 함수 앞에 배치 정규화를 적용 할 수 있습니다.컨볼 루션에 여러 개의 출력 채널이있는 경우 이러한 채널의 출력의*각*에 대해 배치 정규화를 수행해야하며 각 채널에는 자체 스케일 및 시프트 매개 변수가 있으며 둘 다 스칼라입니다.미니 배치에 $m$의 예가 포함되어 있고 각 채널에 대해 컨벌루션의 출력의 높이가 $p$이고 너비가 $q$라고 가정합니다.컨벌루션 계층의 경우 출력 채널당 $m \cdot p \cdot q$ 요소에 대해 각 배치 정규화를 동시에 수행합니다.따라서 평균과 분산을 계산할 때 모든 공간 위치에 대한 값을 수집하고 결과적으로 주어진 채널 내에서 동일한 평균과 분산을 적용하여 각 공간 위치에서 값을 정규화합니다. 
+마찬가지로 컨벌루션 계층을 사용하면 컨벌루션 뒤와 비선형 활성화 함수 앞에 배치 정규화를 적용 할 수 있습니다.컨볼 루션에 여러 개의 출력 채널이있는 경우 이러한 채널의 출력의*각*에 대해 배치 정규화를 수행해야하며 각 채널에는 자체 스케일 및 시프트 매개 변수가 있으며 둘 다 스칼라입니다.미니 배치에 $m$의 예가 포함되어 있고 각 채널에 대해 컨벌루션의 출력의 높이가 $p$이고 너비가 $q$라고 가정합니다.컨벌루션 계층의 경우 출력 채널당 $m \cdot p \cdot q$ 요소에 대해 각 배치 정규화를 동시에 수행합니다.따라서 평균과 분산을 계산할 때 모든 공간 위치에 대한 값을 수집하고 결과적으로 주어진 채널 내에서 동일한 평균과 분산을 적용하여 각 공간 위치에서 값을 정규화합니다.
 
 ### 예측 중 배치 정규화
 
-앞서 언급했듯이 배치 정규화는 일반적으로 훈련 모드와 예측 모드에서 다르게 동작합니다.첫째, 모델을 훈련시킨 후에는 표본 평균의 잡음과 미니 배치에서 각각을 추정하여 발생하는 표본 분산이 더 이상 바람직하지 않습니다.둘째, 배치당 정규화 통계를 계산하는 사치가 없을 수도 있습니다.예를 들어 한 번에 하나씩 예측하기 위해 모델을 적용해야 할 수 있습니다. 
+앞서 언급했듯이 배치 정규화는 일반적으로 훈련 모드와 예측 모드에서 다르게 동작합니다.첫째, 모델을 훈련시킨 후에는 표본 평균의 잡음과 미니 배치에서 각각을 추정하여 발생하는 표본 분산이 더 이상 바람직하지 않습니다.둘째, 배치당 정규화 통계를 계산하는 사치가 없을 수도 있습니다.예를 들어 한 번에 하나씩 예측하기 위해 모델을 적용해야 할 수 있습니다.
 
-일반적으로 훈련 후에는 전체 데이터셋을 사용하여 변수 통계량의 안정적인 추정치를 계산한 다음 예측 시점에 수정합니다.따라서 배치 정규화는 훈련 중과 테스트 시 다르게 동작합니다.드롭 아웃도 이러한 특성을 나타냅니다. 
+일반적으로 훈련 후에는 전체 데이터셋을 사용하여 변수 통계량의 안정적인 추정치를 계산한 다음 예측 시점에 수정합니다.따라서 배치 정규화는 훈련 중과 테스트 시 다르게 동작합니다.드롭 아웃도 이러한 특성을 나타냅니다.
 
 ## (**처음부터 구현**)
 
@@ -155,7 +155,7 @@ def batch_norm(X, gamma, beta, moving_mean, moving_var, eps):
     return Y
 ```
 
-이제 [**적절한 `BatchNorm` 레이어를 생성할 수 있습니다.**] 레이어가 스케일 `gamma` 및 시프트 `beta`에 대한 적절한 파라미터를 유지하며, 이 두 가지 모두 훈련 과정에서 업데이트됩니다.또한 계층은 모델 예측 중에 후속 사용을 위해 평균 및 분산의 이동 평균을 유지합니다. 
+이제 [**적절한 `BatchNorm` 레이어를 생성할 수 있습니다.**] 레이어가 스케일 `gamma` 및 시프트 `beta`에 대한 적절한 파라미터를 유지하며, 이 두 가지 모두 훈련 과정에서 업데이트됩니다.또한 계층은 모델 예측 중에 후속 사용을 위해 평균 및 분산의 이동 평균을 유지합니다.
 
 알고리즘의 세부 사항을 제외하고 레이어 구현의 기초가 되는 디자인 패턴에 주목하십시오.일반적으로 수학은 `batch_norm`와 같은 별도의 함수로 정의합니다.그런 다음 이 기능을 사용자 지정 계층에 통합합니다. 이 계층은 데이터를 올바른 장치 컨텍스트로 이동하고, 필요한 변수를 할당 및 초기화하고, 이동 평균 (여기서는 평균 및 분산) 을 추적하는 등의 부기 문제를 주로 다룹니다.이 패턴을 사용하면 상용구 코드에서 수학을 깔끔하게 분리할 수 있습니다.또한 편의를 위해 입력 셰이프를 자동으로 추론하는 것에 대해 걱정하지 않았으므로 전체 피처 수를 지정해야 합니다.걱정하지 마세요. 딥러닝 프레임워크의 상위 수준 배치 정규화 API가 이 문제를 해결해 줄 것이며 나중에 설명하겠습니다.
 
@@ -353,7 +353,7 @@ train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
 net = d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())
 ```
 
-첫 번째 배치 정규화 계층에서 학습한 스케일 파라미터 `gamma`와 시프트 파라미터 `beta`**] 를 살펴보겠습니다.
+첫 번째 배치 정규화 계층에서 학습한 스케일 파라미터 `gamma`와 시프트 파라미터 `beta` 를 살펴보겠습니다.
 
 ```{.python .input}
 net[1].gamma.data().reshape(-1,), net[1].beta.data().reshape(-1,)
@@ -437,13 +437,13 @@ d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())
 
 ## 논란
 
-직관적으로 배치 정규화는 최적화 환경을 더 매끄럽게 만드는 것으로 생각됩니다.그러나 심층 모델을 훈련 할 때 관찰하는 현상에 대한 투기 적 직관과 진정한 설명을 구분해야합니다.더 단순한 심층 신경망 (MLP 및 기존 CNN) 이 처음부터 잘 일반화되는 이유조차 알지 못합니다.드롭 아웃 및 체중 감소에도 불구하고 기존의 학습 이론적 일반화 보증을 통해 보이지 않는 데이터로 일반화하는 능력을 설명 할 수 없을 정도로 유연합니다. 
+직관적으로 배치 정규화는 최적화 환경을 더 매끄럽게 만드는 것으로 생각됩니다.그러나 심층 모델을 훈련 할 때 관찰하는 현상에 대한 투기 적 직관과 진정한 설명을 구분해야합니다.더 단순한 심층 신경망 (MLP 및 기존 CNN) 이 처음부터 잘 일반화되는 이유조차 알지 못합니다.드롭 아웃 및 체중 감소에도 불구하고 기존의 학습 이론적 일반화 보증을 통해 보이지 않는 데이터로 일반화하는 능력을 설명 할 수 없을 정도로 유연합니다.
 
-배치 정규화를 제안하는 원본 논문에서 저자는 강력하고 유용한 도구를 소개하는 것 외에도 내부 공변량 이동*을 줄임으로써 작동 이유에 대한 설명을 제공했습니다.아마도*내부 공변량 이동*에 의해 저자는 위에 표현된 직관, 즉 훈련 과정에서 변수 값의 분포가 변한다는 개념과 같은 것을 의미했을 것입니다.그러나이 설명에는 두 가지 문제가있었습니다. i) 이 드리프트는*공변량 이동*과 매우 다르므로 이름을 잘못된 명칭으로 만듭니다. ii) 설명은 지정되지 않은 직관을 제공하지만*이 기술이 정확히 작동하는 이유*에 대한 질문을 엄격한 설명을 원하는 열린 질문입니다..이 책 전체에서 우리는 실무자가 심층 신경망 개발을 안내하는 데 사용하는 직관을 전달하는 것을 목표로합니다.그러나 우리는 이러한 지침 직관을 확립 된 과학적 사실과 분리하는 것이 중요하다고 생각합니다.결국, 이 자료를 숙달하고 자신의 연구 논문을 작성하기 시작할 때 기술적 주장과 직감을 명확하게 묘사하고 싶을 것입니다. 
+배치 정규화를 제안하는 원본 논문에서 저자는 강력하고 유용한 도구를 소개하는 것 외에도 내부 공변량 이동*을 줄임으로써 작동 이유에 대한 설명을 제공했습니다.아마도*내부 공변량 이동*에 의해 저자는 위에 표현된 직관, 즉 훈련 과정에서 변수 값의 분포가 변한다는 개념과 같은 것을 의미했을 것입니다.그러나이 설명에는 두 가지 문제가있었습니다. i) 이 드리프트는*공변량 이동*과 매우 다르므로 이름을 잘못된 명칭으로 만듭니다. ii) 설명은 지정되지 않은 직관을 제공하지만*이 기술이 정확히 작동하는 이유*에 대한 질문을 엄격한 설명을 원하는 열린 질문입니다..이 책 전체에서 우리는 실무자가 심층 신경망 개발을 안내하는 데 사용하는 직관을 전달하는 것을 목표로합니다.그러나 우리는 이러한 지침 직관을 확립 된 과학적 사실과 분리하는 것이 중요하다고 생각합니다.결국, 이 자료를 숙달하고 자신의 연구 논문을 작성하기 시작할 때 기술적 주장과 직감을 명확하게 묘사하고 싶을 것입니다.
 
-배치 정규화의 성공에 이어, *내부 공변량 이동*에 대한 설명은 기술 문헌의 논쟁과 기계 학습 연구를 제시하는 방법에 대한 광범위한 담론에서 반복적으로 드러났습니다.2017 NeuRips 컨퍼런스에서 Test of Time Award를 수락하면서 기억에 남는 연설에서 Ali Rahimi는 딥 러닝의 현대 관행을 연금술에 비유하는 논쟁에서*내부 공변량 이동*을 초점으로 사용했습니다.그 후 기계 학습 :cite:`Lipton.Steinhardt.2018`의 문제가되는 추세를 요약 한 직책 논문에서 예제를 자세히 다시 검토했습니다.다른 저자들은 배치 정규화의 성공에 대한 대체 설명을 제안했으며, 일부는 원본 논문 :cite:`Santurkar.Tsipras.Ilyas.ea.2018`에서 주장한 것과 반대되는 동작을 보였음에도 불구하고 배치 정규화의 성공이 발생한다고 주장합니다. 
+배치 정규화의 성공에 이어, *내부 공변량 이동*에 대한 설명은 기술 문헌의 논쟁과 기계 학습 연구를 제시하는 방법에 대한 광범위한 담론에서 반복적으로 드러났습니다.2017 NeuRips 컨퍼런스에서 Test of Time Award를 수락하면서 기억에 남는 연설에서 Ali Rahimi는 딥 러닝의 현대 관행을 연금술에 비유하는 논쟁에서*내부 공변량 이동*을 초점으로 사용했습니다.그 후 기계 학습 :cite:`Lipton.Steinhardt.2018`의 문제가되는 추세를 요약 한 직책 논문에서 예제를 자세히 다시 검토했습니다.다른 저자들은 배치 정규화의 성공에 대한 대체 설명을 제안했으며, 일부는 원본 논문 :cite:`Santurkar.Tsipras.Ilyas.ea.2018`에서 주장한 것과 반대되는 동작을 보였음에도 불구하고 배치 정규화의 성공이 발생한다고 주장합니다.
 
-*내부 공변량 이동*은 기술 기계 학습 문헌에서 매년 수천 건의 유사한 모호한 주장보다 더 이상 비판의 가치가 없다는 점에 주목합니다.아마도 이러한 논쟁의 초점으로서의 공명은 대상 청중에 대한 광범위한 인식 가능성 때문일 것입니다.배치 정규화는 거의 모든 배포된 이미지 분류기에 적용되는 필수 방법임이 입증되어 수만 건의 인용 기법을 도입한 논문을 얻었습니다. 
+*내부 공변량 이동*은 기술 기계 학습 문헌에서 매년 수천 건의 유사한 모호한 주장보다 더 이상 비판의 가치가 없다는 점에 주목합니다.아마도 이러한 논쟁의 초점으로서의 공명은 대상 청중에 대한 광범위한 인식 가능성 때문일 것입니다.배치 정규화는 거의 모든 배포된 이미지 분류기에 적용되는 필수 방법임이 입증되어 수만 건의 인용 기법을 도입한 논문을 얻었습니다.
 
 ## 요약
 
diff --git a/chapter_convolutional-neural-networks/conv-layer.md b/chapter_convolutional-neural-networks/conv-layer.md
index cb4541c2..c46e0ee0 100644
--- a/chapter_convolutional-neural-networks/conv-layer.md
+++ b/chapter_convolutional-neural-networks/conv-layer.md
@@ -1,18 +1,18 @@
 # 이미지에 대한 컨볼루션
 :label:`sec_conv_layer`
 
-이제 컨벌루션 계층이 이론적으로 작동하는 방식을 이해했으므로 실제로 어떻게 작동하는지 확인할 준비가 되었습니다.이미지 데이터의 구조를 탐색하기 위한 효율적인 아키텍처로서 컨벌루션 신경망의 동기를 기반으로 이미지를 실행 예제로 사용합니다. 
+이제 컨벌루션 계층이 이론적으로 작동하는 방식을 이해했으므로 실제로 어떻게 작동하는지 확인할 준비가 되었습니다.이미지 데이터의 구조를 탐색하기 위한 효율적인 아키텍처로서 컨벌루션 신경망의 동기를 기반으로 이미지를 실행 예제로 사용합니다.
 
 ## 상호 상관 연산
 
-엄밀히 말하면 컨벌루션 계층이 표현하는 연산이 상호 상관 관계로 더 정확하게 설명되기 때문에 컨벌루션 계층은 잘못된 이름입니다.:numref:`sec_why-conv`의 컨벌루션 계층에 대한 설명을 기반으로 이러한 계층에서 입력 텐서와 커널 텐서가 결합되어 (**상호 상관 연산**) 을 통해 출력 텐서를 생성합니다. 
+엄밀히 말하면 컨벌루션 계층이 표현하는 연산이 상호 상관 관계로 더 정확하게 설명되기 때문에 컨벌루션 계층은 잘못된 이름입니다.:numref:`sec_why-conv`의 컨벌루션 계층에 대한 설명을 기반으로 이러한 계층에서 입력 텐서와 커널 텐서가 결합되어 (**상호 상관 연산**) 을 통해 출력 텐서를 생성합니다.
 
-지금은 채널을 무시하고 2차원 데이터 및 숨겨진 표현에서 어떻게 작동하는지 살펴 보겠습니다.:numref:`fig_correlation`에서 입력은 높이가 3이고 너비가 3인 2차원 텐서입니다.텐서의 모양을 $3 \times 3$ 또는 ($3$, $3$) 으로 표시합니다.커널의 높이와 너비는 모두 2입니다.*커널 창* (또는*컨볼루션 창*) 의 모양은 커널의 높이와 너비로 지정됩니다 (여기서는 $2 \times 2$입니다). 
+지금은 채널을 무시하고 2차원 데이터 및 숨겨진 표현에서 어떻게 작동하는지 살펴 보겠습니다.:numref:`fig_correlation`에서 입력은 높이가 3이고 너비가 3인 2차원 텐서입니다.텐서의 모양을 $3 \times 3$ 또는 ($3$, $3$) 으로 표시합니다.커널의 높이와 너비는 모두 2입니다.*커널 창* (또는*컨볼루션 창*) 의 모양은 커널의 높이와 너비로 지정됩니다 (여기서는 $2 \times 2$입니다).
 
 ![Two-dimensional cross-correlation operation. The shaded portions are the first output element as well as the input and kernel tensor elements used for the output computation: $0\times0+1\times1+3\times2+4\times3=19$.](../img/correlation.svg)
 :label:`fig_correlation`
 
-2 차원 상호 상관 연산에서는 입력 텐서의 왼쪽 상단 모서리에 위치한 컨볼 루션 창에서 시작하여 왼쪽에서 오른쪽으로, 위에서 아래로 입력 텐서를 가로 질러 슬라이드합니다.컨볼 루션 창이 특정 위치로 미끄러지면 해당 창에 포함 된 입력 서브 텐서와 커널 텐서가 요소별로 곱해지고 결과 텐서가 합산되어 단일 스칼라 값이 생성됩니다.이 결과는 해당 위치에서 출력 텐서의 값을 제공합니다.여기서 출력 텐서의 높이는 2이고 너비는 2이며 네 개의 요소는 2차원 상호 상관 연산에서 파생됩니다. 
+2 차원 상호 상관 연산에서는 입력 텐서의 왼쪽 상단 모서리에 위치한 컨볼 루션 창에서 시작하여 왼쪽에서 오른쪽으로, 위에서 아래로 입력 텐서를 가로 질러 슬라이드합니다.컨볼 루션 창이 특정 위치로 미끄러지면 해당 창에 포함 된 입력 서브 텐서와 커널 텐서가 요소별로 곱해지고 결과 텐서가 합산되어 단일 스칼라 값이 생성됩니다.이 결과는 해당 위치에서 출력 텐서의 값을 제공합니다.여기서 출력 텐서의 높이는 2이고 너비는 2이며 네 개의 요소는 2차원 상호 상관 연산에서 파생됩니다.
 
 $$
 0\times0+1\times1+3\times2+4\times3=19,\\
@@ -21,7 +21,7 @@ $$
 4\times0+5\times1+7\times2+8\times3=43.
 $$
 
-각 축을 따라 출력 크기는 입력 크기보다 약간 작습니다.커널의 너비와 높이가 1보다 크기 때문에 커널이 이미지 내에 완전히 맞는 위치에 대해서만 상호 상관을 올바르게 계산할 수 있습니다. 출력 크기는 입력 크기 $n_h \times n_w$에서 다음을 통해 컨볼루션 커널 $k_h \times k_w$의 크기를 뺀 값으로 계산됩니다. 
+각 축을 따라 출력 크기는 입력 크기보다 약간 작습니다.커널의 너비와 높이가 1보다 크기 때문에 커널이 이미지 내에 완전히 맞는 위치에 대해서만 상호 상관을 올바르게 계산할 수 있습니다. 출력 크기는 입력 크기 $n_h \times n_w$에서 다음을 통해 컨볼루션 커널 $k_h \times k_w$의 크기를 뺀 값으로 계산됩니다.
 
 $$(n_h-k_h+1) \times (n_w-k_w+1).$$
 
@@ -80,7 +80,7 @@ corr2d(X, K)
 
 ## 컨벌루션 계층
 
-컨벌루션 계층은 입력값과 커널을 교차 상관시키고 스칼라 바이어스를 추가하여 출력값을 생성합니다.컨벌루션 계층의 두 파라미터는 커널과 스칼라 편향입니다.컨벌루션 계층을 기반으로 모델을 훈련시킬 때는 일반적으로 완전 연결 계층에서와 마찬가지로 커널을 무작위로 초기화합니다. 
+컨벌루션 계층은 입력값과 커널을 교차 상관시키고 스칼라 바이어스를 추가하여 출력값을 생성합니다.컨벌루션 계층의 두 파라미터는 커널과 스칼라 편향입니다.컨벌루션 계층을 기반으로 모델을 훈련시킬 때는 일반적으로 완전 연결 계층에서와 마찬가지로 커널을 무작위로 초기화합니다.
 
 이제 위에서 정의한 `corr2d` 함수를 기반으로 [**2차원 컨벌루션 계층을 구현**] 할 준비가 되었습니다.`__init__` 생성자 함수에서 `weight` 및 `bias`를 두 개의 모델 매개 변수로 선언합니다.순방향 전파 함수는 `corr2d` 함수를 호출하고 바이어스를 추가합니다.
 
@@ -124,7 +124,7 @@ class Conv2D(tf.keras.layers.Layer):
         return corr2d(inputs, self.weight) + self.bias
 ```
 
-$h \times w$ 컨볼루션 또는 $h \times w$ 컨볼루션 커널에서 컨볼루션 커널의 높이와 너비는 각각 $h$와 $w$입니다.또한 $h \times w$ 컨벌루션 커널이 있는 컨벌루션 계층을 간단히 $h \times w$ 컨벌루션 계층이라고 합니다. 
+$h \times w$ 컨볼루션 또는 $h \times w$ 컨볼루션 커널에서 컨볼루션 커널의 높이와 너비는 각각 $h$와 $w$입니다.또한 $h \times w$ 컨벌루션 커널이 있는 컨벌루션 계층을 간단히 $h \times w$ 컨벌루션 계층이라고 합니다.
 
 ## 이미지의 객체 가장자리 감지
 
@@ -168,9 +168,9 @@ corr2d(d2l.transpose(X), K)
 
 ## 커널 학습
 
-유한 차분 `[1, -1]`로 에지 검출기를 설계하는 것은 이것이 우리가 찾고있는 것임을 정확히 알고 있다면 깔끔합니다.그러나 더 큰 커널을 살펴보고 연속적인 컨벌루션 계층을 고려할 때 각 필터가 수동으로 수행해야 할 작업을 정확하게 지정하는 것은 불가능할 수 있습니다. 
+유한 차분 `[1, -1]`로 에지 검출기를 설계하는 것은 이것이 우리가 찾고있는 것임을 정확히 알고 있다면 깔끔합니다.그러나 더 큰 커널을 살펴보고 연속적인 컨벌루션 계층을 고려할 때 각 필터가 수동으로 수행해야 할 작업을 정확하게 지정하는 것은 불가능할 수 있습니다.
 
-이제 입력-출력 쌍만 살펴봄으로써 [**`X`**에서 `Y`를 생성한 커널을 학습할 수 있는지 살펴보겠습니다.먼저 컨볼 루션 계층을 만들고 커널을 랜덤 텐서로 초기화합니다.다음으로 각 반복에서 제곱 오차를 사용하여 `Y`를 컨벌루션 계층의 출력값과 비교합니다.그런 다음 기울기를 계산하여 커널을 업데이트할 수 있습니다.단순화를 위해 다음에서는 2차원 컨벌루션 계층에 내장 클래스를 사용하고 바이어스를 무시합니다.
+이제 입력-출력 쌍만 살펴봄으로써 [**`X`**]에서 `Y`를 생성한 커널을 학습할 수 있는지 살펴보겠습니다.먼저 컨볼 루션 계층을 만들고 커널을 랜덤 텐서로 초기화합니다.다음으로 각 반복에서 제곱 오차를 사용하여 `Y`를 컨벌루션 계층의 출력값과 비교합니다.그런 다음 기울기를 계산하여 커널을 업데이트할 수 있습니다.단순화를 위해 다음에서는 2차원 컨벌루션 계층에 내장 클래스를 사용하고 바이어스를 무시합니다.
 
 ```{.python .input}
 # Construct a two-dimensional convolutional layer with 1 output channel and a
@@ -264,23 +264,23 @@ d2l.reshape(conv2d.weight.data, (1, 2))
 d2l.reshape(conv2d.get_weights()[0], (1, 2))
 ```
 
-실제로 학습된 커널 텐서는 앞서 정의한 커널 텐서 `K`에 매우 가깝습니다. 
+실제로 학습된 커널 텐서는 앞서 정의한 커널 텐서 `K`에 매우 가깝습니다.
 
 ## 교차 상관 및 컨볼루션
 
-교차 상관 연산과 컨볼루션 연산 간의 대응에 대한 :numref:`sec_why-conv`의 관찰을 상기하십시오.여기서는 2 차원 컨볼 루션 계층을 계속 고려해 보겠습니다.이러한 계층이 교차 상관 대신 :eqref:`eq_2d-conv-discrete`에 정의된 대로 엄격한 컨벌루션 연산을 수행하면 어떻게 될까요?엄격한* 컨볼 루션* 연산의 출력을 얻으려면 2 차원 커널 텐서를 수평 및 수직으로 뒤집은 다음 입력 텐서로* 상호 상관 관계* 연산을 수행하면됩니다. 
+교차 상관 연산과 컨볼루션 연산 간의 대응에 대한 :numref:`sec_why-conv`의 관찰을 상기하십시오.여기서는 2 차원 컨볼 루션 계층을 계속 고려해 보겠습니다.이러한 계층이 교차 상관 대신 :eqref:`eq_2d-conv-discrete`에 정의된 대로 엄격한 컨벌루션 연산을 수행하면 어떻게 될까요?엄격한* 컨볼 루션* 연산의 출력을 얻으려면 2 차원 커널 텐서를 수평 및 수직으로 뒤집은 다음 입력 텐서로* 상호 상관 관계* 연산을 수행하면됩니다.
 
-커널은 딥러닝의 데이터에서 학습되므로 컨벌루션 계층의 출력값은 이러한 계층이 엄격한 컨벌루션 연산이나 상호 상관 연산을 수행하더라도 영향을 받지 않습니다. 
+커널은 딥러닝의 데이터에서 학습되므로 컨벌루션 계층의 출력값은 이러한 계층이 엄격한 컨벌루션 연산이나 상호 상관 연산을 수행하더라도 영향을 받지 않습니다.
 
-이를 설명하기 위해 컨벌루션 계층이*교차 상관 관계*를 수행하고 :numref:`fig_correlation`에서 커널을 학습한다고 가정합니다. 이 커널은 여기서 행렬 $\mathbf{K}$으로 표시됩니다.다른 조건이 변경되지 않는다고 가정할 때, 이 계층이 엄격한*컨벌루션*을 대신 수행하면 $\mathbf{K}'$가 가로 및 세로로 뒤집힌 후 학습된 커널 $\mathbf{K}'$는 $\mathbf{K}$과 같습니다.즉, 컨벌루션 계층이 :numref:`fig_correlation` 및 $\mathbf{K}'$의 입력에 대해 엄격한*컨벌루션*을 수행하면 :numref:`fig_correlation`에서 동일한 출력 (입력과 $\mathbf{K}$의 상호 상관) 이 얻어집니다. 
+이를 설명하기 위해 컨벌루션 계층이*교차 상관 관계*를 수행하고 :numref:`fig_correlation`에서 커널을 학습한다고 가정합니다. 이 커널은 여기서 행렬 $\mathbf{K}$으로 표시됩니다.다른 조건이 변경되지 않는다고 가정할 때, 이 계층이 엄격한*컨벌루션*을 대신 수행하면 $\mathbf{K}'$가 가로 및 세로로 뒤집힌 후 학습된 커널 $\mathbf{K}'$는 $\mathbf{K}$과 같습니다.즉, 컨벌루션 계층이 :numref:`fig_correlation` 및 $\mathbf{K}'$의 입력에 대해 엄격한*컨벌루션*을 수행하면 :numref:`fig_correlation`에서 동일한 출력 (입력과 $\mathbf{K}$의 상호 상관) 이 얻어집니다.
 
-딥 러닝 문헌의 표준 용어에 따라 엄격하게 말하면 약간 다르더라도 상호 상관 연산을 컨볼루션이라고 계속 지칭할 것입니다.게다가*요소*라는 용어를 사용하여 계층 표현 또는 컨볼 루션 커널을 나타내는 텐서의 항목 (또는 구성 요소) 을 나타냅니다. 
+딥 러닝 문헌의 표준 용어에 따라 엄격하게 말하면 약간 다르더라도 상호 상관 연산을 컨볼루션이라고 계속 지칭할 것입니다.게다가*요소*라는 용어를 사용하여 계층 표현 또는 컨볼 루션 커널을 나타내는 텐서의 항목 (또는 구성 요소) 을 나타냅니다.
 
 ## 특징 맵 및 수용 필드
 
-:numref:`subsec_why-conv-channels`에서 설명한 대로 :numref:`fig_correlation`의 컨벌루션 계층 출력값은*특징 맵*이라고도 합니다. 이는 후속 계층에 대한 공간 차원 (예: 너비 및 높이) 에서 학습된 표현 (특징) 으로 간주될 수 있기 때문입니다.CNN에서 일부 층의 모든 요소 $x$에 대해*수용 필드*는 순방향 전파 중에 $x$의 계산에 영향을 미칠 수 있는 모든 요소 (이전 계층의 모든 요소) 를 나타냅니다.수신 필드는 입력의 실제 크기보다 클 수 있습니다. 
+:numref:`subsec_why-conv-channels`에서 설명한 대로 :numref:`fig_correlation`의 컨벌루션 계층 출력값은*특징 맵*이라고도 합니다. 이는 후속 계층에 대한 공간 차원 (예: 너비 및 높이) 에서 학습된 표현 (특징) 으로 간주될 수 있기 때문입니다.CNN에서 일부 층의 모든 요소 $x$에 대해*수용 필드*는 순방향 전파 중에 $x$의 계산에 영향을 미칠 수 있는 모든 요소 (이전 계층의 모든 요소) 를 나타냅니다.수신 필드는 입력의 실제 크기보다 클 수 있습니다.
 
-수용 분야를 설명하기 위해 :numref:`fig_correlation`를 계속 사용하겠습니다.$2 \times 2$ 컨벌루션 커널이 주어지면 음영처리된 출력 요소 (값 $19$) 의 수용 필드는 입력의 음영 부분에 있는 4개의 요소입니다.이제 $2 \times 2$ 출력을 $\mathbf{Y}$으로 표시하고 $\mathbf{Y}$을 입력으로 사용하여 단일 요소 $z$을 출력하는 추가 $2 \times 2$ 컨벌루션 계층이 있는 더 깊은 CNN을 고려해 보겠습니다.이 경우 $\mathbf{Y}$의 $z$의 수용 필드에는 $\mathbf{Y}$의 네 가지 요소가 모두 포함되는 반면 입력의 수용 필드에는 9개의 입력 요소가 모두 포함됩니다.따라서 피처 맵의 요소가 더 넓은 영역에서 입력 피처를 감지하기 위해 더 큰 수용 필드가 필요한 경우 더 깊은 네트워크를 구축 할 수 있습니다. 
+수용 분야를 설명하기 위해 :numref:`fig_correlation`를 계속 사용하겠습니다.$2 \times 2$ 컨벌루션 커널이 주어지면 음영처리된 출력 요소 (값 $19$) 의 수용 필드는 입력의 음영 부분에 있는 4개의 요소입니다.이제 $2 \times 2$ 출력을 $\mathbf{Y}$으로 표시하고 $\mathbf{Y}$을 입력으로 사용하여 단일 요소 $z$을 출력하는 추가 $2 \times 2$ 컨벌루션 계층이 있는 더 깊은 CNN을 고려해 보겠습니다.이 경우 $\mathbf{Y}$의 $z$의 수용 필드에는 $\mathbf{Y}$의 네 가지 요소가 모두 포함되는 반면 입력의 수용 필드에는 9개의 입력 요소가 모두 포함됩니다.따라서 피처 맵의 요소가 더 넓은 영역에서 입력 피처를 감지하기 위해 더 큰 수용 필드가 필요한 경우 더 깊은 네트워크를 구축 할 수 있습니다.
 
 ## 요약
 
diff --git a/chapter_deep-learning-computation/read-write.md b/chapter_deep-learning-computation/read-write.md
index 7feb24cb..dc42fe4a 100644
--- a/chapter_deep-learning-computation/read-write.md
+++ b/chapter_deep-learning-computation/read-write.md
@@ -1,6 +1,6 @@
 # 파일 입출력
 
-지금까지 데이터를 처리하는 방법과 딥 러닝 모델을 구축, 학습 및 테스트하는 방법에 대해 논의했습니다.그러나 어느 시점에서는 나중에 다양한 컨텍스트에서 사용할 수 있도록 결과를 저장하려는 학습 된 모델에 충분히 만족할 것입니다 (아마도 배포 중에 예측을 수행하기 위해).또한 긴 교육 프로세스를 실행할 때 가장 좋은 방법은 서버의 전원 코드를 넘어갈 때 며칠 분량의 계산을 잃지 않도록 중간 결과 (체크 포인트) 를 주기적으로 저장하는 것입니다.따라서 개별 가중치 벡터와 전체 모델을 로드하고 저장하는 방법을 배워야 할 때입니다.이 섹션에서는 두 가지 문제를 모두 다룹니다. 
+지금까지 데이터를 처리하는 방법과 딥 러닝 모델을 구축, 학습 및 테스트하는 방법에 대해 논의했습니다.그러나 어느 시점에서는 나중에 다양한 컨텍스트에서 사용할 수 있도록 결과를 저장하려는 학습 된 모델에 충분히 만족할 것입니다 (아마도 배포 중에 예측을 수행하기 위해).또한 긴 교육 프로세스를 실행할 때 가장 좋은 방법은 서버의 전원 코드를 넘어갈 때 며칠 분량의 계산을 잃지 않도록 중간 결과 (체크 포인트) 를 주기적으로 저장하는 것입니다.따라서 개별 가중치 벡터와 전체 모델을 로드하고 저장하는 방법을 배워야 할 때입니다.이 섹션에서는 두 가지 문제를 모두 다룹니다.
 
 ## (**텐서 로드 및 저장**)
 
@@ -78,7 +78,7 @@ x2, y2 = np.load('xy-files.npy', allow_pickle=True)
 (x2, y2)
 ```
 
-[**문자열에서 텐서로 매핑되는 딕셔너리를 작성하고 읽기**] 도 가능합니다.**] 모델의 모든 가중치를 읽거나 쓰고 싶을 때 편리합니다.
+[**문자열에서 텐서로 매핑되는 딕셔너리를 작성하고 읽기**] 도 가능합니다. 모델의 모든 가중치를 읽거나 쓰고 싶을 때 편리합니다.
 
 ```{.python .input}
 mydict = {'x': x, 'y': y}
diff --git a/chapter_linear-networks/linear-regression-scratch.md b/chapter_linear-networks/linear-regression-scratch.md
index 82ba1d95..71ac1c64 100644
--- a/chapter_linear-networks/linear-regression-scratch.md
+++ b/chapter_linear-networks/linear-regression-scratch.md
@@ -29,11 +29,11 @@ import random
 
 ## 데이터세트 생성
 
-단순하게 유지하기 위해 [**가산 잡음이 있는 선형 모델에 따라 인공 데이터 세트를 구성합니다.**] 우리의 임무는 데이터 세트에 포함된 유한 예제 세트를 사용하여 이 모델의 매개 변수를 복구하는 것입니다.데이터를 쉽게 시각화할 수 있도록 저차원으로 유지할 것입니다.다음 코드 스니펫에서는 표준 정규분포에서 샘플링된 2개의 피처로 구성된 1000개의 예제가 포함된 데이터세트를 생성합니다.따라서 우리의 합성 데이터셋은 행렬 $\mathbf{X}\in \mathbb{R}^{1000 \times 2}$가 될 것입니다. 
+단순하게 유지하기 위해 [**가산 잡음이 있는 선형 모델에 따라 인공 데이터 세트를 구성합니다.**] 우리의 임무는 데이터 세트에 포함된 유한 예제 세트를 사용하여 이 모델의 매개 변수를 복구하는 것입니다.데이터를 쉽게 시각화할 수 있도록 저차원으로 유지할 것입니다.다음 코드 스니펫에서는 표준 정규분포에서 샘플링된 2개의 피처로 구성된 1000개의 예제가 포함된 데이터세트를 생성합니다.따라서 우리의 합성 데이터셋은 행렬 $\mathbf{X}\in \mathbb{R}^{1000 \times 2}$가 될 것입니다.
 
-(**데이터 세트를 생성하는 실제 매개 변수는 $\mathbf{w} = [2, -3.4]^\top$ 및 $b = 4.2$이며, **) 합성 레이블은 노이즈 용어 $\epsilon$을 사용하는 다음 선형 모델에 따라 할당됩니다. 
+(**데이터 세트를 생성하는 실제 매개 변수는 $\mathbf{w} = [2, -3.4]^\top$ 및 $b = 4.2$이며, **) 합성 레이블은 노이즈 용어 $\epsilon$을 사용하는 다음 선형 모델에 따라 할당됩니다.
 
-(**$\mathbf{y}= \mathbf{X} \mathbf{w} + b + \mathbf\epsilon.$달러**) 
+(**$\mathbf{y}= \mathbf{X} \mathbf{w} + b + \mathbf\epsilon.$달러**)
 
 $\epsilon$는 피처와 라벨에 잠재적인 측정 오류를 캡처하는 것으로 생각할 수 있습니다.표준 가정이 유지되고 따라서 $\epsilon$가 평균이 0인 정규 분포를 따른다고 가정합니다.문제를 쉽게 해결하기 위해 표준 편차를 0.01로 설정합니다.다음 코드는 합성 데이터세트를 생성합니다.
 
@@ -84,9 +84,9 @@ d2l.plt.scatter(d2l.numpy(features[:, 1]), d2l.numpy(labels), 1);
 
 ## 데이터세트 읽기
 
-학습 모델은 데이터 세트를 여러 번 통과하고 한 번에 하나의 미니 배치를 가져 와서 모델을 업데이트하는 데 사용하는 것으로 구성됩니다.이 과정은 기계 학습 알고리즘을 훈련시키는 데 매우 중요하므로 데이터 세트를 섞고 미니 배치로 액세스하는 유틸리티 함수를 정의하는 것이 좋습니다. 
+학습 모델은 데이터 세트를 여러 번 통과하고 한 번에 하나의 미니 배치를 가져 와서 모델을 업데이트하는 데 사용하는 것으로 구성됩니다.이 과정은 기계 학습 알고리즘을 훈련시키는 데 매우 중요하므로 데이터 세트를 섞고 미니 배치로 액세스하는 유틸리티 함수를 정의하는 것이 좋습니다.
 
-다음 코드에서는 [**`data_iter` 함수**](~~that~~) 를 정의하여 이 기능의 구현 가능한 한 가지를 보여줍니다.함수 (**배치 크기, 특징 행렬, 레이블 벡터를 취하여 크기가 `batch_size`.**인 미니배치를 산출함) 각 미니배치는 특징과 레이블의 튜플로 구성됩니다.
+다음 코드에서는 [**`data_iter` 함수**](~~that~~) 를 정의하여 이 기능의 구현 가능한 한 가지를 보여줍니다.함수 (**배치 크기, 특징 행렬, 레이블 벡터를 취하여 크기가 `batch_size`.**)인 미니배치를 산출함  각 미니배치는 특징과 레이블의 튜플로 구성됩니다.
 
 ```{.python .input}
 #@tab mxnet, pytorch
@@ -113,7 +113,7 @@ def data_iter(batch_size, features, labels):
         yield tf.gather(features, j), tf.gather(labels, j)
 ```
 
-일반적으로 우리는 연산을 병렬화하는 데 탁월한 GPU 하드웨어를 활용하기 위해 적당한 크기의 미니 배치를 사용하고 싶습니다.각 예제는 모델을 통해 병렬로 공급할 수 있고 각 예제에 대한 손실 함수의 기울기도 병렬로 취할 수 있기 때문에 GPU를 사용하면 단일 예제를 처리하는 데 걸리는 시간보다 훨씬 더 많은 시간 내에 수백 개의 예제를 처리 할 수 있습니다. 
+일반적으로 우리는 연산을 병렬화하는 데 탁월한 GPU 하드웨어를 활용하기 위해 적당한 크기의 미니 배치를 사용하고 싶습니다.각 예제는 모델을 통해 병렬로 공급할 수 있고 각 예제에 대한 손실 함수의 기울기도 병렬로 취할 수 있기 때문에 GPU를 사용하면 단일 예제를 처리하는 데 걸리는 시간보다 훨씬 더 많은 시간 내에 수백 개의 예제를 처리 할 수 있습니다.
 
 직관을 구축하기 위해 데이터 예제의 첫 번째 작은 배치를 읽고 인쇄해 보겠습니다.각 미니배치의 피처 모양은 미니배치 크기와 입력 피처 수를 모두 알려줍니다.마찬가지로 라벨의 미니 배치는 `batch_size`에 의해 주어진 모양을 갖습니다.
 
@@ -126,7 +126,7 @@ for X, y in data_iter(batch_size, features, labels):
     break
 ```
 
-반복을 실행할 때 전체 데이터셋이 모두 소진될 때까지 고유한 미니배치를 연속적으로 얻습니다 (이렇게 해 보십시오).위에서 구현한 반복은 교훈적인 목적으로는 좋지만 실제 문제에 어려움을 겪을 수 있는 방식에서는 비효율적입니다.예를 들어 메모리에 모든 데이터를 로드하고 많은 랜덤 메모리 액세스를 수행해야 합니다.딥러닝 프레임워크에 구현된 내장 반복기는 훨씬 더 효율적이며 파일에 저장된 데이터와 데이터 스트림을 통해 공급되는 데이터를 모두 처리할 수 있습니다. 
+반복을 실행할 때 전체 데이터셋이 모두 소진될 때까지 고유한 미니배치를 연속적으로 얻습니다 (이렇게 해 보십시오).위에서 구현한 반복은 교훈적인 목적으로는 좋지만 실제 문제에 어려움을 겪을 수 있는 방식에서는 비효율적입니다.예를 들어 메모리에 모든 데이터를 로드하고 많은 랜덤 메모리 액세스를 수행해야 합니다.딥러닝 프레임워크에 구현된 내장 반복기는 훨씬 더 효율적이며 파일에 저장된 데이터와 데이터 스트림을 통해 공급되는 데이터를 모두 처리할 수 있습니다.
 
 ## 모델 매개변수 초기화
 
@@ -152,13 +152,13 @@ w = tf.Variable(tf.random.normal(shape=(2, 1), mean=0, stddev=0.01),
 b = tf.Variable(tf.zeros(1), trainable=True)
 ```
 
-매개 변수를 초기화한 후 다음 작업은 데이터가 충분히 잘 맞을 때까지 매개 변수를 업데이트하는 것입니다.업데이트 할 때마다 매개 변수와 관련하여 손실 함수의 기울기를 취해야합니다.이 기울기가 주어지면 손실을 줄일 수 있는 방향으로 각 파라미터를 업데이트할 수 있습니다. 
+매개 변수를 초기화한 후 다음 작업은 데이터가 충분히 잘 맞을 때까지 매개 변수를 업데이트하는 것입니다.업데이트 할 때마다 매개 변수와 관련하여 손실 함수의 기울기를 취해야합니다.이 기울기가 주어지면 손실을 줄일 수 있는 방향으로 각 파라미터를 업데이트할 수 있습니다.
 
-아무도 그라디언트를 명시적으로 계산하기를 원하지 않기 때문에 (지루하고 오류가 발생하기 쉽습니다) :numref:`sec_autograd`에 소개된 자동 미분을 사용하여 그래디언트를 계산합니다. 
+아무도 그라디언트를 명시적으로 계산하기를 원하지 않기 때문에 (지루하고 오류가 발생하기 쉽습니다) :numref:`sec_autograd`에 소개된 자동 미분을 사용하여 그래디언트를 계산합니다.
 
 ## 모델 정의
 
-다음으로, 입력과 파라미터를 출력에 연결하여 모델을 정의해야 합니다.**] 선형 모델의 출력을 계산하려면 입력 피처 $\mathbf{X}$와 모델 가중치 $\mathbf{w}$의 행렬-벡터 내적을 가져와 각 예제에 오프셋 $b$을 추가하기만 하면 됩니다.$\mathbf{Xw}$ 아래는 벡터이고 $b$은 스칼라입니다.:numref:`subsec_broadcasting`에 설명된 대로 방송 메커니즘을 호출합니다.벡터와 스칼라를 추가하면 벡터의 각 구성 요소에 스칼라가 추가됩니다.
+다음으로, 입력과 파라미터를 출력에 연결하여 모델을 정의해야 합니다. 선형 모델의 출력을 계산하려면 입력 피처 $\mathbf{X}$와 모델 가중치 $\mathbf{w}$의 행렬-벡터 내적을 가져와 각 예제에 오프셋 $b$을 추가하기만 하면 됩니다.$\mathbf{Xw}$ 아래는 벡터이고 $b$은 스칼라입니다.:numref:`subsec_broadcasting`에 설명된 대로 방송 메커니즘을 호출합니다.벡터와 스칼라를 추가하면 벡터의 각 구성 요소에 스칼라가 추가됩니다.
 
 ```{.python .input}
 #@tab all
@@ -180,7 +180,7 @@ def squared_loss(y_hat, y):  #@save
 
 ## 최적화 알고리즘 정의
 
-:numref:`sec_linear_regression`에서 논의한 것처럼 선형 회귀에는 폐쇄 형식 해가 있습니다.그러나 이 책은 선형 회귀에 관한 책이 아니라 딥 러닝에 관한 책입니다.이 책에서 소개하는 다른 모델은 분석적으로 해결할 수 없으므로 이번 기회에 미니 배치 확률 적 경사 하강의 첫 번째 작업 예를 소개하겠습니다.[~~선형 회귀 분석에는 폐쇄 형식 해가 있지만, 이 책의 다른 모델은 그렇지 않습니다.여기에서는 미니배치 스토캐스틱 그래디언트 하강을 소개합니다. ~~] 
+:numref:`sec_linear_regression`에서 논의한 것처럼 선형 회귀에는 폐쇄 형식 해가 있습니다.그러나 이 책은 선형 회귀에 관한 책이 아니라 딥 러닝에 관한 책입니다.이 책에서 소개하는 다른 모델은 분석적으로 해결할 수 없으므로 이번 기회에 미니 배치 확률 적 경사 하강의 첫 번째 작업 예를 소개하겠습니다.[~~선형 회귀 분석에는 폐쇄 형식 해가 있지만, 이 책의 다른 모델은 그렇지 않습니다.여기에서는 미니배치 스토캐스틱 그래디언트 하강을 소개합니다. ~~]
 
 각 단계에서 데이터 세트에서 무작위로 추출한 하나의 미니 배치를 사용하여 매개 변수에 대한 손실의 기울기를 추정합니다.다음으로 손실을 줄일 수 있는 방향으로 매개변수를 업데이트합니다.다음 코드에서는 파라미터 집합, 학습률 및 배치 크기가 지정된 경우 미니배치 확률적 경사하강법 업데이트를 적용합니다.업데이트 단계의 크기는 학습 속도 `lr`에 의해 결정됩니다.손실은 예제의 미니 배치에 대한 합계로 계산되므로, 일반적인 스텝 크기의 크기가 배치 크기 선택에 크게 좌우되지 않도록 단계 크기를 배치 크기 (`batch_size`) 로 정규화합니다.
 
@@ -211,11 +211,11 @@ def sgd(params, grads, lr, batch_size):  #@save
 
 ## 트레이닝
 
-이제 모든 부분이 준비되었으므로 [**기본 교육 루프를 구현할 준비가 되었습니다.**] 딥 러닝 경력 전반에 걸쳐 거의 동일한 훈련 루프를 반복해서 볼 수 있으므로 이 코드를 이해하는 것이 중요합니다. 
+이제 모든 부분이 준비되었으므로 [**기본 교육 루프를 구현할 준비가 되었습니다.**] 딥 러닝 경력 전반에 걸쳐 거의 동일한 훈련 루프를 반복해서 볼 수 있으므로 이 코드를 이해하는 것이 중요합니다.
 
-각 반복에서 훈련 예제의 미니 배치를 가져와 모델에 전달하여 일련의 예측을 얻습니다.손실을 계산 한 후 각 매개 변수에 대한 기울기를 저장하여 네트워크를 통과하는 역방향 통과를 시작합니다.마지막으로 최적화 알고리즘 `sgd`를 호출하여 모델 파라미터를 업데이트합니다. 
+각 반복에서 훈련 예제의 미니 배치를 가져와 모델에 전달하여 일련의 예측을 얻습니다.손실을 계산 한 후 각 매개 변수에 대한 기울기를 저장하여 네트워크를 통과하는 역방향 통과를 시작합니다.마지막으로 최적화 알고리즘 `sgd`를 호출하여 모델 파라미터를 업데이트합니다.
 
-요약하면 다음 루프를 실행합니다. 
+요약하면 다음 루프를 실행합니다.
 
 * 매개 변수를 초기화합니다. $(\mathbf{w}, b)$
 * 완료될 때까지 반복
@@ -281,7 +281,7 @@ print(f'error in estimating w: {true_w - d2l.reshape(w, true_w.shape)}')
 print(f'error in estimating b: {true_b - b}')
 ```
 
-매개 변수를 완벽하게 복구 할 수 있다는 것을 당연하게 생각해서는 안됩니다.그러나 기계 학습에서는 일반적으로 실제 기본 매개 변수를 복구하는 데 관심이 적고 매우 정확한 예측으로 이어지는 매개 변수에 더 관심이 있습니다.다행스럽게도 어려운 최적화 문제에서도 확률적 경사 하강법은 심층 네트워크의 경우 매우 정확한 예측으로 이어지는 많은 파라미터 구성이 존재하기 때문에 매우 좋은 해를 찾을 수 있습니다. 
+매개 변수를 완벽하게 복구 할 수 있다는 것을 당연하게 생각해서는 안됩니다.그러나 기계 학습에서는 일반적으로 실제 기본 매개 변수를 복구하는 데 관심이 적고 매우 정확한 예측으로 이어지는 매개 변수에 더 관심이 있습니다.다행스럽게도 어려운 최적화 문제에서도 확률적 경사 하강법은 심층 네트워크의 경우 매우 정확한 예측으로 이어지는 많은 파라미터 구성이 존재하기 때문에 매우 좋은 해를 찾을 수 있습니다.
 
 ## 요약
 
diff --git a/chapter_linear-networks/softmax-regression-concise.md b/chapter_linear-networks/softmax-regression-concise.md
index 17541274..0f3ace33 100644
--- a/chapter_linear-networks/softmax-regression-concise.md
+++ b/chapter_linear-networks/softmax-regression-concise.md
@@ -1,7 +1,7 @@
 # 소프트맥스 회귀의 간결한 구현
 :label:`sec_softmax_concise`
 
-:numref:`sec_linear_concise`의 딥 러닝 프레임워크 (**선형 회귀 구현이 훨씬 쉬워졌습니다**) 의 (**상위 수준 API**와 마찬가지로), 분류 모델을 구현하는 데 편리합니다 (**비슷하게 찾을 수 있습니다**) (~~here~~) (또는 그 이상).패션-MNIST 데이터세트를 고수하고 :numref:`sec_softmax_scratch`에서와 같이 배치 크기를 256으로 유지해 보겠습니다.
+:numref:`sec_linear_concise`의 딥 러닝 프레임워크 (**선형 회귀 구현이 훨씬 쉬워졌습니다**) 의 (**상위 수준 API**)와 마찬가지로, 분류 모델을 구현하는 데 편리합니다 (**비슷하게 찾을 수 있습니다**) (~~here~~) (또는 그 이상).패션-MNIST 데이터세트를 고수하고 :numref:`sec_softmax_scratch`에서와 같이 배치 크기를 256으로 유지해 보겠습니다.
 
 ```{.python .input}
 from d2l import mxnet as d2l
@@ -63,11 +63,11 @@ net.add(tf.keras.layers.Dense(10, kernel_initializer=weight_initializer))
 ## 소프트맥스 구현 재검토
 :label:`subsec_softmax-implementation-revisited`
 
-:numref:`sec_softmax_scratch`의 이전 예에서는 모델의 출력을 계산한 다음 교차 엔트로피 손실을 통해 이 출력을 실행했습니다.수학적으로 이것은 완벽하게 합리적인 일입니다.그러나 계산적 관점에서 지수화는 수치 안정성 문제의 원인이 될 수 있습니다. 
+:numref:`sec_softmax_scratch`의 이전 예에서는 모델의 출력을 계산한 다음 교차 엔트로피 손실을 통해 이 출력을 실행했습니다.수학적으로 이것은 완벽하게 합리적인 일입니다.그러나 계산적 관점에서 지수화는 수치 안정성 문제의 원인이 될 수 있습니다.
 
-소프트맥스 함수는 $\hat y_j = \frac{\exp(o_j)}{\sum_k \exp(o_k)}$을 계산합니다. 여기서 $\hat y_j$는 예측된 확률 분포 $\hat{\mathbf{y}}$의 $j^\mathrm{th}$이고 $o_j$은 로짓 $\mathbf{o}$의 $j^\mathrm{th}$ 요소입니다.$o_k$ 중 일부가 매우 큰 경우 (즉, 매우 양수) $\exp(o_k)$이 특정 데이터 유형 (예: *오버플로*) 에 대해 가질 수 있는 가장 큰 수보다 클 수 있습니다.이것은 분모 (및/또는 분자) `inf` (무한대) 를 만들고 $\hat y_j$에 대해 0, `inf` 또는 `nan` (숫자가 아님) 를 만나게됩니다.이러한 상황에서는 교차 엔트로피에 대해 잘 정의된 반환 값을 얻지 못합니다. 
+소프트맥스 함수는 $\hat y_j = \frac{\exp(o_j)}{\sum_k \exp(o_k)}$을 계산합니다. 여기서 $\hat y_j$는 예측된 확률 분포 $\hat{\mathbf{y}}$의 $j^\mathrm{th}$이고 $o_j$은 로짓 $\mathbf{o}$의 $j^\mathrm{th}$ 요소입니다.$o_k$ 중 일부가 매우 큰 경우 (즉, 매우 양수) $\exp(o_k)$이 특정 데이터 유형 (예: *오버플로*) 에 대해 가질 수 있는 가장 큰 수보다 클 수 있습니다.이것은 분모 (및/또는 분자) `inf` (무한대) 를 만들고 $\hat y_j$에 대해 0, `inf` 또는 `nan` (숫자가 아님) 를 만나게됩니다.이러한 상황에서는 교차 엔트로피에 대해 잘 정의된 반환 값을 얻지 못합니다.
 
-이 문제를 해결하기 위한 한 가지 비결은 소프트맥스 계산을 진행하기 전에 먼저 모든 $o_k$에서 $\max(o_k)$를 빼는 것입니다.상수 인자에 의해 각 $o_k$를 이동해도 소프트맥스의 반환 값은 변경되지 않는다는 것을 알 수 있습니다. 
+이 문제를 해결하기 위한 한 가지 비결은 소프트맥스 계산을 진행하기 전에 먼저 모든 $o_k$에서 $\max(o_k)$를 빼는 것입니다.상수 인자에 의해 각 $o_k$를 이동해도 소프트맥스의 반환 값은 변경되지 않는다는 것을 알 수 있습니다.
 
 $$
 \begin{aligned}
@@ -76,9 +76,9 @@ $$
 \end{aligned}
 $$
 
-빼기 및 정규화 단계 후에 일부 $o_j - \max(o_k)$는 큰 음수 값을 가지므로 해당 $\exp(o_j - \max(o_k))$이 0에 가까운 값을 가질 수 있습니다.유한 정밀도 (즉, *언더플로*) 로 인해 0으로 반올림되어 $\hat y_j$을 0으로 만들고 $\log(\hat y_j)$에 대해 `-inf`를 제공할 수 있습니다.역전파의 길을 몇 걸음 내려가면, 우리는 두려운 `nan` 결과를 스크린으로 보게 될 것입니다. 
+빼기 및 정규화 단계 후에 일부 $o_j - \max(o_k)$는 큰 음수 값을 가지므로 해당 $\exp(o_j - \max(o_k))$이 0에 가까운 값을 가질 수 있습니다.유한 정밀도 (즉, *언더플로*) 로 인해 0으로 반올림되어 $\hat y_j$을 0으로 만들고 $\log(\hat y_j)$에 대해 `-inf`를 제공할 수 있습니다.역전파의 길을 몇 걸음 내려가면, 우리는 두려운 `nan` 결과를 스크린으로 보게 될 것입니다.
 
-다행히도 지수 함수를 계산하더라도 궁극적으로 (교차 엔트로피 손실을 계산할 때) 로그를 가져올 것이라는 사실에 의해 절약됩니다.이 두 연산자 softmax와 cross-entropy를 함께 결합하면 역전파 중에 우리를 괴롭힐 수 있는 수치 안정성 문제를 피할 수 있습니다.아래 방정식에서 볼 수 있듯이 $\exp(o_j - \max(o_k))$를 계산하는 것을 피하고 $\log(\exp(\cdot))$의 취소로 인해 $o_j - \max(o_k)$을 직접 사용할 수 있습니다. 
+다행히도 지수 함수를 계산하더라도 궁극적으로 (교차 엔트로피 손실을 계산할 때) 로그를 가져올 것이라는 사실에 의해 절약됩니다.이 두 연산자 softmax와 cross-entropy를 함께 결합하면 역전파 중에 우리를 괴롭힐 수 있는 수치 안정성 문제를 피할 수 있습니다.아래 방정식에서 볼 수 있듯이 $\exp(o_j - \max(o_k))$를 계산하는 것을 피하고 $\log(\exp(\cdot))$의 취소로 인해 $o_j - \max(o_k)$을 직접 사용할 수 있습니다.
 
 $$
 \begin{aligned}
@@ -88,7 +88,7 @@ $$
 \end{aligned}
 $$
 
-모델을 통해 출력 확률을 평가하려는 경우 기존 softmax 함수를 편리하게 사용할 수 있습니다.그러나 소프트맥스 확률을 새로운 손실 함수에 전달하는 대신 [**LogsumExp trick "](https://en.wikipedia.org/wiki/LogSumExp) 과 같은 스마트한 작업을 수행하는 교차 엔트로피 손실 함수 내에서 로짓을 전달하고 소프트맥스와 그 로그를 한꺼번에 계산합니다.
+모델을 통해 출력 확률을 평가하려는 경우 기존 softmax 함수를 편리하게 사용할 수 있습니다.그러나 소프트맥스 확률을 새로운 손실 함수에 전달하는 대신 [LogsumExp trick](https://en.wikipedia.org/wiki/LogSumExp) 과 같은 스마트한 작업을 수행하는 교차 엔트로피 손실 함수 내에서 로짓을 전달하고 소프트맥스와 그 로그를 한꺼번에 계산합니다.
 
 ```{.python .input}
 loss = gluon.loss.SoftmaxCrossEntropyLoss()
@@ -132,7 +132,7 @@ num_epochs = 10
 d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)
 ```
 
-이전과 마찬가지로이 알고리즘은 이전보다 적은 코드 줄로 이번에는 적절한 정확도를 달성하는 솔루션으로 수렴됩니다. 
+이전과 마찬가지로이 알고리즘은 이전보다 적은 코드 줄로 이번에는 적절한 정확도를 달성하는 솔루션으로 수렴됩니다.
 
 ## 요약
 
diff --git a/chapter_linear-networks/softmax-regression-scratch.md b/chapter_linear-networks/softmax-regression-scratch.md
index 18b4889d..8aede36e 100644
--- a/chapter_linear-networks/softmax-regression-scratch.md
+++ b/chapter_linear-networks/softmax-regression-scratch.md
@@ -32,7 +32,7 @@ train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
 
 ## 모델 매개변수 초기화
 
-선형 회귀 예제에서와 같이 각 예제는 고정 길이 벡터로 표현됩니다.원시 데이터셋의 각 예는 $28 \times 28$ 이미지입니다.이 섹션에서는 [**각 이미지를 평면화하여 길이 784의 벡터로 처리하겠습니다**] 앞으로는 이미지의 공간 구조를 활용하기 위한 보다 정교한 전략에 대해 이야기하겠습니다. 하지만 지금은 각 픽셀 위치를 또 다른 기능으로 취급합니다. 
+선형 회귀 예제에서와 같이 각 예제는 고정 길이 벡터로 표현됩니다.원시 데이터셋의 각 예는 $28 \times 28$ 이미지입니다.이 섹션에서는 [**각 이미지를 평면화하여 길이 784의 벡터로 처리하겠습니다**] 앞으로는 이미지의 공간 구조를 활용하기 위한 보다 정교한 전략에 대해 이야기하겠습니다. 하지만 지금은 각 픽셀 위치를 또 다른 기능으로 취급합니다.
 
 소프트맥스 회귀에서는 클래스 수만큼의 출력값을 가집니다.(**데이터셋에 10개의 클래스가 있으므로 네트워크의 출력 차원은 10.**) 결과적으로 가중치는 $784 \times 10$ 행렬을 구성하고 편향은 $1 \times 10$ 행 벡터를 구성합니다.선형 회귀와 마찬가지로 가우스 잡음과 편향을 사용하여 가중치 `W`를 초기화하여 초기 값 0을 취합니다.
 
@@ -67,7 +67,7 @@ b = tf.Variable(tf.zeros(num_outputs))
 
 ## 소프트맥스 연산 정의
 
-소프트맥스 회귀 모델을 구현하기 전에 :numref:`subseq_lin-alg-reduction` 및 :numref:`subseq_lin-alg-non-reduction`에서 설명한 것처럼 합계 연산자가 텐서의 특정 차원을 따라 어떻게 작동하는지 간단히 검토해 보겠습니다.[**행렬 `X`이 주어지면 모든 요소 (기본적으로) 또는 동일한 축의 요소 (**]), 즉 동일한 열 (축 0) 또는 동일한 행 (축 1) 에 대해서만 합을 구할 수 있습니다.`X`이 모양 (2, 3) 을 가진 텐서이고 열에 대해 합산하면 결과는 모양 (3,) 을 가진 벡터가됩니다.sum 연산자를 호출 할 때 합산 한 차원을 축소하는 대신 원래 텐서의 축 수를 유지하도록 지정할 수 있습니다.그러면 모양 (1, 3) 의 2차원 텐서가 생성됩니다.
+소프트맥스 회귀 모델을 구현하기 전에 :numref:`subseq_lin-alg-reduction` 및 :numref:`subseq_lin-alg-non-reduction`에서 설명한 것처럼 합계 연산자가 텐서의 특정 차원을 따라 어떻게 작동하는지 간단히 검토해 보겠습니다.[**행렬 `X`이 주어지면 모든 요소 (기본적으로) 또는 동일한 축의 요소 **], 즉 동일한 열 (축 0) 또는 동일한 행 (축 1) 에 대해서만 합을 구할 수 있습니다.`X`이 모양 (2, 3) 을 가진 텐서이고 열에 대해 합산하면 결과는 모양 (3,) 을 가진 벡터가됩니다.sum 연산자를 호출 할 때 합산 한 차원을 축소하는 대신 원래 텐서의 축 수를 유지하도록 지정할 수 있습니다.그러면 모양 (1, 3) 의 2차원 텐서가 생성됩니다.
 
 ```{.python .input}
 #@tab pytorch
@@ -81,7 +81,7 @@ X = d2l.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
 d2l.reduce_sum(X, 0, keepdims=True), d2l.reduce_sum(X, 1, keepdims=True)
 ```
 
-이제 (**소프트맥스 작업 구현**) 할 준비가 되었습니다.softmax는 세 단계로 구성됩니다. (i) 각 항을 지수 화합니다 (`exp` 사용). (ii) 각 예에 대한 정규화 상수를 얻기 위해 각 행에 대해 합산 (배치에 예제 당 하나의 행이 있음); (iii) 각 행을 정규화 상수로 나누어 결과의 합계가 1이되도록합니다.코드를 살펴보기 전에 이것이 방정식으로 어떻게 표현되는지 생각해 봅시다. 
+이제 (**소프트맥스 작업 구현**) 할 준비가 되었습니다.softmax는 세 단계로 구성됩니다. (i) 각 항을 지수 화합니다 (`exp` 사용). (ii) 각 예에 대한 정규화 상수를 얻기 위해 각 행에 대해 합산 (배치에 예제 당 하나의 행이 있음); (iii) 각 행을 정규화 상수로 나누어 결과의 합계가 1이되도록합니다.코드를 살펴보기 전에 이것이 방정식으로 어떻게 표현되는지 생각해 봅시다.
 
 (** $\mathrm{softmax}(\mathbf{X})_{ij} = \frac{\exp(\mathbf{X}_{ij})}{\sum_k \exp(\mathbf{X}_{ik})}.$$
 **)
@@ -120,7 +120,7 @@ X_prob = softmax(X)
 X_prob, tf.reduce_sum(X_prob, 1)
 ```
 
-이것은 수학적으로 정확해 보이지만 행렬의 크거나 매우 작은 요소로 인해 수치 오버 플로우 또는 언더 플로우에 대한 예방 조치를 취하지 못했기 때문에 구현에서 약간 엉성했습니다. 
+이것은 수학적으로 정확해 보이지만 행렬의 크거나 매우 작은 요소로 인해 수치 오버 플로우 또는 언더 플로우에 대한 예방 조치를 취하지 못했기 때문에 구현에서 약간 엉성했습니다.
 
 ## 모델 정의
 
@@ -134,9 +134,9 @@ def net(X):
 
 ## 손실 함수 정의하기
 
-다음으로 :numref:`sec_softmax`에 소개된 교차 엔트로피 손실 함수를 구현해야 합니다.이는 현재 분류 문제가 회귀 문제보다 훨씬 많기 때문에 모든 딥러닝에서 가장 일반적인 손실 함수일 수 있습니다. 
+다음으로 :numref:`sec_softmax`에 소개된 교차 엔트로피 손실 함수를 구현해야 합니다.이는 현재 분류 문제가 회귀 문제보다 훨씬 많기 때문에 모든 딥러닝에서 가장 일반적인 손실 함수일 수 있습니다.
 
-교차 엔트로피는 실제 레이블에 할당된 예측 확률의 음의 로그 우도를 취한다는 것을 상기하십시오.Python for 루프 (비효율적 인 경향이 있음) 로 예측을 반복하는 대신 단일 연산자로 모든 요소를 선택할 수 있습니다.아래에서는 [**3개의 클래스에 대한 예측 확률의 2가지 예와 해당 레이블 `y`.**를 사용하여 샘플 데이터 `y_hat`를 만듭니다.] `y`를 사용하면 첫 번째 예에서는 첫 번째 클래스가 올바른 예측이고 두 번째 예에서는 세 번째 클래스가 실측이라는 것을 알 수 있습니다.[**`y`를 `y_hat`의 확률 인덱스로 사용**] 첫 번째 예에서는 첫 번째 클래스의 확률을 선택하고 두 번째 예에서는 세 번째 클래스의 확률을 선택합니다.
+교차 엔트로피는 실제 레이블에 할당된 예측 확률의 음의 로그 우도를 취한다는 것을 상기하십시오.Python for 루프 (비효율적 인 경향이 있음) 로 예측을 반복하는 대신 단일 연산자로 모든 요소를 선택할 수 있습니다.아래에서는 [**3개의 클래스에 대한 예측 확률의 2가지 예와 해당 레이블 `y`.**]를 사용하여 샘플 데이터 `y_hat`를 만듭니다. `y`를 사용하면 첫 번째 예에서는 첫 번째 클래스가 올바른 예측이고 두 번째 예에서는 세 번째 클래스가 실측이라는 것을 알 수 있습니다.[**`y`를 `y_hat`의 확률 인덱스로 사용**] 첫 번째 예에서는 첫 번째 클래스의 확률을 선택하고 두 번째 예에서는 세 번째 클래스의 확률을 선택합니다.
 
 ```{.python .input}
 #@tab mxnet, pytorch
@@ -173,9 +173,9 @@ cross_entropy(y_hat, y)
 
 ## 분류 정확도
 
-예측 확률 분포 `y_hat`가 주어지면 일반적으로 어려운 예측을 출력해야 할 때마다 예측 확률이 가장 높은 클래스를 선택합니다.실제로 많은 응용 프로그램에서 선택을 요구합니다.Gmail은 이메일을 '기본', '소셜', '업데이트' 또는 '포럼'으로 분류해야 합니다.내부적으로 확률을 추정할 수도 있지만 하루가 끝나면 클래스 중 하나를 선택해야 합니다. 
+예측 확률 분포 `y_hat`가 주어지면 일반적으로 어려운 예측을 출력해야 할 때마다 예측 확률이 가장 높은 클래스를 선택합니다.실제로 많은 응용 프로그램에서 선택을 요구합니다.Gmail은 이메일을 '기본', '소셜', '업데이트' 또는 '포럼'으로 분류해야 합니다.내부적으로 확률을 추정할 수도 있지만 하루가 끝나면 클래스 중 하나를 선택해야 합니다.
 
-예측이 레이블 클래스 `y`와 일치하면 정확합니다.분류 정확도는 모든 예측에서 정확한 비율입니다.정확도를 직접 최적화하는 것은 어려울 수 있지만 (차별화할 수는 없음), 종종 우리가 가장 중요하게 생각하는 성능 척도이며 분류기를 훈련시킬 때 거의 항상 보고할 것입니다. 
+예측이 레이블 클래스 `y`와 일치하면 정확합니다.분류 정확도는 모든 예측에서 정확한 비율입니다.정확도를 직접 최적화하는 것은 어려울 수 있지만 (차별화할 수는 없음), 종종 우리가 가장 중요하게 생각하는 성능 척도이며 분류기를 훈련시킬 때 거의 항상 보고할 것입니다.
 
 정확도를 계산하기 위해 다음을 수행합니다.첫째, `y_hat`이 행렬인 경우 두 번째 차원이 각 클래스에 대한 예측 점수를 저장한다고 가정합니다.`argmax`을 사용하여 각 행에서 가장 큰 항목에 대한 인덱스로 예측된 클래스를 얻습니다.그런 다음 [**예측된 클래스를 실측 `y`와 요소별로 비교합니다.**] 등식 연산자 `==`는 데이터 유형에 민감하므로 `y_hat`의 데이터 유형을 `y`의 데이터 유형과 일치하도록 변환합니다.결과는 0 (false) 과 1 (true) 의 항목을 포함하는 텐서입니다.합계를 취하면 정확한 예측의 수가 산출됩니다.
 
@@ -241,7 +241,7 @@ class Accumulator:  #@save
         return self.data[idx]
 ```
 
-[**랜덤 가중치를 사용하여 `net` 모델을 초기화했기 때문에 이 모델의 정확도는 무작위 추측에 가까워야 합니다. 즉, 10개의 클래스에 대해 0.1이어야 합니다.
+랜덤 가중치를 사용하여 `net` 모델을 초기화했기 때문에 이 모델의 정확도는 무작위 추측에 가까워야 합니다. 즉, 10개의 클래스에 대해 0.1이어야 합니다.
 
 ```{.python .input}
 #@tab all
diff --git a/chapter_multilayer-perceptrons/dropout.md b/chapter_multilayer-perceptrons/dropout.md
index faab2bde..074f1e4f 100644
--- a/chapter_multilayer-perceptrons/dropout.md
+++ b/chapter_multilayer-perceptrons/dropout.md
@@ -1,39 +1,39 @@
 # 드롭아웃
 :label:`sec_dropout`
 
-:numref:`sec_weight_decay`에서는 가중치의 $L_2$ 규범에 불이익을 주어 통계 모델을 정규화하는 고전적 접근 방식을 도입했습니다.확률적 측면에서 우리는 가중치가 평균이 0인 가우스 분포에서 값을 취한다는 사전 믿음을 가정했다고 주장함으로써이 기술을 정당화 할 수 있습니다.좀 더 직관적으로, 우리는 모델이 소수의 잠재적으로 가짜 연관성에 너무 많이 의존하지 않고 많은 특징에 가중치를 분산하도록 권장했다고 주장 할 수 있습니다. 
+:numref:`sec_weight_decay`에서는 가중치의 $L_2$ 규범에 불이익을 주어 통계 모델을 정규화하는 고전적 접근 방식을 도입했습니다.확률적 측면에서 우리는 가중치가 평균이 0인 가우스 분포에서 값을 취한다는 사전 믿음을 가정했다고 주장함으로써이 기술을 정당화 할 수 있습니다.좀 더 직관적으로, 우리는 모델이 소수의 잠재적으로 가짜 연관성에 너무 많이 의존하지 않고 많은 특징에 가중치를 분산하도록 권장했다고 주장 할 수 있습니다.
 
 ## 오버피팅 재검토
 
-예제보다 더 많은 기능에 직면했을 때 선형 모델은 과적합되는 경향이 있습니다.그러나 특징보다 더 많은 예가 주어지면 일반적으로 선형 모델을 과적합시키지 않을 수 있습니다.안타깝게도 선형 모델이 일반화되는 신뢰성에는 비용이 듭니다.기본적으로 적용된 선형 모델은 특징 간의 상호 작용을 고려하지 않습니다.모든 피처에 대해 선형 모델은 컨텍스트를 무시하고 양수 또는 음수 가중치를 할당해야 합니다. 
+예제보다 더 많은 기능에 직면했을 때 선형 모델은 과적합되는 경향이 있습니다.그러나 특징보다 더 많은 예가 주어지면 일반적으로 선형 모델을 과적합시키지 않을 수 있습니다.안타깝게도 선형 모델이 일반화되는 신뢰성에는 비용이 듭니다.기본적으로 적용된 선형 모델은 특징 간의 상호 작용을 고려하지 않습니다.모든 피처에 대해 선형 모델은 컨텍스트를 무시하고 양수 또는 음수 가중치를 할당해야 합니다.
 
-전통적인 텍스트에서 일반화와 유연성 사이의 이러한 근본적인 긴장은*편향 분산 트레이드 오프*로 설명됩니다.선형 모델은 편향이 높습니다. 즉, 소수의 함수 클래스만 나타낼 수 있습니다.그러나 이러한 모형은 분산이 낮기 때문에 데이터의 서로 다른 랜덤 표본에서 유사한 결과를 제공합니다. 
+전통적인 텍스트에서 일반화와 유연성 사이의 이러한 근본적인 긴장은*편향 분산 트레이드 오프*로 설명됩니다.선형 모델은 편향이 높습니다. 즉, 소수의 함수 클래스만 나타낼 수 있습니다.그러나 이러한 모형은 분산이 낮기 때문에 데이터의 서로 다른 랜덤 표본에서 유사한 결과를 제공합니다.
 
-심층 신경망은 편향 분산 스펙트럼의 반대쪽 끝에 존재합니다.선형 모델과 달리 신경망은 각 특징을 개별적으로 보는 데 국한되지 않습니다.피처 그룹 간의 상호 작용을 학습할 수 있습니다.예를 들어 이메일에 함께 나타나는 “나이지리아”와 “Western Union”은 스팸을 나타내지 만 별도로 그렇지 않다고 추론 할 수 있습니다. 
+심층 신경망은 편향 분산 스펙트럼의 반대쪽 끝에 존재합니다.선형 모델과 달리 신경망은 각 특징을 개별적으로 보는 데 국한되지 않습니다.피처 그룹 간의 상호 작용을 학습할 수 있습니다.예를 들어 이메일에 함께 나타나는 “나이지리아”와 “Western Union”은 스팸을 나타내지 만 별도로 그렇지 않다고 추론 할 수 있습니다.
 
-특징보다 훨씬 많은 예가 있더라도 심층 신경망은 과적합할 수 있습니다.2017년 한 연구원 그룹은 무작위로 레이블이 지정된 이미지에서 딥 네트를 훈련시켜 신경망의 극도의 유연성을 입증했습니다.입력과 출력을 연결하는 실제 패턴이 없음에도 불구하고 확률 적 경사 하강법에 의해 최적화 된 신경망이 훈련 세트의 모든 이미지에 완벽하게 레이블을 지정할 수 있음을 발견했습니다.이것이 무엇을 의미하는지 생각해 보십시오.레이블이 무작위로 균일하게 할당되고 10개의 클래스가 있는 경우 홀드아웃 데이터에 대해 10% 이상의 정확도를 제공하는 분류기는 없습니다.여기서 일반화 격차는 무려 90% 입니다.우리 모델이 너무 표현력이 뛰어나서 너무 많이 맞을 수 있다면 언제 과적합하지 않을 것으로 예상해야합니까? 
+특징보다 훨씬 많은 예가 있더라도 심층 신경망은 과적합할 수 있습니다.2017년 한 연구원 그룹은 무작위로 레이블이 지정된 이미지에서 딥 네트를 훈련시켜 신경망의 극도의 유연성을 입증했습니다.입력과 출력을 연결하는 실제 패턴이 없음에도 불구하고 확률 적 경사 하강법에 의해 최적화 된 신경망이 훈련 세트의 모든 이미지에 완벽하게 레이블을 지정할 수 있음을 발견했습니다.이것이 무엇을 의미하는지 생각해 보십시오.레이블이 무작위로 균일하게 할당되고 10개의 클래스가 있는 경우 홀드아웃 데이터에 대해 10% 이상의 정확도를 제공하는 분류기는 없습니다.여기서 일반화 격차는 무려 90% 입니다.우리 모델이 너무 표현력이 뛰어나서 너무 많이 맞을 수 있다면 언제 과적합하지 않을 것으로 예상해야합니까?
 
-딥 네트워크의 수수께끼 같은 일반화 속성에 대한 수학적 기초는 공개 연구 질문으로 남아 있으며 이론적으로 지향적 인 독자가 주제를 더 깊이 파고 들도록 권장합니다.지금은 딥 네트의 일반화를 경험적으로 개선하는 경향이있는 실용적인 도구에 대한 조사로 넘어갑니다. 
+딥 네트워크의 수수께끼 같은 일반화 속성에 대한 수학적 기초는 공개 연구 질문으로 남아 있으며 이론적으로 지향적 인 독자가 주제를 더 깊이 파고 들도록 권장합니다.지금은 딥 네트의 일반화를 경험적으로 개선하는 경향이있는 실용적인 도구에 대한 조사로 넘어갑니다.
 
 ## 섭동을 통한 견고성
 
-좋은 예측 모델에서 기대하는 바를 간단히 생각해 보겠습니다.보이지 않는 데이터에서 제대로 작동하기를 원합니다.고전적 일반화 이론은 훈련과 시험 성능 사이의 격차를 줄이기 위해 간단한 모델을 목표로해야한다고 제안합니다.단순성은 적은 수의 차원 형태로 나타날 수 있습니다.:numref:`sec_model_selection`에서 선형 모델의 단항 기저 함수를 논의 할 때 이것을 탐구했습니다.또한 :numref:`sec_weight_decay`에서 체중 감소 ($L_2$ 정규화) 에 대해 논의 할 때 보았 듯이 매개 변수의 (역) 규범도 단순성의 유용한 척도를 나타냅니다.단순성에 대한 또 다른 유용한 개념은 매끄러움입니다. 즉, 함수가 입력값의 작은 변화에 민감하지 않아야 한다는 것입니다.예를 들어 이미지를 분류할 때 픽셀에 임의의 노이즈를 추가하는 것은 거의 무해할 것으로 예상할 수 있습니다. 
+좋은 예측 모델에서 기대하는 바를 간단히 생각해 보겠습니다.보이지 않는 데이터에서 제대로 작동하기를 원합니다.고전적 일반화 이론은 훈련과 시험 성능 사이의 격차를 줄이기 위해 간단한 모델을 목표로해야한다고 제안합니다.단순성은 적은 수의 차원 형태로 나타날 수 있습니다.:numref:`sec_model_selection`에서 선형 모델의 단항 기저 함수를 논의 할 때 이것을 탐구했습니다.또한 :numref:`sec_weight_decay`에서 체중 감소 ($L_2$ 정규화) 에 대해 논의 할 때 보았 듯이 매개 변수의 (역) 규범도 단순성의 유용한 척도를 나타냅니다.단순성에 대한 또 다른 유용한 개념은 매끄러움입니다. 즉, 함수가 입력값의 작은 변화에 민감하지 않아야 한다는 것입니다.예를 들어 이미지를 분류할 때 픽셀에 임의의 노이즈를 추가하는 것은 거의 무해할 것으로 예상할 수 있습니다.
 
-1995년 크리스토퍼 비숍은 입력 잡음을 사용한 훈련이 티호노프 정규화 :cite:`Bishop.1995`와 동일하다는 것을 증명했을 때 이 아이디어를 공식화했습니다.이 작업은 함수가 매끄럽고 단순해야 한다는 요구 사항과 입력의 섭동에 탄력적이라는 요구 사항 사이에 명확한 수학적 연결을 이끌어 냈습니다. 
+1995년 크리스토퍼 비숍은 입력 잡음을 사용한 훈련이 티호노프 정규화 :cite:`Bishop.1995`와 동일하다는 것을 증명했을 때 이 아이디어를 공식화했습니다.이 작업은 함수가 매끄럽고 단순해야 한다는 요구 사항과 입력의 섭동에 탄력적이라는 요구 사항 사이에 명확한 수학적 연결을 이끌어 냈습니다.
 
-그런 다음 2014년 스리바스타바 외. :cite:`Srivastava.Hinton.Krizhevsky.ea.2014`는 비숍의 아이디어를 네트워크의 내부 계층에도 적용하는 방법에 대한 영리한 아이디어를 개발했습니다.즉, 훈련 중에 후속 계층을 계산하기 전에 네트워크의 각 계층에 잡음을 주입 할 것을 제안했습니다.그들은 계층이 많은 심층 네트워크를 훈련시킬 때 노이즈를 주입하면 입력-출력 매핑에만 부드러움이 적용된다는 것을 깨달았습니다. 
+그런 다음 2014년 스리바스타바 외. :cite:`Srivastava.Hinton.Krizhevsky.ea.2014`는 비숍의 아이디어를 네트워크의 내부 계층에도 적용하는 방법에 대한 영리한 아이디어를 개발했습니다.즉, 훈련 중에 후속 계층을 계산하기 전에 네트워크의 각 계층에 잡음을 주입 할 것을 제안했습니다.그들은 계층이 많은 심층 네트워크를 훈련시킬 때 노이즈를 주입하면 입력-출력 매핑에만 부드러움이 적용된다는 것을 깨달았습니다.
 
 *드롭아웃*이라고 하는 이들의 아이디어는 순방향 전파 중에 각 내부 계층을 계산하는 동안 노이즈를 주입하는 것과 관련이 있으며, 신경망을 훈련시키는 표준 기술이 되었습니다.이 메소드는*dropout*이라고 불립니다. 왜냐하면 문자 그대로
 *훈련 중에 일부 뉴런을 떨어 뜨립니다.
-훈련 내내 각 반복에서 표준 드롭아웃은 후속 계층을 계산하기 전에 각 계층에서 노드의 일부를 제로화하는 것으로 구성됩니다. 
+훈련 내내 각 반복에서 표준 드롭아웃은 후속 계층을 계산하기 전에 각 계층에서 노드의 일부를 제로화하는 것으로 구성됩니다.
 
-분명히 말하자면, 우리는 주교와의 연결과 함께 우리 자신의 이야기를 강요하고 있습니다.드롭 아웃에 관한 원본 논문은 성 생식에 대한 놀라운 비유를 통해 직관을 제공합니다.저자들은 신경망 과적합이 각 계층이 이전 계층의 특정 활성화 패턴에 의존하는 상태를 특징으로하며, 이 조건을*co-adaptation*이라고 부릅니다.그들은 성적 생식이 공동 적응 유전자를 분해한다고 주장하는 것처럼 드롭 아웃이 공동 적응을 깨뜨린다고 주장한다. 
+분명히 말하자면, 우리는 주교와의 연결과 함께 우리 자신의 이야기를 강요하고 있습니다.드롭 아웃에 관한 원본 논문은 성 생식에 대한 놀라운 비유를 통해 직관을 제공합니다.저자들은 신경망 과적합이 각 계층이 이전 계층의 특정 활성화 패턴에 의존하는 상태를 특징으로하며, 이 조건을*co-adaptation*이라고 부릅니다.그들은 성적 생식이 공동 적응 유전자를 분해한다고 주장하는 것처럼 드롭 아웃이 공동 적응을 깨뜨린다고 주장한다.
 
-그렇다면 가장 중요한 과제는 이 노이즈를 주입하는 방법입니다.한 가지 아이디어는 노이즈를*편향되지 않은* 방식으로 주입하여 다른 레이어를 고정하는 동안 각 레이어의 예상 값이 노이즈가 없을 때 발생하는 값과 같도록하는 것입니다. 
+그렇다면 가장 중요한 과제는 이 노이즈를 주입하는 방법입니다.한 가지 아이디어는 노이즈를*편향되지 않은* 방식으로 주입하여 다른 레이어를 고정하는 동안 각 레이어의 예상 값이 노이즈가 없을 때 발생하는 값과 같도록하는 것입니다.
 
-Bishop의 작업에서 그는 선형 모델의 입력에 가우스 노이즈를 추가했습니다.각 훈련 반복에서 그는 평균이 0인 분포에서 샘플링된 잡음을 입력 $\mathbf{x}$에 추가하여 교란된 점 $\mathbf{x}' = \mathbf{x} + \epsilon$을 산출했습니다.예상되는 경우 $E[\mathbf{x}'] = \mathbf{x}$입니다. 
+Bishop의 작업에서 그는 선형 모델의 입력에 가우스 노이즈를 추가했습니다.각 훈련 반복에서 그는 평균이 0인 분포에서 샘플링된 잡음을 입력 $\mathbf{x}$에 추가하여 교란된 점 $\mathbf{x}' = \mathbf{x} + \epsilon$을 산출했습니다.예상되는 경우 $E[\mathbf{x}'] = \mathbf{x}$입니다.
 
-표준 드롭아웃 정규화에서는 유지된 (드롭아웃되지 않음) 노드의 비율로 정규화하여 각 레이어의 편향을 제거합니다.즉, *드롭아웃 확률* $p$를 사용하면 각 중간 활성화 $h$이 다음과 같이 랜덤 변수 $h'$로 대체됩니다. 
+표준 드롭아웃 정규화에서는 유지된 (드롭아웃되지 않음) 노드의 비율로 정규화하여 각 레이어의 편향을 제거합니다.즉, *드롭아웃 확률* $p$를 사용하면 각 중간 활성화 $h$이 다음과 같이 랜덤 변수 $h'$로 대체됩니다.
 
 $$
 \begin{aligned}
@@ -45,22 +45,22 @@ h' =
 \end{aligned}
 $$
 
-설계 상 기대치는 변하지 않습니다 (예: $E[h'] = h$). 
+설계 상 기대치는 변하지 않습니다 (예: $E[h'] = h$).
 
 ## 실제로 드롭아웃
 
-:numref:`fig_mlp`에서 숨겨진 레이어와 5개의 숨겨진 유닛이 있는 MLP를 회상합니다.은닉 계층에 드롭아웃을 적용하여 확률 $p$로 각 은닉 유닛을 제로화하면 결과는 원래 뉴런의 하위 집합만 포함하는 네트워크로 볼 수 있습니다.:numref:`fig_dropout2`에서는 $h_2$ 및 $h_5$이 제거됩니다.결과적으로 출력의 계산은 더 이상 $h_2$ 또는 $h_5$에 의존하지 않으며 역전파를 수행 할 때 각각의 기울기도 사라집니다.이러한 방식으로 출력 레이어의 계산은 $h_1, \ldots, h_5$의 한 요소에 지나치게 종속될 수 없습니다. 
+:numref:`fig_mlp`에서 숨겨진 레이어와 5개의 숨겨진 유닛이 있는 MLP를 회상합니다.은닉 계층에 드롭아웃을 적용하여 확률 $p$로 각 은닉 유닛을 제로화하면 결과는 원래 뉴런의 하위 집합만 포함하는 네트워크로 볼 수 있습니다.:numref:`fig_dropout2`에서는 $h_2$ 및 $h_5$이 제거됩니다.결과적으로 출력의 계산은 더 이상 $h_2$ 또는 $h_5$에 의존하지 않으며 역전파를 수행 할 때 각각의 기울기도 사라집니다.이러한 방식으로 출력 레이어의 계산은 $h_1, \ldots, h_5$의 한 요소에 지나치게 종속될 수 없습니다.
 
 ![MLP before and after dropout.](../img/dropout2.svg)
 :label:`fig_dropout2`
 
-일반적으로 테스트 시간에는 드롭아웃을 비활성화합니다.훈련된 모델과 새로운 예제가 주어지면 노드를 삭제하지 않으므로 정규화할 필요가 없습니다.그러나 몇 가지 예외가 있습니다. 일부 연구자들은 신경망 예측의*불확실성*을 추정하기 위한 휴리스틱으로 테스트 시 드롭아웃을 사용합니다. 예측이 여러 드롭아웃 마스크에서 일치하면 네트워크가 더 확신한다고 말할 수 있습니다. 
+일반적으로 테스트 시간에는 드롭아웃을 비활성화합니다.훈련된 모델과 새로운 예제가 주어지면 노드를 삭제하지 않으므로 정규화할 필요가 없습니다.그러나 몇 가지 예외가 있습니다. 일부 연구자들은 신경망 예측의*불확실성*을 추정하기 위한 휴리스틱으로 테스트 시 드롭아웃을 사용합니다. 예측이 여러 드롭아웃 마스크에서 일치하면 네트워크가 더 확신한다고 말할 수 있습니다.
 
 ## 처음부터 구현
 
-단일 계층에 대해 드롭 아웃 함수를 구현하려면 계층에 차원이 있으므로 베르누이 (이진) 확률 변수에서 많은 샘플을 그려야합니다. 여기서 랜덤 변수는 확률 $1-p$ 및 확률이 $p$ 인 $0$ (드롭) 의 값 $1$ (유지) 을 취합니다.이를 구현하는 한 가지 쉬운 방법은 먼저 균일 분포 $U[0, 1]$에서 샘플을 추출하는 것입니다.그런 다음 해당 샘플이 $p$보다 큰 노드를 유지하고 나머지는 삭제할 수 있습니다. 
+단일 계층에 대해 드롭 아웃 함수를 구현하려면 계층에 차원이 있으므로 베르누이 (이진) 확률 변수에서 많은 샘플을 그려야합니다. 여기서 랜덤 변수는 확률 $1-p$ 및 확률이 $p$ 인 $0$ (드롭) 의 값 $1$ (유지) 을 취합니다.이를 구현하는 한 가지 쉬운 방법은 먼저 균일 분포 $U[0, 1]$에서 샘플을 추출하는 것입니다.그런 다음 해당 샘플이 $p$보다 큰 노드를 유지하고 나머지는 삭제할 수 있습니다.
 
-다음 코드에서는 (**텐서 입력 `X`의 요소를 확률 `dropout`**로 삭제하는 `dropout_layer` 함수를 구현) 위에서 설명한대로 나머지를 다시 스케일링합니다. 생존자를 `1.0-dropout`로 나눕니다.
+다음 코드에서는 (**텐서 입력 `X`의 요소를 확률 `dropout`**)로 삭제하는 `dropout_layer` 함수를 구현 위에서 설명한대로 나머지를 다시 스케일링합니다. 생존자를 `1.0-dropout`로 나눕니다.
 
 ```{.python .input}
 from d2l import mxnet as d2l
diff --git a/chapter_multilayer-perceptrons/kaggle-house-price.md b/chapter_multilayer-perceptrons/kaggle-house-price.md
index 24492a78..6afe8102 100644
--- a/chapter_multilayer-perceptrons/kaggle-house-price.md
+++ b/chapter_multilayer-perceptrons/kaggle-house-price.md
@@ -1,9 +1,9 @@
 # Kaggle의 주택 가격 예측
 :label:`sec_kaggle_house`
 
-이제 심층 네트워크를 구축 및 훈련하고 체중 감소 및 드롭아웃을 포함한 기술로 정규화하기 위한 몇 가지 기본 도구를 도입했으므로 Kaggle 대회에 참가하여 이러한 모든 지식을 실천할 준비가 되었습니다.주택 가격 예측 경쟁은 시작하기에 좋은 곳입니다.데이터는 매우 일반적이며 특수한 모델 (오디오 또는 비디오) 이 필요할 수 있는 이국적인 구조를 나타내지 않습니다.2011년 :cite:`De-Cock.2011`년에 바트 드 콕이 수집한 이 데이터세트는 2006년부터 2010년까지 아이오와 주 에임스의 주택 가격을 다룹니다.해리슨과 루빈펠드 (1978) 의 유명한 [Boston housing dataset](https://archive.ics.uci.edu/ml/machine-learning-databases/housing/housing.names) (1978) 보다 훨씬 크며 더 많은 예와 더 많은 기능을 자랑합니다. 
+이제 심층 네트워크를 구축 및 훈련하고 체중 감소 및 드롭아웃을 포함한 기술로 정규화하기 위한 몇 가지 기본 도구를 도입했으므로 Kaggle 대회에 참가하여 이러한 모든 지식을 실천할 준비가 되었습니다.주택 가격 예측 경쟁은 시작하기에 좋은 곳입니다.데이터는 매우 일반적이며 특수한 모델 (오디오 또는 비디오) 이 필요할 수 있는 이국적인 구조를 나타내지 않습니다.2011년 :cite:`De-Cock.2011`년에 바트 드 콕이 수집한 이 데이터세트는 2006년부터 2010년까지 아이오와 주 에임스의 주택 가격을 다룹니다.해리슨과 루빈펠드 (1978) 의 유명한 [Boston housing dataset](https://archive.ics.uci.edu/ml/machine-learning-databases/housing/housing.names) (1978) 보다 훨씬 크며 더 많은 예와 더 많은 기능을 자랑합니다.
 
-이 섹션에서는 데이터 전처리, 모델 설계 및 하이퍼파라미터 선택에 대해 자세히 설명합니다.실습 접근 방식을 통해 데이터 과학자로서 경력을 쌓을 수 있는 몇 가지 직관을 얻을 수 있기를 바랍니다. 
+이 섹션에서는 데이터 전처리, 모델 설계 및 하이퍼파라미터 선택에 대해 자세히 설명합니다.실습 접근 방식을 통해 데이터 과학자로서 경력을 쌓을 수 있는 몇 가지 직관을 얻을 수 있기를 바랍니다.
 
 ## 데이터세트 다운로드 및 캐싱
 
@@ -75,15 +75,15 @@ def download_all():  #@save
 
 ## Kaggle
 
-[Kaggle](https://www.kaggle.com)는 기계 학습 대회를 주최하는 인기 있는 플랫폼입니다.각 경쟁은 데이터 세트를 중심으로하며 많은 경쟁은 수상 솔루션에 상을 제공하는 이해 관계자의 후원을 받습니다.이 플랫폼은 사용자가 포럼 및 공유 코드를 통해 상호 작용할 수 있도록 지원하여 협업과 경쟁을 촉진합니다.리더 보드 추격은 종종 통제 불능 상태이지만 연구자들은 근본적인 질문을하지 않고 전처리 단계에 근시적으로 초점을 맞추고 있지만, 경쟁 접근 방식과 코드 간의 직접적인 정량적 비교를 용이하게하는 플랫폼의 객관성에는 엄청난 가치가 있습니다.공유하여 모든 사람이 효과가 있었던 것과 작동하지 않는 것을 배울 수 있습니다.Kaggle 대회에 참가하려면 먼저 계정을 등록해야 합니다 (:numref:`fig_kaggle` 참조). 
+[Kaggle](https://www.kaggle.com)는 기계 학습 대회를 주최하는 인기 있는 플랫폼입니다.각 경쟁은 데이터 세트를 중심으로하며 많은 경쟁은 수상 솔루션에 상을 제공하는 이해 관계자의 후원을 받습니다.이 플랫폼은 사용자가 포럼 및 공유 코드를 통해 상호 작용할 수 있도록 지원하여 협업과 경쟁을 촉진합니다.리더 보드 추격은 종종 통제 불능 상태이지만 연구자들은 근본적인 질문을하지 않고 전처리 단계에 근시적으로 초점을 맞추고 있지만, 경쟁 접근 방식과 코드 간의 직접적인 정량적 비교를 용이하게하는 플랫폼의 객관성에는 엄청난 가치가 있습니다.공유하여 모든 사람이 효과가 있었던 것과 작동하지 않는 것을 배울 수 있습니다.Kaggle 대회에 참가하려면 먼저 계정을 등록해야 합니다 (:numref:`fig_kaggle` 참조).
 
 ![The Kaggle website.](../img/kaggle.png)
 :width:`400px`
 :label:`fig_kaggle`
 
-:numref:`fig_house_pricing`에 설명된 대로 주택 가격 예측 경쟁 페이지에서 데이터 세트 (“데이터” 탭 아래) 를 찾고 예측을 제출하고 순위를 확인할 수 있습니다. URL은 바로 여기에 있습니다. 
+:numref:`fig_house_pricing`에 설명된 대로 주택 가격 예측 경쟁 페이지에서 데이터 세트 (“데이터” 탭 아래) 를 찾고 예측을 제출하고 순위를 확인할 수 있습니다. URL은 바로 여기에 있습니다.
 
-> https://www.kaggle.com/c/house-prices-advanced-regression-techniques 
+> https://www.kaggle.com/c/house-prices-advanced-regression-techniques
 
 ![The house price prediction competition page.](../img/house-pricing.png)
 :width:`400px`
@@ -91,9 +91,9 @@ def download_all():  #@save
 
 ## 데이터세트 액세스 및 읽기
 
-경쟁 데이터는 훈련 세트와 테스트 세트로 구분됩니다.각 레코드에는 주택의 속성 값과 거리 유형, 건축 연도, 지붕 유형, 지하실 상태 등과 같은 속성이 포함됩니다. 이 기능은 다양한 데이터 유형으로 구성됩니다.예를 들어, 건축 연도는 정수로, 지붕 유형은 불연속 범주형 할당으로, 기타 피쳐는 부동 소수점 숫자로 표시됩니다.그리고 현실이 상황을 복잡하게 만드는 부분이 있습니다. 예를 들어, 일부 데이터는 단순히 “na”로 표시된 누락 된 값으로 완전히 누락되었습니다.각 주택의 가격은 교육 세트에만 포함됩니다 (결국 경쟁입니다).학습 세트를 분할하여 검증 세트를 만들고 싶지만 Kaggle에 예측을 업로드한 후에만 공식 테스트 세트에서 모델을 평가할 수 있습니다.:numref:`fig_house_pricing`의 경쟁 탭에 있는 “데이터” 탭에는 데이터를 다운로드할 수 있는 링크가 있습니다. 
+경쟁 데이터는 훈련 세트와 테스트 세트로 구분됩니다.각 레코드에는 주택의 속성 값과 거리 유형, 건축 연도, 지붕 유형, 지하실 상태 등과 같은 속성이 포함됩니다. 이 기능은 다양한 데이터 유형으로 구성됩니다.예를 들어, 건축 연도는 정수로, 지붕 유형은 불연속 범주형 할당으로, 기타 피쳐는 부동 소수점 숫자로 표시됩니다.그리고 현실이 상황을 복잡하게 만드는 부분이 있습니다. 예를 들어, 일부 데이터는 단순히 “na”로 표시된 누락 된 값으로 완전히 누락되었습니다.각 주택의 가격은 교육 세트에만 포함됩니다 (결국 경쟁입니다).학습 세트를 분할하여 검증 세트를 만들고 싶지만 Kaggle에 예측을 업로드한 후에만 공식 테스트 세트에서 모델을 평가할 수 있습니다.:numref:`fig_house_pricing`의 경쟁 탭에 있는 “데이터” 탭에는 데이터를 다운로드할 수 있는 링크가 있습니다.
 
-시작하기 위해 :numref:`sec_pandas`에서 소개한 [**`pandas`**를 사용하여 데이터를 읽고 처리] 할 것입니다.따라서 계속 진행하기 전에 `pandas`가 설치되어 있는지 확인해야 합니다.다행히도 Jupyter에서 책을 읽고 있다면 노트북을 떠나지 않고도 팬더를 설치할 수 있습니다.
+시작하기 위해 :numref:`sec_pandas`에서 소개한 [**`pandas`를 사용하여 데이터를 읽고 처리**] 할 것입니다.따라서 계속 진행하기 전에 `pandas`가 설치되어 있는지 확인해야 합니다.다행히도 Jupyter에서 책을 읽고 있다면 노트북을 떠나지 않고도 팬더를 설치할 수 있습니다.
 
 ```{.python .input}
 # If pandas is not installed, please uncomment the following line:
@@ -177,7 +177,7 @@ all_features = pd.concat((train_data.iloc[:, 1:-1], test_data.iloc[:, 1:]))
 
 ## 데이터 전처리
 
-위에서 언급한 바와 같이 다양한 데이터 유형이 있습니다.모델링을 시작하기 전에 데이터를 전처리해야 합니다.수치 적 특징부터 시작하겠습니다.먼저 휴리스틱 (**모든 누락된 값을 해당 기능의 평균으로 대체**] 을 적용한 다음, 모든 특징을 공통 척도로 배치하기 위해 특징을 0 평균과 단위 분산으로 다시 스케일링하여 데이터를 표준화**) 합니다. 
+위에서 언급한 바와 같이 다양한 데이터 유형이 있습니다.모델링을 시작하기 전에 데이터를 전처리해야 합니다.수치 적 특징부터 시작하겠습니다.먼저 휴리스틱 (**모든 누락된 값을 해당 기능의 평균으로 대체 을 적용한 다음, 모든 특징을 공통 척도로 배치하기 위해 특징을 0 평균과 단위 분산으로 다시 스케일링하여 데이터를 표준화**) 합니다.
 
 $$x \leftarrow \frac{x - \mu}{\sigma},$$
 
@@ -185,7 +185,7 @@ $$x \leftarrow \frac{x - \mu}{\sigma},$$
 
 ```{.python .input}
 #@tab all
-# If test data were inaccessible, mean and standard deviation could be 
+# If test data were inaccessible, mean and standard deviation could be
 # calculated from training data
 numeric_features = all_features.dtypes[all_features.dtypes != 'object'].index
 all_features[numeric_features] = all_features[numeric_features].apply(
@@ -251,9 +251,9 @@ def get_net():
     return net
 ```
 
-주택 가격은 주가와 마찬가지로 절대 수량보다 상대 수량을 더 중요하게 생각합니다.따라서 [**우리는 절대 오차 $y - \hat{y}$보다 상대 오차 $\frac{y - \hat{y}}{y}$**] 에 더 신경을 쓰는 경향이 있습니다.예를 들어, 전형적인 주택의 가치가 125,000 달러인 오하이오 시골의 주택 가격을 추정 할 때 예측이 100,000 달러 할인된다면 우리는 아마도 끔찍한 일을하고 있을 것입니다.반면에 캘리포니아 로스 알토스 힐스 (Los Altos Hills) 에서이 금액으로 잘못하면 놀랍도록 정확한 예측을 나타낼 수 있습니다 (평균 주택 가격이 400 만 달러를 초과 함). 
+주택 가격은 주가와 마찬가지로 절대 수량보다 상대 수량을 더 중요하게 생각합니다.따라서 [**우리는 절대 오차 $y - \hat{y}$보다 상대 오차 $\frac{y - \hat{y}}{y}$**] 에 더 신경을 쓰는 경향이 있습니다.예를 들어, 전형적인 주택의 가치가 125,000 달러인 오하이오 시골의 주택 가격을 추정 할 때 예측이 100,000 달러 할인된다면 우리는 아마도 끔찍한 일을하고 있을 것입니다.반면에 캘리포니아 로스 알토스 힐스 (Los Altos Hills) 에서이 금액으로 잘못하면 놀랍도록 정확한 예측을 나타낼 수 있습니다 (평균 주택 가격이 400 만 달러를 초과 함).
 
-(**이 문제를 해결하는 한 가지 방법은 가격 견적 로그의 불일치를 측정하는 것입니다.**) 실제로 이는 경쟁 업체가 제출 품질을 평가하기 위해 사용하는 공식 오류 측정치이기도합니다.결국 $|\log y - \log \hat{y}| \leq \delta$에 대한 작은 값 $\delta$는 $e^{-\delta} \leq \frac{\hat{y}}{y} \leq e^\delta$로 변환됩니다.이로 인해 예측 가격의 로그와 라벨 가격의 로그 사이에 다음과 같은 평균 제곱근 오차가 발생합니다. 
+(**이 문제를 해결하는 한 가지 방법은 가격 견적 로그의 불일치를 측정하는 것입니다.**) 실제로 이는 경쟁 업체가 제출 품질을 평가하기 위해 사용하는 공식 오류 측정치이기도합니다.결국 $|\log y - \log \hat{y}| \leq \delta$에 대한 작은 값 $\delta$는 $e^{-\delta} \leq \frac{\hat{y}}{y} \leq e^\delta$로 변환됩니다.이로 인해 예측 가격의 로그와 라벨 가격의 로그 사이에 다음과 같은 평균 제곱근 오차가 발생합니다.
 
 $$\sqrt{\frac{1}{n}\sum_{i=1}^n\left(\log y_i -\log \hat{y}_i\right)^2}.$$
 
@@ -412,7 +412,7 @@ print(f'{k}-fold validation: avg train log rmse: {float(train_l):f}, '
       f'avg valid log rmse: {float(valid_l):f}')
 ```
 
-$K$겹 교차 검증의 오차 수가 상당히 많더라도 하이퍼파라미터 집합에 대한 훈련 오차 수가 매우 적을 수 있는 경우가 있습니다.이는 우리가 과적합되고 있음을 나타냅니다.훈련 내내 두 수치를 모두 모니터링하는 것이 좋습니다.과적합이 적으면 데이터가 더 강력한 모형을 지원할 수 있다는 것을 나타낼 수 있습니다.대규모 과적합은 정규화 기술을 통합하여 얻을 수 있음을 시사 할 수 있습니다. 
+$K$겹 교차 검증의 오차 수가 상당히 많더라도 하이퍼파라미터 집합에 대한 훈련 오차 수가 매우 적을 수 있는 경우가 있습니다.이는 우리가 과적합되고 있음을 나타냅니다.훈련 내내 두 수치를 모두 모니터링하는 것이 좋습니다.과적합이 적으면 데이터가 더 강력한 모형을 지원할 수 있다는 것을 나타낼 수 있습니다.대규모 과적합은 정규화 기술을 통합하여 얻을 수 있음을 시사 할 수 있습니다.
 
 ##  [**Kaggle에 대한 예측 제출**]
 
@@ -444,7 +444,7 @@ train_and_pred(train_features, test_features, train_labels, test_data,
                num_epochs, lr, weight_decay, batch_size)
 ```
 
-다음으로 :numref:`fig_kaggle_submit2`에서 설명한 것처럼 Kaggle에 대한 예측을 제출하고 테스트 세트의 실제 주택 가격 (라벨) 과 어떻게 비교되는지 확인할 수 있습니다.단계는 매우 간단합니다. 
+다음으로 :numref:`fig_kaggle_submit2`에서 설명한 것처럼 Kaggle에 대한 예측을 제출하고 테스트 세트의 실제 주택 가격 (라벨) 과 어떻게 비교되는지 확인할 수 있습니다.단계는 매우 간단합니다.
 
 * Kaggle 웹 사이트에 로그인하고 주택 가격 예측 경쟁 페이지를 방문하십시오.
 * “예측 제출” 또는 “제출 지연” 버튼을 클릭합니다 (이 글을 쓰는 시점에서 버튼은 오른쪽에 있습니다).
diff --git a/chapter_multilayer-perceptrons/mlp.md b/chapter_multilayer-perceptrons/mlp.md
index 140f0ed0..17b94690 100644
--- a/chapter_multilayer-perceptrons/mlp.md
+++ b/chapter_multilayer-perceptrons/mlp.md
@@ -1,36 +1,36 @@
 # 다층 퍼셉트론
 :label:`sec_mlp`
 
-:numref:`chap_linear`에서는 소프트맥스 회귀 (:numref:`sec_softmax`) 를 도입하여 알고리즘을 처음부터 구현하고 (:numref:`sec_softmax_scratch`) 상위 수준 API (:numref:`sec_softmax_concise`) 를 사용하고 저해상도 이미지에서 10개의 의류 범주를 인식하도록 분류자를 교육했습니다.그 과정에서 데이터를 논쟁하고, 출력을 유효한 확률 분포로 강제하고, 적절한 손실 함수를 적용하고, 모델의 매개 변수와 관련하여 최소화하는 방법을 배웠습니다.이제 간단한 선형 모델의 맥락에서 이러한 메커니즘을 마스터했으므로이 책이 주로 관련된 비교적 풍부한 모델 클래스 인 심층 신경망에 대한 탐구를 시작할 수 있습니다. 
+:numref:`chap_linear`에서는 소프트맥스 회귀 (:numref:`sec_softmax`) 를 도입하여 알고리즘을 처음부터 구현하고 (:numref:`sec_softmax_scratch`) 상위 수준 API (:numref:`sec_softmax_concise`) 를 사용하고 저해상도 이미지에서 10개의 의류 범주를 인식하도록 분류자를 교육했습니다.그 과정에서 데이터를 논쟁하고, 출력을 유효한 확률 분포로 강제하고, 적절한 손실 함수를 적용하고, 모델의 매개 변수와 관련하여 최소화하는 방법을 배웠습니다.이제 간단한 선형 모델의 맥락에서 이러한 메커니즘을 마스터했으므로이 책이 주로 관련된 비교적 풍부한 모델 클래스 인 심층 신경망에 대한 탐구를 시작할 수 있습니다.
 
 ## 숨겨진 레이어
 
-우리는 :numref:`subsec_linear_model`에서 아핀 변환을 설명했는데, 이는 바이어스에 의해 추가된 선형 변환입니다.먼저 :numref:`fig_softmaxreg`에 설명된 소프트맥스 회귀 예제에 해당하는 모델 아키텍처를 생각해 보십시오.이 모델은 단일 아핀 변환을 통해 입력을 출력에 직접 매핑한 다음 소프트맥스 연산을 수행했습니다.레이블이 아핀 변환에 의해 입력 데이터와 실제로 관련되어 있다면 이 접근법만으로도 충분할 것입니다.그러나 아핀 변환의 선형성은*강한* 가정입니다. 
+우리는 :numref:`subsec_linear_model`에서 아핀 변환을 설명했는데, 이는 바이어스에 의해 추가된 선형 변환입니다.먼저 :numref:`fig_softmaxreg`에 설명된 소프트맥스 회귀 예제에 해당하는 모델 아키텍처를 생각해 보십시오.이 모델은 단일 아핀 변환을 통해 입력을 출력에 직접 매핑한 다음 소프트맥스 연산을 수행했습니다.레이블이 아핀 변환에 의해 입력 데이터와 실제로 관련되어 있다면 이 접근법만으로도 충분할 것입니다.그러나 아핀 변환의 선형성은*강한* 가정입니다.
 
 ### 선형 모델이 잘못 될 수 있음
 
-예를 들어, 선형성은*단조성*에 대한*약한* 가정을 의미합니다. 즉, 특징이 증가하면 항상 모델 출력이 증가하거나 (해당 가중치가 양수인 경우) 항상 모델 출력이 감소해야 합니다 (해당 가중치가 음수인 경우).때로는 의미가 있습니다.예를 들어, 개인이 대출금을 상환할지 여부를 예측하려는 경우, 다른 모든 것을 동등하게 보유하면 소득이 높은 신청자가 소득이 낮은 신청자보다 항상 상환 할 가능성이 더 높다고 합리적으로 상상할 수 있습니다.단조롭지 만 이 관계는 상환 확률과 선형적으로 연관되지 않을 수 있습니다.소득이 0에서 50,000으로 증가하면 상환 가능성이 1 백만에서 150 만 명으로 증가한 것보다 상환 가능성이 더 커질 수 있습니다.이를 처리하는 한 가지 방법은 예를 들어 소득 로그를 특징으로 사용하여 선형성이 더 그럴듯하게 되도록 데이터를 전처리하는 것입니다. 
+예를 들어, 선형성은*단조성*에 대한*약한* 가정을 의미합니다. 즉, 특징이 증가하면 항상 모델 출력이 증가하거나 (해당 가중치가 양수인 경우) 항상 모델 출력이 감소해야 합니다 (해당 가중치가 음수인 경우).때로는 의미가 있습니다.예를 들어, 개인이 대출금을 상환할지 여부를 예측하려는 경우, 다른 모든 것을 동등하게 보유하면 소득이 높은 신청자가 소득이 낮은 신청자보다 항상 상환 할 가능성이 더 높다고 합리적으로 상상할 수 있습니다.단조롭지 만 이 관계는 상환 확률과 선형적으로 연관되지 않을 수 있습니다.소득이 0에서 50,000으로 증가하면 상환 가능성이 1 백만에서 150 만 명으로 증가한 것보다 상환 가능성이 더 커질 수 있습니다.이를 처리하는 한 가지 방법은 예를 들어 소득 로그를 특징으로 사용하여 선형성이 더 그럴듯하게 되도록 데이터를 전처리하는 것입니다.
 
-단조 로움을 위반하는 예를 쉽게 생각해 낼 수 있습니다.예를 들어 체온에 따라 사망 확률을 예측하고 싶다고 가정 해 보겠습니다.체온이 37°C (98.6°F) 이상인 개인의 경우 온도가 높을수록 위험이 더 큽니다.그러나 체온이 37° C 미만인 개인의 경우 온도가 높을수록 위험이 낮다는 것을 나타냅니다!이 경우에도 영리한 전처리를 통해 문제를 해결할 수 있습니다.즉, 37°C에서의 거리를 특징으로 사용할 수 있습니다. 
+단조 로움을 위반하는 예를 쉽게 생각해 낼 수 있습니다.예를 들어 체온에 따라 사망 확률을 예측하고 싶다고 가정 해 보겠습니다.체온이 37°C (98.6°F) 이상인 개인의 경우 온도가 높을수록 위험이 더 큽니다.그러나 체온이 37° C 미만인 개인의 경우 온도가 높을수록 위험이 낮다는 것을 나타냅니다!이 경우에도 영리한 전처리를 통해 문제를 해결할 수 있습니다.즉, 37°C에서의 거리를 특징으로 사용할 수 있습니다.
 
-하지만 고양이와 개 이미지를 분류하는 것은 어떨까요?위치 (13, 17) 에서 픽셀의 강도를 높이면 이미지가 개를 묘사할 가능성이 항상 증가해야 합니까 (또는 항상 감소) 해야 합니까?선형 모델에 대한 의존도는 고양이와 개를 구별하기 위한 유일한 요구 사항은 개별 픽셀의 밝기를 평가하는 것임을 암시적 가정에 해당합니다.이 접근 방식은 이미지를 반전하면 범주가 유지되는 세상에서 실패 할 운명입니다. 
+하지만 고양이와 개 이미지를 분류하는 것은 어떨까요?위치 (13, 17) 에서 픽셀의 강도를 높이면 이미지가 개를 묘사할 가능성이 항상 증가해야 합니까 (또는 항상 감소) 해야 합니까?선형 모델에 대한 의존도는 고양이와 개를 구별하기 위한 유일한 요구 사항은 개별 픽셀의 밝기를 평가하는 것임을 암시적 가정에 해당합니다.이 접근 방식은 이미지를 반전하면 범주가 유지되는 세상에서 실패 할 운명입니다.
 
-그러나 이전 예제와 비교할 때 선형성의 명백한 부조리가 있음에도 불구하고 간단한 전처리 수정으로 문제를 해결할 수 있다는 것은 분명하지 않습니다.픽셀의 중요성은 컨텍스트 (주변 픽셀의 값) 에 따라 복잡한 방식으로 달라지기 때문입니다.기능 간의 관련 상호 작용을 고려한 데이터 표현이 존재할 수 있지만 그 위에 선형 모델이 적합하지만 손으로 계산하는 방법을 알지 못합니다.심층 신경망에서는 관측 데이터를 사용하여 은닉 레이어를 통한 표현과 해당 표현에 작용하는 선형 예측자를 공동으로 학습했습니다. 
+그러나 이전 예제와 비교할 때 선형성의 명백한 부조리가 있음에도 불구하고 간단한 전처리 수정으로 문제를 해결할 수 있다는 것은 분명하지 않습니다.픽셀의 중요성은 컨텍스트 (주변 픽셀의 값) 에 따라 복잡한 방식으로 달라지기 때문입니다.기능 간의 관련 상호 작용을 고려한 데이터 표현이 존재할 수 있지만 그 위에 선형 모델이 적합하지만 손으로 계산하는 방법을 알지 못합니다.심층 신경망에서는 관측 데이터를 사용하여 은닉 레이어를 통한 표현과 해당 표현에 작용하는 선형 예측자를 공동으로 학습했습니다.
 
 ### 숨겨진 레이어 통합
 
-선형 모델의 이러한 한계를 극복하고 하나 이상의 은닉 레이어를 통합하여 보다 일반적인 함수 클래스를 처리할 수 있습니다.가장 쉬운 방법은 완전히 연결된 여러 레이어를 서로 겹쳐서 쌓는 것입니다.각 레이어는 출력을 생성할 때까지 그 위에 있는 레이어로 공급됩니다.첫 번째 $L-1$ 레이어를 표현으로 생각하고 최종 레이어를 선형 예측 변수로 생각할 수 있습니다.이 아키텍처는 일반적으로*다층 퍼셉트론*이라고 하며, 종종*MLP*로 약칭됩니다.아래에서는 MLP를 다이어그램으로 묘사합니다 (:numref:`fig_mlp`). 
+선형 모델의 이러한 한계를 극복하고 하나 이상의 은닉 레이어를 통합하여 보다 일반적인 함수 클래스를 처리할 수 있습니다.가장 쉬운 방법은 완전히 연결된 여러 레이어를 서로 겹쳐서 쌓는 것입니다.각 레이어는 출력을 생성할 때까지 그 위에 있는 레이어로 공급됩니다.첫 번째 $L-1$ 레이어를 표현으로 생각하고 최종 레이어를 선형 예측 변수로 생각할 수 있습니다.이 아키텍처는 일반적으로*다층 퍼셉트론*이라고 하며, 종종*MLP*로 약칭됩니다.아래에서는 MLP를 다이어그램으로 묘사합니다 (:numref:`fig_mlp`).
 
 ![An MLP with a hidden layer of 5 hidden units. ](../img/mlp.svg)
 :label:`fig_mlp`
 
-이 MLP에는 4개의 입력, 3개의 출력이 있으며, 숨겨진 레이어에는 5개의 은닉 유닛이 있습니다.입력 계층에는 계산이 포함되지 않으므로 이 네트워크를 사용하여 출력값을 생성하려면 은닉 계층과 출력 계층 모두에 대한 계산을 구현해야 합니다. 따라서 이 MLP의 계층 수는 2입니다.이 두 레이어는 모두 완전히 연결되어 있습니다.모든 입력은 은닉 레이어의 모든 뉴런에 영향을 미치며, 각 입력은 출력 레이어의 모든 뉴런에 영향을 미칩니다.그러나 :numref:`subsec_parameterization-cost-fc-layers`에서 제안한 바와 같이 완전히 연결된 레이어를 가진 MLP의 파라미터화 비용은 엄청나게 높을 수 있으며, 이는 입력 또는 출력 크기 :cite:`Zhang.Tay.Zhang.ea.2021`를 변경하지 않고도 파라미터 저장과 모델 효율성 간의 절충을 유발할 수 있습니다. 
+이 MLP에는 4개의 입력, 3개의 출력이 있으며, 숨겨진 레이어에는 5개의 은닉 유닛이 있습니다.입력 계층에는 계산이 포함되지 않으므로 이 네트워크를 사용하여 출력값을 생성하려면 은닉 계층과 출력 계층 모두에 대한 계산을 구현해야 합니다. 따라서 이 MLP의 계층 수는 2입니다.이 두 레이어는 모두 완전히 연결되어 있습니다.모든 입력은 은닉 레이어의 모든 뉴런에 영향을 미치며, 각 입력은 출력 레이어의 모든 뉴런에 영향을 미칩니다.그러나 :numref:`subsec_parameterization-cost-fc-layers`에서 제안한 바와 같이 완전히 연결된 레이어를 가진 MLP의 파라미터화 비용은 엄청나게 높을 수 있으며, 이는 입력 또는 출력 크기 :cite:`Zhang.Tay.Zhang.ea.2021`를 변경하지 않고도 파라미터 저장과 모델 효율성 간의 절충을 유발할 수 있습니다.
 
 ### 선형에서 비선형으로
 
 이전과 마찬가지로 행렬 $\mathbf{X} \in \mathbb{R}^{n \times d}$에서 $n$ 예제의 미니 배치를 나타냅니다. 여기서 각 예제에는 $d$ 입력 (기능) 이 있습니다.은닉 레이어에 $h$개의 은닉 유닛이 있는 단일 은닉 레이어 MLP의 경우 은닉 레이어의 출력을 $\mathbf{H} \in \mathbb{R}^{n \times h}$로 나타냅니다.
 *숨겨진 표현*.
-수학 또는 코드에서 $\mathbf{H}$는*은닉 레이어 변수* 또는*은닉 변수*로도 알려져 있습니다.은닉 레이어와 출력 레이어가 모두 완전히 연결되어 있기 때문에 은닉 레이어 가중치 $\mathbf{W}^{(1)} \in \mathbb{R}^{d \times h}$과 바이어스 $\mathbf{b}^{(1)} \in \mathbb{R}^{1 \times h}$, 출력 레이어 가중치 $\mathbf{W}^{(2)} \in \mathbb{R}^{h \times q}$ 및 편향 $\mathbf{b}^{(2)} \in \mathbb{R}^{1 \times q}$가 있습니다.공식적으로 단일 은닉 레이어 MLP의 출력 $\mathbf{O} \in \mathbb{R}^{n \times q}$을 다음과 같이 계산합니다. 
+수학 또는 코드에서 $\mathbf{H}$는*은닉 레이어 변수* 또는*은닉 변수*로도 알려져 있습니다.은닉 레이어와 출력 레이어가 모두 완전히 연결되어 있기 때문에 은닉 레이어 가중치 $\mathbf{W}^{(1)} \in \mathbb{R}^{d \times h}$과 바이어스 $\mathbf{b}^{(1)} \in \mathbb{R}^{1 \times h}$, 출력 레이어 가중치 $\mathbf{W}^{(2)} \in \mathbb{R}^{h \times q}$ 및 편향 $\mathbf{b}^{(2)} \in \mathbb{R}^{1 \times q}$가 있습니다.공식적으로 단일 은닉 레이어 MLP의 출력 $\mathbf{O} \in \mathbb{R}^{n \times q}$을 다음과 같이 계산합니다.
 
 $$
 \begin{aligned}
@@ -39,15 +39,15 @@ $$
 \end{aligned}
 $$
 
-숨겨진 레이어를 추가한 후 이제 모델에서 추가 파라미터 세트를 추적하고 업데이트해야 합니다.그래서 우리는 그 대가로 무엇을 얻었을까요?위에서 정의한 모델에서*문제에 대해 아무것도 얻지 못한다는 사실에 놀랄 수도 있습니다*!그 이유는 명백합니다.위의 은닉 유닛은 입력값의 아핀 함수에 의해 주어지며, 출력값 (pre-softmax) 은 은닉 유닛의 아핀 함수에 불과합니다.아핀 함수의 아핀 함수 자체가 아핀 함수입니다.게다가 우리의 선형 모델은 이미 모든 아핀 함수를 나타낼 수 있었습니다. 
+숨겨진 레이어를 추가한 후 이제 모델에서 추가 파라미터 세트를 추적하고 업데이트해야 합니다.그래서 우리는 그 대가로 무엇을 얻었을까요?위에서 정의한 모델에서*문제에 대해 아무것도 얻지 못한다는 사실에 놀랄 수도 있습니다*!그 이유는 명백합니다.위의 은닉 유닛은 입력값의 아핀 함수에 의해 주어지며, 출력값 (pre-softmax) 은 은닉 유닛의 아핀 함수에 불과합니다.아핀 함수의 아핀 함수 자체가 아핀 함수입니다.게다가 우리의 선형 모델은 이미 모든 아핀 함수를 나타낼 수 있었습니다.
 
-가중치의 모든 값에 대해 숨겨진 계층을 축소하여 매개 변수 $\mathbf{W} = \mathbf{W}^{(1)}\mathbf{W}^{(2)}$ 및 $\mathbf{b} = \mathbf{b}^{(1)} \mathbf{W}^{(2)} + \mathbf{b}^{(2)}$를 갖는 동등한 단일 계층 모델을 생성 할 수 있음을 증명함으로써 등가를 공식적으로 볼 수 있습니다. 
+가중치의 모든 값에 대해 숨겨진 계층을 축소하여 매개 변수 $\mathbf{W} = \mathbf{W}^{(1)}\mathbf{W}^{(2)}$ 및 $\mathbf{b} = \mathbf{b}^{(1)} \mathbf{W}^{(2)} + \mathbf{b}^{(2)}$를 갖는 동등한 단일 계층 모델을 생성 할 수 있음을 증명함으로써 등가를 공식적으로 볼 수 있습니다.
 
 $$
 \mathbf{O} = (\mathbf{X} \mathbf{W}^{(1)} + \mathbf{b}^{(1)})\mathbf{W}^{(2)} + \mathbf{b}^{(2)} = \mathbf{X} \mathbf{W}^{(1)}\mathbf{W}^{(2)} + \mathbf{b}^{(1)} \mathbf{W}^{(2)} + \mathbf{b}^{(2)} = \mathbf{X} \mathbf{W} + \mathbf{b}.
 $$
 
-다층 아키텍처의 잠재력을 실현하기 위해서는 아핀 변환 후 각 은닉 유닛에 적용할 비선형*활성화 함수* $\sigma$라는 핵심 요소가 하나 더 필요합니다.활성화 함수 (예: $\sigma(\cdot)$) 의 출력을 *활성화*라고 합니다.일반적으로 활성화 함수가 있으면 MLP를 선형 모델로 축소할 수 없습니다. 
+다층 아키텍처의 잠재력을 실현하기 위해서는 아핀 변환 후 각 은닉 유닛에 적용할 비선형*활성화 함수* $\sigma$라는 핵심 요소가 하나 더 필요합니다.활성화 함수 (예: $\sigma(\cdot)$) 의 출력을 *활성화*라고 합니다.일반적으로 활성화 함수가 있으면 MLP를 선형 모델로 축소할 수 없습니다.
 
 $$
 \begin{aligned}
@@ -56,17 +56,17 @@ $$
 \end{aligned}
 $$
 
-$\mathbf{X}$의 각 행은 미니 배치의 예와 일치하므로 표기법을 남용하여 비선형 성 $\sigma$을 행 방식으로, 즉 한 번에 하나의 예제로 입력에 적용 할 비선형 성 $\sigma$을 정의합니다.:numref:`subsec_softmax_vectorization`에서 행별 연산을 나타내는 것과 같은 방식으로 소프트맥스에 대한 표기법을 사용했습니다.이 섹션에서와 같이 히든 레이어에 적용하는 활성화 함수는 행별로 적용되는 것이 아니라 요소별로 적용되는 경우가 많습니다.즉, 레이어의 선형 부분을 계산한 후 다른 은닉 유닛이 취한 값을 보지 않고도 각 활성화를 계산할 수 있습니다.이는 대부분의 활성화 함수에 해당됩니다. 
+$\mathbf{X}$의 각 행은 미니 배치의 예와 일치하므로 표기법을 남용하여 비선형 성 $\sigma$을 행 방식으로, 즉 한 번에 하나의 예제로 입력에 적용 할 비선형 성 $\sigma$을 정의합니다.:numref:`subsec_softmax_vectorization`에서 행별 연산을 나타내는 것과 같은 방식으로 소프트맥스에 대한 표기법을 사용했습니다.이 섹션에서와 같이 히든 레이어에 적용하는 활성화 함수는 행별로 적용되는 것이 아니라 요소별로 적용되는 경우가 많습니다.즉, 레이어의 선형 부분을 계산한 후 다른 은닉 유닛이 취한 값을 보지 않고도 각 활성화를 계산할 수 있습니다.이는 대부분의 활성화 함수에 해당됩니다.
 
-보다 일반적인 MLP를 구축하기 위해 이러한 숨겨진 레이어 (예: $\mathbf{H}^{(1)} = \sigma_1(\mathbf{X} \mathbf{W}^{(1)} + \mathbf{b}^{(1)})$ 및 $\mathbf{H}^{(2)} = \sigma_2(\mathbf{H}^{(1)} \mathbf{W}^{(2)} + \mathbf{b}^{(2)})$) 를 서로 겹쳐 쌓아서 훨씬 더 표현력이 풍부한 모델을 생성 할 수 있습니다. 
+보다 일반적인 MLP를 구축하기 위해 이러한 숨겨진 레이어 (예: $\mathbf{H}^{(1)} = \sigma_1(\mathbf{X} \mathbf{W}^{(1)} + \mathbf{b}^{(1)})$ 및 $\mathbf{H}^{(2)} = \sigma_2(\mathbf{H}^{(1)} \mathbf{W}^{(2)} + \mathbf{b}^{(2)})$) 를 서로 겹쳐 쌓아서 훨씬 더 표현력이 풍부한 모델을 생성 할 수 있습니다.
 
 ### 유니버설 근사기
 
-MLP는 각 입력의 값에 따라 달라지는 숨겨진 뉴런을 통해 입력 간의 복잡한 상호 작용을 포착 할 수 있습니다.숨겨진 노드를 쉽게 설계하여 임의의 계산 (예: 한 쌍의 입력에 대한 기본 논리 연산) 을 수행 할 수 있습니다.또한 활성화 기능의 특정 선택에 대해 MLP가 범용 근사치라는 것이 널리 알려져 있습니다.충분한 노드 (아마도 터무니없이 많은 노드) 와 올바른 가중치 세트가 주어진 단일 은폐 계층 네트워크를 사용하더라도 실제로 그 함수를 배우는 것이 어려운 부분이지만 모든 함수를 모델링 할 수 있습니다.신경망은 C 프로그래밍 언어와 약간 비슷하다고 생각할 수 있습니다.이 언어는 다른 현대 언어와 마찬가지로 계산 가능한 프로그램을 표현할 수 있습니다.하지만 실제로 사양에 맞는 프로그램을 만드는 것은 어려운 부분입니다. 
+MLP는 각 입력의 값에 따라 달라지는 숨겨진 뉴런을 통해 입력 간의 복잡한 상호 작용을 포착 할 수 있습니다.숨겨진 노드를 쉽게 설계하여 임의의 계산 (예: 한 쌍의 입력에 대한 기본 논리 연산) 을 수행 할 수 있습니다.또한 활성화 기능의 특정 선택에 대해 MLP가 범용 근사치라는 것이 널리 알려져 있습니다.충분한 노드 (아마도 터무니없이 많은 노드) 와 올바른 가중치 세트가 주어진 단일 은폐 계층 네트워크를 사용하더라도 실제로 그 함수를 배우는 것이 어려운 부분이지만 모든 함수를 모델링 할 수 있습니다.신경망은 C 프로그래밍 언어와 약간 비슷하다고 생각할 수 있습니다.이 언어는 다른 현대 언어와 마찬가지로 계산 가능한 프로그램을 표현할 수 있습니다.하지만 실제로 사양에 맞는 프로그램을 만드는 것은 어려운 부분입니다.
 
 게다가 단일 은폐 계층 네트워크가
 *모든 기능을 배울 수 있습니다
-단일 은폐 계층 네트워크의 모든 문제를 해결하려고 시도해야 한다는 의미는 아닙니다.실제로 더 깊은 (대 더 넓은) 네트워크를 사용하여 많은 함수를 훨씬 더 간결하게 근사화할 수 있습니다.우리는 다음 장에서 더 엄격한 주장을 다룰 것입니다. 
+단일 은폐 계층 네트워크의 모든 문제를 해결하려고 시도해야 한다는 의미는 아닙니다.실제로 더 깊은 (대 더 넓은) 네트워크를 사용하여 많은 함수를 훨씬 더 간결하게 근사화할 수 있습니다.우리는 다음 장에서 더 엄격한 주장을 다룰 것입니다.
 
 ## 활성화 함수
 :label:`subsec_activation-functions`
@@ -96,7 +96,7 @@ import tensorflow as tf
 
 ### 리루 함수
 
-구현의 단순성과 다양한 예측 작업에서 우수한 성능으로 인해 가장 많이 사용되는 선택은*정류 선형 단위* (*Relu*) 입니다.[**ReLU는 매우 간단한 비선형 변환**] 을 제공합니다.요소 $x$가 주어지면 함수는 해당 요소의 최대값과 $0$로 정의됩니다. 
+구현의 단순성과 다양한 예측 작업에서 우수한 성능으로 인해 가장 많이 사용되는 선택은*정류 선형 단위* (*Relu*) 입니다.[**ReLU는 매우 간단한 비선형 변환**] 을 제공합니다.요소 $x$가 주어지면 함수는 해당 요소의 최대값과 $0$로 정의됩니다.
 
 $$\operatorname{ReLU}(x) = \max(x, 0).$$
 
@@ -145,21 +145,21 @@ d2l.plot(x.numpy(), t.gradient(y, x).numpy(), 'x', 'grad of relu',
          figsize=(5, 2.5))
 ```
 
-ReLU를 사용하는 이유는 파생물이 특히 잘 동작하기 때문입니다. 사라지거나 인수를 통과시킵니다.이로 인해 최적화가 더 잘 작동하고 이전 버전의 신경망을 괴롭혔던 그래디언트가 사라지는 잘 문서화 된 문제가 완화되었습니다 (자세한 내용은 나중에 설명). 
+ReLU를 사용하는 이유는 파생물이 특히 잘 동작하기 때문입니다. 사라지거나 인수를 통과시킵니다.이로 인해 최적화가 더 잘 작동하고 이전 버전의 신경망을 괴롭혔던 그래디언트가 사라지는 잘 문서화 된 문제가 완화되었습니다 (자세한 내용은 나중에 설명).
 
-ReLU 함수에는*매개변수화된 ReLU* (*PreLU*) 함수 :cite:`He.Zhang.Ren.ea.2015`를 포함하여 많은 변형이 있습니다.이 변형은 ReLU에 선형 항을 추가하므로 인수가 음수인 경우에도 일부 정보는 여전히 통과합니다. 
+ReLU 함수에는*매개변수화된 ReLU* (*PreLU*) 함수 :cite:`He.Zhang.Ren.ea.2015`를 포함하여 많은 변형이 있습니다.이 변형은 ReLU에 선형 항을 추가하므로 인수가 음수인 경우에도 일부 정보는 여전히 통과합니다.
 
 $$\operatorname{pReLU}(x) = \max(0, x) + \alpha \min(0, x).$$
 
 ### 시그모이드 함수
 
-[***시그모이드 함수*는 값이 영역 $\mathbb{R}$에 있는 입력**] 을 변환합니다 (**구간 (0, 1) 에 있는 출력으로.**) 이러한 이유로 시그모이드는 종종*스쿼싱 함수*라고 합니다. 범위 (-inf, inf) 의 입력을 범위 (0, 1) 의 값으로 스쿼시합니다. 
+[***시그모이드 함수*는 값이 영역 $\mathbb{R}$에 있는 입력**] 을 변환합니다 (**구간 (0, 1) 에 있는 출력으로.**) 이러한 이유로 시그모이드는 종종*스쿼싱 함수*라고 합니다. 범위 (-inf, inf) 의 입력을 범위 (0, 1) 의 값으로 스쿼시합니다.
 
 $$\operatorname{sigmoid}(x) = \frac{1}{1 + \exp(-x)}.$$
 
-초기 신경망에서 과학자들은*화재* 또는*발사하지 않는*생물학적 뉴런을 모델링하는 데 관심이 있었습니다.따라서이 분야의 개척자들은 인공 뉴런의 발명가 인 McCulloch와 Pitts로 돌아가 임계 단위에 중점을 두었습니다.임계값 활성화는 입력이 일부 임계값보다 작을 때는 값 0을, 입력이 임계값을 초과하면 값 1을 받습니다. 
+초기 신경망에서 과학자들은*화재* 또는*발사하지 않는*생물학적 뉴런을 모델링하는 데 관심이 있었습니다.따라서이 분야의 개척자들은 인공 뉴런의 발명가 인 McCulloch와 Pitts로 돌아가 임계 단위에 중점을 두었습니다.임계값 활성화는 입력이 일부 임계값보다 작을 때는 값 0을, 입력이 임계값을 초과하면 값 1을 받습니다.
 
-주의가 기울기 기반 학습으로 전환되었을 때 시그모이드 함수는 분계점 단위에 대한 부드럽고 미분 가능한 근사치이기 때문에 자연스러운 선택이었습니다.시그모이드는 출력값을 이진 분류 문제에 대한 확률로 해석하고자 할 때 출력 단위의 활성화 함수로 널리 사용됩니다 (시그모이드는 소프트맥스의 특수한 경우라고 생각할 수 있음).그러나 시그모이드는 대부분 은닉 레이어에서 사용하기 위해 더 간단하고 쉽게 훈련 가능한 ReLU로 대체되었습니다.순환 신경망에 대한 이후 장에서는 시그모이드 단위를 활용하여 시간에 따른 정보 흐름을 제어하는 아키텍처에 대해 설명합니다. 
+주의가 기울기 기반 학습으로 전환되었을 때 시그모이드 함수는 분계점 단위에 대한 부드럽고 미분 가능한 근사치이기 때문에 자연스러운 선택이었습니다.시그모이드는 출력값을 이진 분류 문제에 대한 확률로 해석하고자 할 때 출력 단위의 활성화 함수로 널리 사용됩니다 (시그모이드는 소프트맥스의 특수한 경우라고 생각할 수 있음).그러나 시그모이드는 대부분 은닉 레이어에서 사용하기 위해 더 간단하고 쉽게 훈련 가능한 ReLU로 대체되었습니다.순환 신경망에 대한 이후 장에서는 시그모이드 단위를 활용하여 시간에 따른 정보 흐름을 제어하는 아키텍처에 대해 설명합니다.
 
 아래에서는 시그모이드 함수를 플로팅합니다.입력값이 0에 가까우면 시그모이드 함수가 선형 변환에 접근합니다.
 
@@ -181,7 +181,7 @@ y = tf.nn.sigmoid(x)
 d2l.plot(x.numpy(), y.numpy(), 'x', 'sigmoid(x)', figsize=(5, 2.5))
 ```
 
-시그모이드 함수의 도함수는 다음 방정식으로 계산됩니다. 
+시그모이드 함수의 도함수는 다음 방정식으로 계산됩니다.
 
 $$\frac{d}{dx} \operatorname{sigmoid}(x) = \frac{\exp(-x)}{(1 + \exp(-x))^2} = \operatorname{sigmoid}(x)\left(1-\operatorname{sigmoid}(x)\right).$$
 
@@ -210,7 +210,7 @@ d2l.plot(x.numpy(), t.gradient(y, x).numpy(), 'x', 'grad of sigmoid',
 
 ### 탄 함수
 
-시그모이드 함수와 마찬가지로 [**tanh (쌍곡선 탄젠트) 함수는 입력값을**] 스쿼시하여 구간 (**-1과 1** 사이) 의 요소로 변환합니다. 
+시그모이드 함수와 마찬가지로 [**tanh (쌍곡선 탄젠트) 함수는 입력값을**] 스쿼시하여 구간 (**-1과 1**) 사이 의 요소로 변환합니다.
 
 $$\operatorname{tanh}(x) = \frac{1 - \exp(-2x)}{1 + \exp(-2x)}.$$
 
@@ -234,7 +234,7 @@ y = tf.nn.tanh(x)
 d2l.plot(x.numpy(), y.numpy(), 'x', 'tanh(x)', figsize=(5, 2.5))
 ```
 
-tanh 함수의 도함수는 다음과 같습니다. 
+tanh 함수의 도함수는 다음과 같습니다.
 
 $$\frac{d}{dx} \operatorname{tanh}(x) = 1 - \operatorname{tanh}^2(x).$$
 
@@ -261,7 +261,7 @@ d2l.plot(x.numpy(), t.gradient(y, x).numpy(), 'x', 'grad of tanh',
          figsize=(5, 2.5))
 ```
 
-요약하면, 이제 비선형성을 통합하여 표현적인 다층 신경망 아키텍처를 구축하는 방법을 알게 되었습니다.참고로, 귀하의 지식은 이미 1990 년경 실무자와 유사한 툴킷을 지휘하고 있습니다.강력한 오픈 소스 딥 러닝 프레임워크를 활용하여 몇 줄의 코드만으로 모델을 빠르게 구축할 수 있기 때문에 어떤 면에서는 1990년대에 작업하는 사람보다 유리합니다.이전에는 이러한 네트워크를 훈련시키기 위해 연구원들은 수천 줄의 C와 포트란을 코딩해야 했습니다. 
+요약하면, 이제 비선형성을 통합하여 표현적인 다층 신경망 아키텍처를 구축하는 방법을 알게 되었습니다.참고로, 귀하의 지식은 이미 1990 년경 실무자와 유사한 툴킷을 지휘하고 있습니다.강력한 오픈 소스 딥 러닝 프레임워크를 활용하여 몇 줄의 코드만으로 모델을 빠르게 구축할 수 있기 때문에 어떤 면에서는 1990년대에 작업하는 사람보다 유리합니다.이전에는 이러한 네트워크를 훈련시키기 위해 연구원들은 수천 줄의 C와 포트란을 코딩해야 했습니다.
 
 ## 요약
 
diff --git a/chapter_preliminaries/autograd.md b/chapter_preliminaries/autograd.md
index 42eead8c..79c4e1bc 100644
--- a/chapter_preliminaries/autograd.md
+++ b/chapter_preliminaries/autograd.md
@@ -1,9 +1,9 @@
 # 자동 차별화
 :label:`sec_autograd`
 
-:numref:`sec_calculus`에서 설명했듯이 차별화는 거의 모든 딥 러닝 최적화 알고리즘에서 중요한 단계입니다.이러한 도함수를 취하기위한 계산은 간단하지만 몇 가지 기본 미적분학 만 필요하지만 복잡한 모델의 경우 수동으로 업데이트를 수행하는 것은 고통 스러울 수 있습니다 (종종 오류가 발생하기 쉽습니다). 
+:numref:`sec_calculus`에서 설명했듯이 차별화는 거의 모든 딥 러닝 최적화 알고리즘에서 중요한 단계입니다.이러한 도함수를 취하기위한 계산은 간단하지만 몇 가지 기본 미적분학 만 필요하지만 복잡한 모델의 경우 수동으로 업데이트를 수행하는 것은 고통 스러울 수 있습니다 (종종 오류가 발생하기 쉽습니다).
 
-딥 러닝 프레임워크는 도함수 (예: *자동 미분*) 를 자동으로 계산하여 이 작업을 신속하게 처리합니다.실제로 설계된 모델을 기반으로 시스템은*계산 그래프*를 구축하여 어떤 데이터를 결합하여 어떤 작업을 통해 출력을 생성하는지 추적합니다.자동 미분을 통해 시스템은 그라디언트를 역전파할 수 있습니다.여기서*backpropagate*는 단순히 계산 그래프를 통해 추적하여 각 매개 변수에 대한 편도함수를 채우는 것을 의미합니다. 
+딥 러닝 프레임워크는 도함수 (예: *자동 미분*) 를 자동으로 계산하여 이 작업을 신속하게 처리합니다.실제로 설계된 모델을 기반으로 시스템은*계산 그래프*를 구축하여 어떤 데이터를 결합하여 어떤 작업을 통해 출력을 생성하는지 추적합니다.자동 미분을 통해 시스템은 그라디언트를 역전파할 수 있습니다.여기서*backpropagate*는 단순히 계산 그래프를 통해 추적하여 각 매개 변수에 대한 편도함수를 채우는 것을 의미합니다.
 
 ## 간단한 예제
 
@@ -78,7 +78,7 @@ with tf.GradientTape() as t:
 y
 ```
 
-`x`는 길이가 4인 벡터이므로 `x` 및 `x`의 내적이 수행되어 `y`에 할당하는 스칼라 출력값이 생성됩니다.다음으로 역전파 함수를 호출하고 그래디언트를 인쇄하여 [**`x`**의 각 구성 요소에 대한 `y`의 기울기를 자동으로 계산할 수 있습니다].
+`x`는 길이가 4인 벡터이므로 `x` 및 `x`의 내적이 수행되어 `y`에 할당하는 스칼라 출력값이 생성됩니다.다음으로 역전파 함수를 호출하고 그래디언트를 인쇄하여 `x`의 각 구성 요소에 대한 `y`의 기울기를 자동으로 계산할 수 있습니다.
 
 ```{.python .input}
 y.backward()
@@ -97,7 +97,7 @@ x_grad = t.gradient(y, x)
 x_grad
 ```
 
-(**$\mathbf{x}$에 대한 함수 $y = 2\mathbf{x}^{\top}\mathbf{x}$의 기울기는 $4\mathbf{x}$.**이어야 합니다.) 원하는 기울기가 올바르게 계산되었는지 신속하게 확인하겠습니다.
+(**$\mathbf{x}$에 대한 함수 $y = 2\mathbf{x}^{\top}\mathbf{x}$의 기울기는 $4\mathbf{x}$.이어야 합니다.**) 원하는 기울기가 올바르게 계산되었는지 신속하게 확인하겠습니다.
 
 ```{.python .input}
 x.grad == 4 * x
@@ -113,7 +113,7 @@ x.grad == 4 * x
 x_grad == 4 * x
 ```
 
-[**이제 `x`.**의 다른 함수를 계산해 보겠습니다.]
+[**이제 `x`.의 다른 함수를 계산해 보겠습니다.**]
 
 ```{.python .input}
 with autograd.record():
@@ -141,7 +141,7 @@ t.gradient(y, x)  # Overwritten by the newly calculated gradient
 
 ## 스칼라 변수가 아닌 경우 역방향
 
-기술적으로 `y`가 스칼라가 아닌 경우 벡터 `x`에 대한 벡터 `y`의 미분을 가장 자연스럽게 해석하는 것은 행렬입니다.고차 및 고차원 `y` 및 `x`의 경우 차별화 결과는 고차 텐서가 될 수 있습니다. 
+기술적으로 `y`가 스칼라가 아닌 경우 벡터 `x`에 대한 벡터 `y`의 미분을 가장 자연스럽게 해석하는 것은 행렬입니다.고차 및 고차원 `y` 및 `x`의 경우 차별화 결과는 고차 텐서가 될 수 있습니다.
 
 그러나 이러한 이국적인 객체는 고급 기계 학습 ([**딥 러닝에서**] 포함) 에 나타나지만, 더 자주 (**벡터를 역방향으로 호출 할 때**) 훈련 예제의*배치*의 각 구성 요소에 대한 손실 함수의 도함수를 계산하려고합니다.여기서 (**우리의 의도는**) 미분 행렬을 계산하는 것이 아니라 배치에서 (**각 예에 대해 개별적으로 계산된 편도함수의 합**) 을 계산하는 것입니다.
 
@@ -177,7 +177,7 @@ t.gradient(y, x)  # Same as `y = tf.reduce_sum(x * x)`
 
 ## 분리 계산
 
-경우에 따라 [**기록된 계산 그래프 외부로 일부 계산을 이동**] 예를 들어 `y`이 `x`의 함수로 계산되었고 이후 `z`가 `y`과 `x`의 함수로 계산되었다고 가정해 보겠습니다.이제 `x`와 관련하여 `z`의 기울기를 계산하고 싶었지만 어떤 이유로 `y`을 상수로 취급하고 `y`이 계산 된 후 `x`가 수행 한 역할만 고려하기를 원한다고 상상해보십시오. 
+경우에 따라 [**기록된 계산 그래프 외부로 일부 계산을 이동**] 예를 들어 `y`이 `x`의 함수로 계산되었고 이후 `z`가 `y`과 `x`의 함수로 계산되었다고 가정해 보겠습니다.이제 `x`와 관련하여 `z`의 기울기를 계산하고 싶었지만 어떤 이유로 `y`을 상수로 취급하고 `y`이 계산 된 후 `x`가 수행 한 역할만 고려하기를 원한다고 상상해보십시오.
 
 여기서 `y`를 분리하여 `y`와 동일한 값을 갖지만 계산 그래프에서 `y`가 어떻게 계산되었는지에 대한 정보는 버리는 새 변수 `u`을 반환할 수 있습니다.즉, 그라데이션은 `u`을 통해 `x`까지 뒤로 흐르지 않습니다.따라서, 다음의 역전파 함수는 `x`에 대한 `z = x * x * x`의 편미분 대신 `u`을 상수로 처리하면서 `x`에 대한 `z = u * x`의 편도함수를 계산한다.
 
diff --git a/chapter_preliminaries/calculus.md b/chapter_preliminaries/calculus.md
index 70baccbd..385b515d 100644
--- a/chapter_preliminaries/calculus.md
+++ b/chapter_preliminaries/calculus.md
@@ -1,28 +1,28 @@
 # 미적분
 :label:`sec_calculus`
 
-다각형의 면적을 찾는 것은 적어도 2,500년 전까지 고대 그리스인들이 다각형을 삼각형으로 나누고 면적을 합산할 때까지 신비로 남아있었습니다.원과 같은 곡선 모양의 영역을 찾기 위해 고대 그리스인들은 이러한 모양의 다각형을 새겼습니다.:numref:`fig_circle_area`에서 볼 수 있듯이 길이가 같은 변이 더 많은 내접 다각형은 원과 더 비슷합니다.이 과정은*소진 방법*으로도 알려져 있습니다. 
+다각형의 면적을 찾는 것은 적어도 2,500년 전까지 고대 그리스인들이 다각형을 삼각형으로 나누고 면적을 합산할 때까지 신비로 남아있었습니다.원과 같은 곡선 모양의 영역을 찾기 위해 고대 그리스인들은 이러한 모양의 다각형을 새겼습니다.:numref:`fig_circle_area`에서 볼 수 있듯이 길이가 같은 변이 더 많은 내접 다각형은 원과 더 비슷합니다.이 과정은*소진 방법*으로도 알려져 있습니다.
 
 ![Find the area of a circle with the method of exhaustion.](../img/polygon-circle.svg)
 :label:`fig_circle_area`
 
-실제로 고갈 방법은*적분 미적분* (:numref:`sec_integral_calculus`에 설명 됨) 이 시작된 곳입니다.2,000년이 지난 후, 미적분학의 다른 지점인 *미적분학*이 발명되었습니다.미분 미적분학의 가장 중요한 응용 분야 중 최적화 문제는*최고*를 수행하는 방법을 고려합니다.:numref:`subsec_norms_and_objectives`에서 설명한 것처럼 이러한 문제는 딥 러닝에서 어디에나 존재합니다. 
+실제로 고갈 방법은*적분 미적분* (:numref:`sec_integral_calculus`에 설명 됨) 이 시작된 곳입니다.2,000년이 지난 후, 미적분학의 다른 지점인 *미적분학*이 발명되었습니다.미분 미적분학의 가장 중요한 응용 분야 중 최적화 문제는*최고*를 수행하는 방법을 고려합니다.:numref:`subsec_norms_and_objectives`에서 설명한 것처럼 이러한 문제는 딥 러닝에서 어디에나 존재합니다.
 
-딥 러닝에서는 점점 더 많은 데이터를 볼 때 더 좋아질 수 있도록 모델을 연속적으로 업데이트하여*훈련* 합니다.일반적으로 더 나아진다는 것은 “모델이 얼마나 나쁜지*”라는 질문에 답하는 점수인*손실 함수*를 최소화하는 것을 의미합니다.이 질문은 보이는 것보다 더 미묘합니다.궁극적으로 우리가 정말로 관심을 갖는 것은 이전에 보지 못했던 데이터에서 잘 작동하는 모델을 만드는 것입니다.하지만 실제로 볼 수 있는 데이터에만 모델을 맞출 수 있습니다.따라서 모델을 피팅하는 작업을 두 가지 주요 관심사로 분해 할 수 있습니다. (i) *최적화*: 관찰 된 데이터에 모델을 피팅하는 프로세스; (ii) *일반화*: 유효성이 정확한 데이터 세트를 넘어서는 모델을 생성하는 방법을 안내하는 수학적 원리와 실무자의 지혜예제를 훈련시키는 데 사용됩니다. 
+딥 러닝에서는 점점 더 많은 데이터를 볼 때 더 좋아질 수 있도록 모델을 연속적으로 업데이트하여*훈련* 합니다.일반적으로 더 나아진다는 것은 “모델이 얼마나 나쁜지*”라는 질문에 답하는 점수인*손실 함수*를 최소화하는 것을 의미합니다.이 질문은 보이는 것보다 더 미묘합니다.궁극적으로 우리가 정말로 관심을 갖는 것은 이전에 보지 못했던 데이터에서 잘 작동하는 모델을 만드는 것입니다.하지만 실제로 볼 수 있는 데이터에만 모델을 맞출 수 있습니다.따라서 모델을 피팅하는 작업을 두 가지 주요 관심사로 분해 할 수 있습니다. (i) *최적화*: 관찰 된 데이터에 모델을 피팅하는 프로세스; (ii) *일반화*: 유효성이 정확한 데이터 세트를 넘어서는 모델을 생성하는 방법을 안내하는 수학적 원리와 실무자의 지혜예제를 훈련시키는 데 사용됩니다.
 
-이후 장에서 최적화 문제와 방법을 이해하는 데 도움이 되도록 딥 러닝에서 일반적으로 사용되는 미분 미적분에 대한 간략한 입문서를 제공합니다. 
+이후 장에서 최적화 문제와 방법을 이해하는 데 도움이 되도록 딥 러닝에서 일반적으로 사용되는 미분 미적분에 대한 간략한 입문서를 제공합니다.
 
 ## 파생 상품 및 차별화
 
-먼저 거의 모든 딥러닝 최적화 알고리즘에서 중요한 단계인 도함수 계산을 다룹니다.딥러닝에서는 일반적으로 모델의 파라미터와 관련하여 구분할 수 있는 손실 함수를 선택합니다.간단히 말해서, 이것은 각 매개 변수에 대해 손실이 얼마나 빨리 증가 또는 감소하는지 결정할 수 있음을 의미합니다. 즉, 해당 매개 변수를 무한히 적은 양으로*증가* 또는*감소*할 수 있습니다. 
+먼저 거의 모든 딥러닝 최적화 알고리즘에서 중요한 단계인 도함수 계산을 다룹니다.딥러닝에서는 일반적으로 모델의 파라미터와 관련하여 구분할 수 있는 손실 함수를 선택합니다.간단히 말해서, 이것은 각 매개 변수에 대해 손실이 얼마나 빨리 증가 또는 감소하는지 결정할 수 있음을 의미합니다. 즉, 해당 매개 변수를 무한히 적은 양으로*증가* 또는*감소*할 수 있습니다.
 
-입력과 출력이 모두 스칼라 인 함수 $f: \mathbb{R} \rightarrow \mathbb{R}$가 있다고 가정합니다.[**$f$의*미분*은 다음과 같이 정의됩니다.] 
+입력과 출력이 모두 스칼라 인 함수 $f: \mathbb{R} \rightarrow \mathbb{R}$가 있다고 가정합니다.$f$의*미분*은 다음과 같이 정의됩니다.
 
-(**$f'(x) = \lim_{h \rightarrow 0} \frac{f(x+h) - f(x)}{h},$달러**) :eqlabel:`eq_derivative` 
+(**$f'(x) = \lim_{h \rightarrow 0} \frac{f(x+h) - f(x)}{h},$달러**) :eqlabel:`eq_derivative`
 
-이 제한이 존재하는 경우$f'(a)$가 존재하는 경우 $f$은 $a$에서*차별화 가능한*이라고 합니다.$f$이 구간의 모든 수에서 미분 가능한 경우 이 함수는 이 구간에서 미분 가능합니다.:eqref:`eq_derivative`의 도함수 $f'(x)$을 $x$에 대한 $f(x)$의*순간적* 변화율로 해석할 수 있습니다.소위 순간 변화율은 $x$의 변동 $h$을 기반으로하며, 이는 $0$에 근접합니다. 
+이 제한이 존재하는 경우$f'(a)$가 존재하는 경우 $f$은 $a$에서*차별화 가능한*이라고 합니다.$f$이 구간의 모든 수에서 미분 가능한 경우 이 함수는 이 구간에서 미분 가능합니다.:eqref:`eq_derivative`의 도함수 $f'(x)$을 $x$에 대한 $f(x)$의*순간적* 변화율로 해석할 수 있습니다.소위 순간 변화율은 $x$의 변동 $h$을 기반으로하며, 이는 $0$에 근접합니다.
 
-도함수를 설명하기 위해 예제를 사용해 보겠습니다.(**$u = f(x) = 3x^2-4x$.** 정의)
+도함수를 설명하기 위해 예제를 사용해 보겠습니다.(**$u = f(x) = 3x^2-4x$. 정의**)
 
 ```{.python .input}
 %matplotlib inline
@@ -70,34 +70,34 @@ for i in range(5):
     h *= 0.1
 ```
 
-파생 상품에 대한 몇 가지 동등한 표기법을 익히겠습니다.$y = f(x)$을 감안할 때, 여기서 $x$와 $y$는 각각 함수 $f$의 독립 변수이자 종속 변수입니다.다음 표현식은 동일합니다. 
+파생 상품에 대한 몇 가지 동등한 표기법을 익히겠습니다.$y = f(x)$을 감안할 때, 여기서 $x$와 $y$는 각각 함수 $f$의 독립 변수이자 종속 변수입니다.다음 표현식은 동일합니다.
 
 $$f'(x) = y' = \frac{dy}{dx} = \frac{df}{dx} = \frac{d}{dx} f(x) = Df(x) = D_x f(x),$$
 
-여기서 기호 $\frac{d}{dx}$ 및 $D$는*미분*의 연산을 나타내는*미분 연산자*입니다.다음 규칙을 사용하여 공통 함수를 구분할 수 있습니다. 
+여기서 기호 $\frac{d}{dx}$ 및 $D$는*미분*의 연산을 나타내는*미분 연산자*입니다.다음 규칙을 사용하여 공통 함수를 구분할 수 있습니다.
 
 * $DC = 0$ ($C$는 상수입니다),
 * $Dx^n = nx^{n-1}$ (*거듭제곱 규칙*, $n$는 임의의 실수입니다),
 * $De^x = e^x$,
 * $D\ln(x) = 1/x.$
 
-위의 공통 함수와 같은 몇 가지 간단한 함수로 구성된 함수를 구별하기 위해 다음 규칙이 유용 할 수 있습니다.함수 $f$과 $g$가 모두 미분 가능하고 $C$가 상수라고 가정하면*상수 다중 규칙*이 있습니다. 
+위의 공통 함수와 같은 몇 가지 간단한 함수로 구성된 함수를 구별하기 위해 다음 규칙이 유용 할 수 있습니다.함수 $f$과 $g$가 모두 미분 가능하고 $C$가 상수라고 가정하면*상수 다중 규칙*이 있습니다.
 
 $$\frac{d}{dx} [Cf(x)] = C \frac{d}{dx} f(x),$$
 
-*합계 규칙* 
+*합계 규칙*
 
 $$\frac{d}{dx} [f(x) + g(x)] = \frac{d}{dx} f(x) + \frac{d}{dx} g(x),$$
 
-*제품 규칙* 
+*제품 규칙*
 
 $$\frac{d}{dx} [f(x)g(x)] = f(x) \frac{d}{dx} [g(x)] + g(x) \frac{d}{dx} [f(x)],$$
 
-그리고*몫 규칙* 
+그리고*몫 규칙*
 
 $$\frac{d}{dx} \left[\frac{f(x)}{g(x)}\right] = \frac{g(x) \frac{d}{dx} [f(x)] - f(x) \frac{d}{dx} [g(x)]}{[g(x)]^2}.$$
 
-이제 위의 규칙 중 몇 가지를 적용하여 $u' = f'(x) = 3 \frac{d}{dx} x^2-4\frac{d}{dx}x = 6x-4$을 찾을 수 있습니다.따라서 $x = 1$를 설정하면 $u' = 2$가 생깁니다. 이는 수치 결과가 $2$에 접근하는 이 섹션의 이전 실험에서 뒷받침됩니다.이 도함수는 $x = 1$일 때 곡선 $u = f(x)$에 대한 접선의 기울기이기도 합니다. 
+이제 위의 규칙 중 몇 가지를 적용하여 $u' = f'(x) = 3 \frac{d}{dx} x^2-4\frac{d}{dx}x = 6x-4$을 찾을 수 있습니다.따라서 $x = 1$를 설정하면 $u' = 2$가 생깁니다. 이는 수치 결과가 $2$에 접근하는 이 섹션의 이전 실험에서 뒷받침됩니다.이 도함수는 $x = 1$일 때 곡선 $u = f(x)$에 대한 접선의 기울기이기도 합니다.
 
 [**이러한 도함수 해석을 시각화하기 위해 파이썬에서 널리 사용되는 플로팅 라이브러리인 `matplotlib`, **] 를 사용할 것입니다.`matplotlib`에서 생성된 그림의 속성을 구성하려면 몇 가지 함수를 정의해야 합니다.다음에서 `use_svg_display` 함수는 더 선명한 이미지를 위해 svg 그림을 출력할 `matplotlib` 패키지를 지정합니다.`# @save `주석은 다음 함수, 클래스 또는 명령문이 `d2l` 패키지에 저장되어 나중에 다시 정의하지 않고 직접 호출 (예: `d2l.use_svg_display()`) 할 수 있는 특별한 표시입니다.
 
@@ -173,7 +173,7 @@ def plot(X, Y=None, xlabel=None, ylabel=None, legend=None, xlim=None,
     set_axes(axes, xlabel, ylabel, xlim, ylim, xscale, yscale, legend)
 ```
 
-이제 [**함수 $u = f(x)$와 해당 접선 $y = 2x - 3$을 $x=1$**에 플로팅할 수 있습니다. 여기서 계수 $2$는 접선의 기울기입니다.
+이제 [**함수 $u = f(x)$와 해당 접선 $y = 2x - 3$을 $x=1$**]에 플로팅할 수 있습니다. 여기서 계수 $2$는 접선의 기울기입니다.
 
 ```{.python .input}
 #@tab all
@@ -183,47 +183,47 @@ plot(x, [f(x), 2 * x - 3], 'x', 'f(x)', legend=['f(x)', 'Tangent line (x=1)'])
 
 ## 부분 도함수
 
-지금까지 우리는 단 하나의 변수의 함수의 차별화를 다루었습니다.딥러닝에서 함수는 종종*많은* 변수에 종속됩니다.따라서 차별화 아이디어를 이러한*다변량* 함수로 확장해야 합니다. 
+지금까지 우리는 단 하나의 변수의 함수의 차별화를 다루었습니다.딥러닝에서 함수는 종종*많은* 변수에 종속됩니다.따라서 차별화 아이디어를 이러한*다변량* 함수로 확장해야 합니다.
 
-$y = f(x_1, x_2, \ldots, x_n)$을 변수가 $n$인 함수로 설정합니다.$i^\mathrm{th}$ 매개변수 $x_i$에 대한 $y$의*편미함*은 다음과 같습니다. 
+$y = f(x_1, x_2, \ldots, x_n)$을 변수가 $n$인 함수로 설정합니다.$i^\mathrm{th}$ 매개변수 $x_i$에 대한 $y$의*편미함*은 다음과 같습니다.
 
 $$ \frac{\partial y}{\partial x_i} = \lim_{h \rightarrow 0} \frac{f(x_1, \ldots, x_{i-1}, x_i+h, x_{i+1}, \ldots, x_n) - f(x_1, \ldots, x_i, \ldots, x_n)}{h}.$$
 
-$\frac{\partial y}{\partial x_i}$을 계산하기 위해 $x_1, \ldots, x_{i-1}, x_{i+1}, \ldots, x_n$를 상수로 취급하고 $x_i$에 대해 $y$의 미분을 계산할 수 있습니다.편도함수 표기법의 경우 다음과 같습니다. 
+$\frac{\partial y}{\partial x_i}$을 계산하기 위해 $x_1, \ldots, x_{i-1}, x_{i+1}, \ldots, x_n$를 상수로 취급하고 $x_i$에 대해 $y$의 미분을 계산할 수 있습니다.편도함수 표기법의 경우 다음과 같습니다.
 
 $$\frac{\partial y}{\partial x_i} = \frac{\partial f}{\partial x_i} = f_{x_i} = f_i = D_i f = D_{x_i} f.$$
 
 ## 그라디언트
 :label:`subsec_calculus-grad`
 
-모든 변수에 대해 다변량 함수의 편도함수를 결합하여 함수의*gradient* 벡터를 얻을 수 있습니다.함수 $f: \mathbb{R}^n \rightarrow \mathbb{R}$의 입력값이 $n$차원 벡터 $\mathbf{x} = [x_1, x_2, \ldots, x_n]^\top$이고 출력값이 스칼라라고 가정합니다.$\mathbf{x}$에 대한 함수 $f(\mathbf{x})$의 기울기는 $n$ 편도함수로 구성된 벡터입니다. 
+모든 변수에 대해 다변량 함수의 편도함수를 결합하여 함수의*gradient* 벡터를 얻을 수 있습니다.함수 $f: \mathbb{R}^n \rightarrow \mathbb{R}$의 입력값이 $n$차원 벡터 $\mathbf{x} = [x_1, x_2, \ldots, x_n]^\top$이고 출력값이 스칼라라고 가정합니다.$\mathbf{x}$에 대한 함수 $f(\mathbf{x})$의 기울기는 $n$ 편도함수로 구성된 벡터입니다.
 
 $$\nabla_{\mathbf{x}} f(\mathbf{x}) = \bigg[\frac{\partial f(\mathbf{x})}{\partial x_1}, \frac{\partial f(\mathbf{x})}{\partial x_2}, \ldots, \frac{\partial f(\mathbf{x})}{\partial x_n}\bigg]^\top,$$
 
-여기서 $\nabla_{\mathbf{x}} f(\mathbf{x})$는 모호성이 없는 경우 $\nabla f(\mathbf{x})$로 대체되는 경우가 많습니다. 
+여기서 $\nabla_{\mathbf{x}} f(\mathbf{x})$는 모호성이 없는 경우 $\nabla f(\mathbf{x})$로 대체되는 경우가 많습니다.
 
-$\mathbf{x}$를 $n$차원 벡터로 설정합니다. 다변량 함수를 구분할 때 다음 규칙이 자주 사용됩니다. 
+$\mathbf{x}$를 $n$차원 벡터로 설정합니다. 다변량 함수를 구분할 때 다음 규칙이 자주 사용됩니다.
 
 * 모든 $\mathbf{A} \in \mathbb{R}^{m \times n}$, $\nabla_{\mathbf{x}} \mathbf{A} \mathbf{x} = \mathbf{A}^\top$에 대해,
 * 모든 $\mathbf{A} \in \mathbb{R}^{n \times m}$, $\nabla_{\mathbf{x}} \mathbf{x}^\top \mathbf{A}  = \mathbf{A}$에 대해,
 * 모든 $\mathbf{A} \in \mathbb{R}^{n \times n}$, $\nabla_{\mathbf{x}} \mathbf{x}^\top \mathbf{A} \mathbf{x}  = (\mathbf{A} + \mathbf{A}^\top)\mathbf{x}$에 대해,
 * $\nabla_{\mathbf{x}} \|\mathbf{x} \|^2 = \nabla_{\mathbf{x}} \mathbf{x}^\top \mathbf{x} = 2\mathbf{x}$.
 
-마찬가지로 모든 행렬 $\mathbf{X}$에 대해 $\nabla_{\mathbf{X}} \|\mathbf{X} \|_F^2 = 2\mathbf{X}$가 있습니다.나중에 살펴보겠지만 그래디언트는 딥러닝에서 최적화 알고리즘을 설계하는 데 유용합니다. 
+마찬가지로 모든 행렬 $\mathbf{X}$에 대해 $\nabla_{\mathbf{X}} \|\mathbf{X} \|_F^2 = 2\mathbf{X}$가 있습니다.나중에 살펴보겠지만 그래디언트는 딥러닝에서 최적화 알고리즘을 설계하는 데 유용합니다.
 
 ## 체인 룰
 
-그러나 이러한 그라디언트는 찾기가 어려울 수 있습니다.이는 딥러닝의 다변량 함수가 종종*복합적*이기 때문에 이러한 함수를 구분하기 위해 앞서 언급한 규칙을 적용하지 않을 수 있기 때문입니다.다행히도*체인 규칙*을 사용하면 복합 함수를 구분할 수 있습니다. 
+그러나 이러한 그라디언트는 찾기가 어려울 수 있습니다.이는 딥러닝의 다변량 함수가 종종*복합적*이기 때문에 이러한 함수를 구분하기 위해 앞서 언급한 규칙을 적용하지 않을 수 있기 때문입니다.다행히도*체인 규칙*을 사용하면 복합 함수를 구분할 수 있습니다.
 
-먼저 단일 변수의 함수를 고려해 보겠습니다.함수 $y=f(u)$와 $u=g(x)$가 모두 미분 가능하다고 가정하면 연쇄 규칙은 다음과 같이 명시합니다. 
+먼저 단일 변수의 함수를 고려해 보겠습니다.함수 $y=f(u)$와 $u=g(x)$가 모두 미분 가능하다고 가정하면 연쇄 규칙은 다음과 같이 명시합니다.
 
 $$\frac{dy}{dx} = \frac{dy}{du} \frac{du}{dx}.$$
 
-이제 함수에 임의의 수의 변수가 있는 좀 더 일반적인 시나리오를 살펴보겠습니다.미분 가능 함수 $y$에 변수 $u_1, u_2, \ldots, u_m$가 있으며, 여기서 각 미분 가능 함수 $u_i$에는 변수 $x_1, x_2, \ldots, x_n$이 있다고 가정합니다.$y$은 $x_1, x_2, \ldots, x_n$의 함수라는 점에 유의하십시오.그런 다음 체인 규칙이 
+이제 함수에 임의의 수의 변수가 있는 좀 더 일반적인 시나리오를 살펴보겠습니다.미분 가능 함수 $y$에 변수 $u_1, u_2, \ldots, u_m$가 있으며, 여기서 각 미분 가능 함수 $u_i$에는 변수 $x_1, x_2, \ldots, x_n$이 있다고 가정합니다.$y$은 $x_1, x_2, \ldots, x_n$의 함수라는 점에 유의하십시오.그런 다음 체인 규칙이
 
 $$\frac{dy}{dx_i} = \frac{dy}{du_1} \frac{du_1}{dx_i} + \frac{dy}{du_2} \frac{du_2}{dx_i} + \cdots + \frac{dy}{du_m} \frac{du_m}{dx_i}$$
 
-모든 $i = 1, 2, \ldots, n$를 위해. 
+모든 $i = 1, 2, \ldots, n$를 위해.
 
 ## 요약
 
diff --git a/chapter_preliminaries/linear-algebra.md b/chapter_preliminaries/linear-algebra.md
index 02f01363..2271954c 100644
--- a/chapter_preliminaries/linear-algebra.md
+++ b/chapter_preliminaries/linear-algebra.md
@@ -1,13 +1,13 @@
 # 선형 대수
 :label:`sec_linear-algebra`
 
-이제 데이터를 저장하고 조작할 수 있으므로 이 책에서 다루는 대부분의 모델을 이해하고 구현하는 데 필요한 기본 선형 대수의 하위 집합을 간략하게 살펴보겠습니다.아래에서는 선형 대수의 기본 수학 객체, 산술 및 연산을 소개하고 수학적 표기법과 해당 코드 구현을 통해 각각을 표현합니다. 
+이제 데이터를 저장하고 조작할 수 있으므로 이 책에서 다루는 대부분의 모델을 이해하고 구현하는 데 필요한 기본 선형 대수의 하위 집합을 간략하게 살펴보겠습니다.아래에서는 선형 대수의 기본 수학 객체, 산술 및 연산을 소개하고 수학적 표기법과 해당 코드 구현을 통해 각각을 표현합니다.
 
 ## 스칼라
 
-선형 대수학이나 기계 학습을 공부한 적이 없다면 과거 수학 경험은 아마도 한 번에 하나의 숫자를 생각하는 것으로 구성되었을 것입니다.그리고 수표 책의 균형을 맞추거나 식당에서 저녁 식사를 지불 한 적이 있다면 숫자 쌍을 더하고 곱하는 것과 같은 기본적인 작업을 수행하는 방법을 이미 알고 있습니다.예를 들어 팔로 알토의 온도는 화씨 $52$도입니다.공식적으로, 우리는 단지 하나의 숫자*스칼라*로 구성된 값을 호출합니다.이 값을 섭씨 (미터법 시스템의 보다 합리적인 온도 눈금) 로 변환하려면 $f$을 $52$으로 설정하여 $c = \frac{5}{9}(f - 32)$ 표현식을 평가해야 합니다.이 방정식에서 각 항 ($5$, $9$ 및 $32$) 은 스칼라 값입니다.자리 표시자 $c$ 및 $f$은*변수*라고 하며 알 수 없는 스칼라 값을 나타냅니다. 
+선형 대수학이나 기계 학습을 공부한 적이 없다면 과거 수학 경험은 아마도 한 번에 하나의 숫자를 생각하는 것으로 구성되었을 것입니다.그리고 수표 책의 균형을 맞추거나 식당에서 저녁 식사를 지불 한 적이 있다면 숫자 쌍을 더하고 곱하는 것과 같은 기본적인 작업을 수행하는 방법을 이미 알고 있습니다.예를 들어 팔로 알토의 온도는 화씨 $52$도입니다.공식적으로, 우리는 단지 하나의 숫자*스칼라*로 구성된 값을 호출합니다.이 값을 섭씨 (미터법 시스템의 보다 합리적인 온도 눈금) 로 변환하려면 $f$을 $52$으로 설정하여 $c = \frac{5}{9}(f - 32)$ 표현식을 평가해야 합니다.이 방정식에서 각 항 ($5$, $9$ 및 $32$) 은 스칼라 값입니다.자리 표시자 $c$ 및 $f$은*변수*라고 하며 알 수 없는 스칼라 값을 나타냅니다.
 
-이 책에서는 스칼라 변수가 일반 소문자로 표시되는 수학적 표기법을 채택합니다 (예: $x$, $y$ 및 $z$).우리는 모든 (연속) *실수 값* 스칼라의 공간을 $\mathbb{R}$으로 나타냅니다.편의를 위해 정확히*공간*이 무엇인지에 대한 엄격한 정의를 펀트 할 것입니다. 하지만 지금은 $x \in \mathbb{R}$이라는 표현식이 $x$이 실수 값 스칼라라고 말하는 공식적인 방법이라는 것을 기억하십시오.기호 $\in$는 “in”으로 발음 할 수 있으며 단순히 집합의 구성원을 나타냅니다.마찬가지로 $x, y \in \{0, 1\}$을 작성하여 $x$과 $y$가 값이 $0$ 또는 $1$일 수 있는 숫자임을 나타낼 수 있습니다. 
+이 책에서는 스칼라 변수가 일반 소문자로 표시되는 수학적 표기법을 채택합니다 (예: $x$, $y$ 및 $z$).우리는 모든 (연속) *실수 값* 스칼라의 공간을 $\mathbb{R}$으로 나타냅니다.편의를 위해 정확히*공간*이 무엇인지에 대한 엄격한 정의를 펀트 할 것입니다. 하지만 지금은 $x \in \mathbb{R}$이라는 표현식이 $x$이 실수 값 스칼라라고 말하는 공식적인 방법이라는 것을 기억하십시오.기호 $\in$는 “in”으로 발음 할 수 있으며 단순히 집합의 구성원을 나타냅니다.마찬가지로 $x, y \in \{0, 1\}$을 작성하여 $x$과 $y$가 값이 $0$ 또는 $1$일 수 있는 숫자임을 나타낼 수 있습니다.
 
 (**스칼라는 요소가 하나뿐인 텐서로 표시됩니다.**) 다음 스 니펫에서는 두 개의 스칼라를 인스턴스화하고 이들을 사용하여 친숙한 산술 연산, 즉 더하기, 곱셈, 나누기 및 지수를 수행합니다.
 
@@ -43,7 +43,7 @@ x + y, x * y, x / y, x**y
 
 ## 벡터
 
-[**벡터는 단순히 스칼라 값의 목록이라고 생각할 수 있습니다.**] 이 값을 벡터의*요소* (*항목* 또는*구성 요소*) 라고 합니다.벡터가 데이터셋의 예제를 나타낼 때, 벡터의 값에는 실제 의미가 있습니다.예를 들어, 대출 채무 불이행의 위험을 예측하기 위해 모델을 훈련하는 경우 각 신청자를 소득, 고용 기간, 이전 채무 불이행 수 및 기타 요인에 해당하는 구성 요소의 벡터와 연관시킬 수 있습니다.병원 환자가 직면 할 수있는 심장 마비의 위험을 연구하는 경우 구성 요소가 가장 최근의 활력 징후, 콜레스테롤 수치, 하루 운동 시간 등을 포착하는 벡터로 각 환자를 나타낼 수 있습니다. 수학 표기법에서는 일반적으로 벡터를 굵고 소문자로 표시합니다.편지 (예: $\mathbf{x}$, $\mathbf{y}$ 및 $\mathbf{z})$. 
+[**벡터는 단순히 스칼라 값의 목록이라고 생각할 수 있습니다.**] 이 값을 벡터의*요소* (*항목* 또는*구성 요소*) 라고 합니다.벡터가 데이터셋의 예제를 나타낼 때, 벡터의 값에는 실제 의미가 있습니다.예를 들어, 대출 채무 불이행의 위험을 예측하기 위해 모델을 훈련하는 경우 각 신청자를 소득, 고용 기간, 이전 채무 불이행 수 및 기타 요인에 해당하는 구성 요소의 벡터와 연관시킬 수 있습니다.병원 환자가 직면 할 수있는 심장 마비의 위험을 연구하는 경우 구성 요소가 가장 최근의 활력 징후, 콜레스테롤 수치, 하루 운동 시간 등을 포착하는 벡터로 각 환자를 나타낼 수 있습니다. 수학 표기법에서는 일반적으로 벡터를 굵고 소문자로 표시합니다.편지 (예: $\mathbf{x}$, $\mathbf{y}$ 및 $\mathbf{z})$.
 
 우리는 일차원 텐서를 통해 벡터로 작업합니다.일반적으로 텐서는 컴퓨터의 메모리 제한에 따라 임의의 길이를 가질 수 있습니다.
 
@@ -64,7 +64,7 @@ x = tf.range(4)
 x
 ```
 
-아래 첨자를 사용하여 벡터의 모든 요소를 참조 할 수 있습니다.예를 들어 $x_i$에서 $\mathbf{x}$의 $i^\mathrm{th}$ 요소를 참조할 수 있습니다.요소 $x_i$는 스칼라이므로 글꼴을 참조할 때 글꼴을 굵게 표시하지 않습니다.광범위한 문헌에서는 열 벡터를 벡터의 기본 방향으로 간주하므로 이 책도 마찬가지입니다.수학에서 벡터 $\mathbf{x}$는 다음과 같이 쓸 수 있습니다. 
+아래 첨자를 사용하여 벡터의 모든 요소를 참조 할 수 있습니다.예를 들어 $x_i$에서 $\mathbf{x}$의 $i^\mathrm{th}$ 요소를 참조할 수 있습니다.요소 $x_i$는 스칼라이므로 글꼴을 참조할 때 글꼴을 굵게 표시하지 않습니다.광범위한 문헌에서는 열 벡터를 벡터의 기본 방향으로 간주하므로 이 책도 마찬가지입니다.수학에서 벡터 $\mathbf{x}$는 다음과 같이 쓸 수 있습니다.
 
 $$\mathbf{x} =\begin{bmatrix}x_{1}  \\x_{2}  \\ \vdots  \\x_{n}\end{bmatrix},$$
 :eqlabel:`eq_vec_def`
@@ -87,7 +87,7 @@ x[3]
 
 ### 길이, 치수 및 모양
 
-:numref:`sec_ndarray`의 몇 가지 개념을 다시 살펴보겠습니다.벡터는 숫자의 배열일 뿐입니다.모든 배열에 길이가 있는 것처럼 모든 벡터도 마찬가지입니다.수학 표기법에서 벡터 $\mathbf{x}$이 $n$개의 실수 값 스칼라로 구성되어 있다고 말하고 싶다면 이를 $\mathbf{x} \in \mathbb{R}^n$로 표현할 수 있습니다.벡터의 길이는 일반적으로 벡터의*차원*이라고 합니다. 
+:numref:`sec_ndarray`의 몇 가지 개념을 다시 살펴보겠습니다.벡터는 숫자의 배열일 뿐입니다.모든 배열에 길이가 있는 것처럼 모든 벡터도 마찬가지입니다.수학 표기법에서 벡터 $\mathbf{x}$이 $n$개의 실수 값 스칼라로 구성되어 있다고 말하고 싶다면 이를 $\mathbf{x} \in \mathbb{R}^n$로 표현할 수 있습니다.벡터의 길이는 일반적으로 벡터의*차원*이라고 합니다.
 
 일반적인 파이썬 배열과 마찬가지로 파이썬의 내장 `len()` 함수를 호출하여 [**텐서의 길이에 액세스 할 수 있습니다**].
 
@@ -121,18 +121,18 @@ x.shape
 x.shape
 ```
 
-“차원”이라는 단어는 이러한 맥락에서 과부하가 걸리는 경향이 있으며 이는 사람들을 혼란스럽게하는 경향이 있습니다.명확히하기 위해*벡터* 또는*축*의 차원 성을 사용하여 길이, 즉 벡터 또는 축의 요소 수를 나타냅니다.그러나 텐서의 차원 성을 사용하여 텐서가 가진 축의 수를 나타냅니다.이런 의미에서 텐서의 일부 축의 차원은 해당 축의 길이가됩니다. 
+“차원”이라는 단어는 이러한 맥락에서 과부하가 걸리는 경향이 있으며 이는 사람들을 혼란스럽게하는 경향이 있습니다.명확히하기 위해*벡터* 또는*축*의 차원 성을 사용하여 길이, 즉 벡터 또는 축의 요소 수를 나타냅니다.그러나 텐서의 차원 성을 사용하여 텐서가 가진 축의 수를 나타냅니다.이런 의미에서 텐서의 일부 축의 차원은 해당 축의 길이가됩니다.
 
 ## 행렬
 
-벡터가 0차수에서 1차까지 스칼라를 일반화하는 것처럼 행렬은 벡터를 1차부터 차수 2차까지 일반화합니다.일반적으로 굵은 대문자로 표시되는 행렬 (예: $\mathbf{X}$, $\mathbf{Y}$ 및 $\mathbf{Z}$) 은 코드에서 두 개의 축을 가진 텐서로 표시됩니다. 
+벡터가 0차수에서 1차까지 스칼라를 일반화하는 것처럼 행렬은 벡터를 1차부터 차수 2차까지 일반화합니다.일반적으로 굵은 대문자로 표시되는 행렬 (예: $\mathbf{X}$, $\mathbf{Y}$ 및 $\mathbf{Z}$) 은 코드에서 두 개의 축을 가진 텐서로 표시됩니다.
 
-수학 표기법에서는 $\mathbf{A} \in \mathbb{R}^{m \times n}$을 사용하여 행렬 $\mathbf{A}$이 $m$개의 행과 $n$의 실수 값 스칼라 열로 구성되어 있음을 표현합니다.시각적으로 모든 행렬 $\mathbf{A} \in \mathbb{R}^{m \times n}$을 테이블로 설명할 수 있습니다. 여기서 각 요소 $a_{ij}$는 $i^{\mathrm{th}}$ 행과 $j^{\mathrm{th}}$ 열에 속합니다. 
+수학 표기법에서는 $\mathbf{A} \in \mathbb{R}^{m \times n}$을 사용하여 행렬 $\mathbf{A}$이 $m$개의 행과 $n$의 실수 값 스칼라 열로 구성되어 있음을 표현합니다.시각적으로 모든 행렬 $\mathbf{A} \in \mathbb{R}^{m \times n}$을 테이블로 설명할 수 있습니다. 여기서 각 요소 $a_{ij}$는 $i^{\mathrm{th}}$ 행과 $j^{\mathrm{th}}$ 열에 속합니다.
 
 $$\mathbf{A}=\begin{bmatrix} a_{11} & a_{12} & \cdots & a_{1n} \\ a_{21} & a_{22} & \cdots & a_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m1} & a_{m2} & \cdots & a_{mn} \\ \end{bmatrix}.$$
 :eqlabel:`eq_matrix_def`
 
-모든 $\mathbf{A} \in \mathbb{R}^{m \times n}$의 경우, $\mathbf{A}$의 모양은 ($m$, $n$) 또는 $m \times n$입니다.특히 행렬의 행과 열 수가 같으면 모양이 정사각형이 되므로*정사각형 행렬*이라고 합니다. 
+모든 $\mathbf{A} \in \mathbb{R}^{m \times n}$의 경우, $\mathbf{A}$의 모양은 ($m$, $n$) 또는 $m \times n$입니다.특히 행렬의 행과 열 수가 같으면 모양이 정사각형이 되므로*정사각형 행렬*이라고 합니다.
 
 텐서를 인스턴스화하기 위해 가장 좋아하는 함수를 호출 할 때 두 개의 구성 요소 $m$ 및 $n$로 모양을 지정하여 [**$m \times n$ 행렬**] 을 만들 수 있습니다.
 
@@ -153,9 +153,9 @@ A = tf.reshape(tf.range(20), (5, 4))
 A
 ```
 
-$[\mathbf{A}]_{ij}$과 같은 행 ($i$) 과 열 ($j$) 에 대한 인덱스를 지정하여 :eqref:`eq_matrix_def`에서 행렬 $\mathbf{A}$의 스칼라 요소 $a_{ij}$에 액세스할 수 있습니다.:eqref:`eq_matrix_def`와 같이 행렬 $\mathbf{A}$의 스칼라 요소가 제공되지 않으면 행렬 $\mathbf{A}$의 소문자를 색인 첨자 $a_{ij}$과 함께 사용하여 $[\mathbf{A}]_{ij}$을 참조할 수 있습니다.표기법을 단순하게 유지하기 위해 $a_{2, 3j}$ 및 $[\mathbf{A}]_{2i-1, 3}$와 같이 필요한 경우에만 쉼표를 별도의 인덱스에 삽입합니다. 
+$[\mathbf{A}]_{ij}$과 같은 행 ($i$) 과 열 ($j$) 에 대한 인덱스를 지정하여 :eqref:`eq_matrix_def`에서 행렬 $\mathbf{A}$의 스칼라 요소 $a_{ij}$에 액세스할 수 있습니다.:eqref:`eq_matrix_def`와 같이 행렬 $\mathbf{A}$의 스칼라 요소가 제공되지 않으면 행렬 $\mathbf{A}$의 소문자를 색인 첨자 $a_{ij}$과 함께 사용하여 $[\mathbf{A}]_{ij}$을 참조할 수 있습니다.표기법을 단순하게 유지하기 위해 $a_{2, 3j}$ 및 $[\mathbf{A}]_{2i-1, 3}$와 같이 필요한 경우에만 쉼표를 별도의 인덱스에 삽입합니다.
 
-때로는 축을 뒤집고 싶을 때가 있습니다.행렬의 행과 열을 교환할 때 결과를 행렬의*transpose*라고 합니다.공식적으로, 우리는 행렬 $\mathbf{A}$의 전치를 $\mathbf{A}^\top$로 나타내고, $\mathbf{B} = \mathbf{A}^\top$인 경우 $i$ 및 $j$에 대해 $b_{ij} = a_{ji}$을 나타냅니다.따라서 :eqref:`eq_matrix_def`에서 $\mathbf{A}$의 전치는 $n \times m$ 행렬입니다. 
+때로는 축을 뒤집고 싶을 때가 있습니다.행렬의 행과 열을 교환할 때 결과를 행렬의*transpose*라고 합니다.공식적으로, 우리는 행렬 $\mathbf{A}$의 전치를 $\mathbf{A}^\top$로 나타내고, $\mathbf{B} = \mathbf{A}^\top$인 경우 $i$ 및 $j$에 대해 $b_{ij} = a_{ji}$을 나타냅니다.따라서 :eqref:`eq_matrix_def`에서 $\mathbf{A}$의 전치는 $n \times m$ 행렬입니다.
 
 $$
 \mathbf{A}^\top =
@@ -218,11 +218,11 @@ B == B.T
 B == tf.transpose(B)
 ```
 
-행렬은 유용한 데이터 구조입니다. 행렬을 사용하면 변동 양식이 다른 데이터를 구성 할 수 있습니다.예를 들어 행렬의 행은 다른 집 (데이터 예) 에 해당할 수 있지만 열은 다른 속성에 해당할 수 있습니다.스프레드시트 소프트웨어를 사용해 본 적이 있거나 :numref:`sec_pandas`를 읽은 적이 있다면 친숙하게 들릴 것입니다.따라서 단일 벡터의 기본 방향이 열 벡터이지만 테이블 형식 데이터 세트를 나타내는 행렬에서는 각 데이터 예제를 행렬의 행 벡터로 처리하는 것이 더 일반적입니다.그리고 이후 장에서 살펴보겠지만, 이 컨벤션은 일반적인 딥 러닝 관행을 가능하게 할 것입니다.예를 들어 텐서의 가장 바깥 쪽 축을 따라 데이터 예제의 미니 일괄 처리에 액세스하거나 열거 할 수 있으며 미니 배치가없는 경우 데이터 예제에만 액세스 할 수 있습니다. 
+행렬은 유용한 데이터 구조입니다. 행렬을 사용하면 변동 양식이 다른 데이터를 구성 할 수 있습니다.예를 들어 행렬의 행은 다른 집 (데이터 예) 에 해당할 수 있지만 열은 다른 속성에 해당할 수 있습니다.스프레드시트 소프트웨어를 사용해 본 적이 있거나 :numref:`sec_pandas`를 읽은 적이 있다면 친숙하게 들릴 것입니다.따라서 단일 벡터의 기본 방향이 열 벡터이지만 테이블 형식 데이터 세트를 나타내는 행렬에서는 각 데이터 예제를 행렬의 행 벡터로 처리하는 것이 더 일반적입니다.그리고 이후 장에서 살펴보겠지만, 이 컨벤션은 일반적인 딥 러닝 관행을 가능하게 할 것입니다.예를 들어 텐서의 가장 바깥 쪽 축을 따라 데이터 예제의 미니 일괄 처리에 액세스하거나 열거 할 수 있으며 미니 배치가없는 경우 데이터 예제에만 액세스 할 수 있습니다.
 
 ## 텐서
 
-벡터가 스칼라를 일반화하고 행렬이 벡터를 일반화하는 것처럼 훨씬 더 많은 축을 가진 데이터 구조를 만들 수 있습니다.[**텐서**](이 하위 섹션의 “텐서”는 대수 객체를 나타냅니다) (**임의의 수의 축을 가진 $n$ 차원 배열을 설명하는 일반적인 방법을 제공합니다.**) 예를 들어 벡터는 1 차 텐서이고 행렬은 2 차 텐서입니다.텐서는 특수 글꼴 (예: $\mathsf{X}$, $\mathsf{Y}$ 및 $\mathsf{Z}$) 의 대문자로 표시되며 인덱싱 메커니즘 (예: $x_{ijk}$ 및 $[\mathsf{X}]_{1, 2i-1, 3}$) 은 행렬과 유사합니다. 
+벡터가 스칼라를 일반화하고 행렬이 벡터를 일반화하는 것처럼 훨씬 더 많은 축을 가진 데이터 구조를 만들 수 있습니다.[**텐서**](이 하위 섹션의 “텐서”는 대수 객체를 나타냅니다) (**임의의 수의 축을 가진 $n$ 차원 배열을 설명하는 일반적인 방법을 제공합니다.**) 예를 들어 벡터는 1 차 텐서이고 행렬은 2 차 텐서입니다.텐서는 특수 글꼴 (예: $\mathsf{X}$, $\mathsf{Y}$ 및 $\mathsf{Z}$) 의 대문자로 표시되며 인덱싱 메커니즘 (예: $x_{ijk}$ 및 $[\mathsf{X}]_{1, 2i-1, 3}$) 은 행렬과 유사합니다.
 
 텐서는 이미지 작업을 시작할 때 더욱 중요해질 것입니다. 이 배열은 높이, 너비에 해당하는 3 개의 축과 색상 채널 (빨간색, 녹색 및 파란색) 을 쌓기위한* 채널* 축이있는 $n$ 차원 배열로 도착합니다.지금은 고차 텐서를 건너 뛰고 기본에 중점을 둘 것입니다.
 
@@ -267,7 +267,7 @@ B = A  # No cloning of `A` to `B` by allocating new memory
 A, A + B
 ```
 
-구체적으로, [**두 행렬의 요소별 곱셈을 *하다마르 곱***](수학 표기법 $\odot$) 라고 합니다.행 $i$과 열 $j$의 요소가 $b_{ij}$인 행렬 $\mathbf{B} \in \mathbb{R}^{m \times n}$를 가정해 보겠습니다.행렬 $\mathbf{A}$ (:eqref:`eq_matrix_def`에 정의됨) 및 $\mathbf{B}$의 하다마르드 곱입니다. 
+구체적으로, [**두 행렬의 요소별 곱셈을 *하다마르 곱***](수학 표기법 $\odot$) 라고 합니다.행 $i$과 열 $j$의 요소가 $b_{ij}$인 행렬 $\mathbf{B} \in \mathbb{R}^{m \times n}$를 가정해 보겠습니다.행렬 $\mathbf{A}$ (:eqref:`eq_matrix_def`에 정의됨) 및 $\mathbf{B}$의 하다마르드 곱입니다.
 
 $$
 \mathbf{A} \odot \mathbf{B} =
@@ -337,7 +337,7 @@ x = tf.range(4, dtype=tf.float32)
 x, tf.reduce_sum(x)
 ```
 
-[**임의의 모양의 텐서 요소에 대한 합계**] 를 표현할 수 있습니다.**] 예를 들어, $m \times n$ 행렬 $\mathbf{A}$의 요소 합은 $\sum_{i=1}^{m} \sum_{j=1}^{n} a_{ij}$로 작성할 수 있습니다.
+[**임의의 모양의 텐서 요소에 대한 합계**] 를 표현할 수 있습니다. 예를 들어, $m \times n$ 행렬 $\mathbf{A}$의 요소 합은 $\sum_{i=1}^{m} \sum_{j=1}^{n} a_{ij}$로 작성할 수 있습니다.
 
 ```{.python .input}
 A.shape, A.sum()
@@ -463,7 +463,7 @@ sum_A = tf.reduce_sum(A, axis=1, keepdims=True)
 sum_A
 ```
 
-예를 들어, `sum_A`는 각 행을 합산한 후에도 여전히 두 축을 유지하기 때문에 브로드캐스트를 사용하여 `A`를 `sum_A`로 나눌 수 있습니다.**)
+예를 들어, `sum_A`는 각 행을 합산한 후에도 여전히 두 축을 유지하기 때문에 브로드캐스트를 사용하여 `A`를 `sum_A`로 나눌 수 있습니다.
 
 ```{.python .input}
 A / sum_A
@@ -497,7 +497,7 @@ tf.cumsum(A, axis=0)
 
 ## 도트 제품
 
-지금까지 요소별 연산, 합계 및 평균만 수행했습니다.그리고 이것이 우리가 할 수 있는 전부라면, 선형 대수학은 아마도 자체 섹션을 가질 자격이 없을 것입니다.그러나 가장 기본적인 연산 중 하나는 내적입니다.두 개의 벡터 $\mathbf{x}, \mathbf{y} \in \mathbb{R}^d$가 주어지면 내적* $\mathbf{x}^\top \mathbf{y}$ (또는 $\langle \mathbf{x}, \mathbf{y}  \rangle$) 은 동일한 위치 $\mathbf{x}^\top \mathbf{y} = \sum_{i=1}^{d} x_i y_i$에 있는 요소의 곱에 대한 합계입니다. 
+지금까지 요소별 연산, 합계 및 평균만 수행했습니다.그리고 이것이 우리가 할 수 있는 전부라면, 선형 대수학은 아마도 자체 섹션을 가질 자격이 없을 것입니다.그러나 가장 기본적인 연산 중 하나는 내적입니다.두 개의 벡터 $\mathbf{x}, \mathbf{y} \in \mathbb{R}^d$가 주어지면 내적* $\mathbf{x}^\top \mathbf{y}$ (또는 $\langle \mathbf{x}, \mathbf{y}  \rangle$) 은 동일한 위치 $\mathbf{x}^\top \mathbf{y} = \sum_{i=1}^{d} x_i y_i$에 있는 요소의 곱에 대한 합계입니다.
 
 [~~두 벡터의 내적*내적*은 같은 위치에 있는 요소의 곱에 대한 합입니다 ~~]
 
@@ -518,7 +518,7 @@ y = tf.ones(4, dtype=tf.float32)
 x, y, tf.tensordot(x, y, axes=1)
 ```
 
-(**요소별 곱셈을 수행한 다음 sum: **을 수행하여 두 벡터의 내적을 동등하게 표현할 수 있습니다.)
+(**요소별 곱셈을 수행한 다음 sum: 을 수행하여 두 벡터의 내적을 동등하게 표현할 수 있습니다.**)
 
 ```{.python .input}
 np.sum(x * y)
@@ -534,11 +534,11 @@ torch.sum(x * y)
 tf.reduce_sum(x * y)
 ```
 
-내적은 다양한 상황에서 유용합니다.예를 들어, 벡터 $\mathbf{x}  \in \mathbb{R}^d$로 표시된 일부 값 세트와 $\mathbf{w} \in \mathbb{R}^d$로 표시된 가중치 집합이 주어지면 가중치 $\mathbf{w}$에 따른 $\mathbf{x}$에 있는 값의 가중 합은 내적 $\mathbf{x}^\top \mathbf{w}$로 표현될 수 있습니다.가중치가 음수가 아니고 합이 1 (즉, $\left(\sum_{i=1}^{d} {w_i} = 1\right)$) 인 경우 내적은*가중 평균*을 나타냅니다.단위 길이를 갖도록 두 벡터를 정규화한 후 내적은 두 벡터 사이의 각도의 코사인을 표현합니다.이 섹션 후반부에서*길이*라는 개념을 공식적으로 소개하겠습니다. 
+내적은 다양한 상황에서 유용합니다.예를 들어, 벡터 $\mathbf{x}  \in \mathbb{R}^d$로 표시된 일부 값 세트와 $\mathbf{w} \in \mathbb{R}^d$로 표시된 가중치 집합이 주어지면 가중치 $\mathbf{w}$에 따른 $\mathbf{x}$에 있는 값의 가중 합은 내적 $\mathbf{x}^\top \mathbf{w}$로 표현될 수 있습니다.가중치가 음수가 아니고 합이 1 (즉, $\left(\sum_{i=1}^{d} {w_i} = 1\right)$) 인 경우 내적은*가중 평균*을 나타냅니다.단위 길이를 갖도록 두 벡터를 정규화한 후 내적은 두 벡터 사이의 각도의 코사인을 표현합니다.이 섹션 후반부에서*길이*라는 개념을 공식적으로 소개하겠습니다.
 
 ## 매트릭스-벡터 제품
 
-내적을 계산하는 방법을 알았으므로*행렬-벡터 곱*을 이해할 수 있습니다.각각 :eqref:`eq_matrix_def` 및 :eqref:`eq_vec_def`에서 정의되고 시각화된 행렬 $\mathbf{A} \in \mathbb{R}^{m \times n}$과 벡터 $\mathbf{x} \in \mathbb{R}^n$을 회상합니다.먼저 행렬 $\mathbf{A}$을 행 벡터로 시각화해 보겠습니다. 
+내적을 계산하는 방법을 알았으므로*행렬-벡터 곱*을 이해할 수 있습니다.각각 :eqref:`eq_matrix_def` 및 :eqref:`eq_vec_def`에서 정의되고 시각화된 행렬 $\mathbf{A} \in \mathbb{R}^{m \times n}$과 벡터 $\mathbf{x} \in \mathbb{R}^n$을 회상합니다.먼저 행렬 $\mathbf{A}$을 행 벡터로 시각화해 보겠습니다.
 
 $$\mathbf{A}=
 \begin{bmatrix}
@@ -548,9 +548,9 @@ $$\mathbf{A}=
 \mathbf{a}^\top_m \\
 \end{bmatrix},$$
 
-여기서 각 $\mathbf{a}^\top_{i} \in \mathbb{R}^n$는 행렬 $\mathbf{A}$의 $i^\mathrm{th}$ 행을 나타내는 행 벡터입니다. 
+여기서 각 $\mathbf{a}^\top_{i} \in \mathbb{R}^n$는 행렬 $\mathbf{A}$의 $i^\mathrm{th}$ 행을 나타내는 행 벡터입니다.
 
-[**행렬-벡터 곱 $\mathbf{A}\mathbf{x}$은 단순히 길이가 $m$인 열 벡터이며, 이 벡터의 $i^\mathrm{th}$ 요소는 내적 $\mathbf{a}^\top_i \mathbf{x}$입니다.**] 
+[**행렬-벡터 곱 $\mathbf{A}\mathbf{x}$은 단순히 길이가 $m$인 열 벡터이며, 이 벡터의 $i^\mathrm{th}$ 요소는 내적 $\mathbf{a}^\top_i \mathbf{x}$입니다.**]
 
 $$
 \mathbf{A}\mathbf{x}
@@ -598,9 +598,9 @@ A.shape, x.shape, tf.linalg.matvec(A, x)
 
 ## 매트릭스-매트릭스 곱셈
 
-내적과 행렬-벡터 곱이 익숙하다면*행렬-행렬 곱셈*은 간단해야 합니다. 
+내적과 행렬-벡터 곱이 익숙하다면*행렬-행렬 곱셈*은 간단해야 합니다.
 
-$\mathbf{A} \in \mathbb{R}^{n \times k}$와 $\mathbf{B} \in \mathbb{R}^{k \times m}$라는 두 개의 행렬이 있다고 가정해 보겠습니다. 
+$\mathbf{A} \in \mathbb{R}^{n \times k}$와 $\mathbf{B} \in \mathbb{R}^{k \times m}$라는 두 개의 행렬이 있다고 가정해 보겠습니다.
 
 $$\mathbf{A}=\begin{bmatrix}
  a_{11} & a_{12} & \cdots & a_{1k} \\
@@ -615,7 +615,7 @@ $$\mathbf{A}=\begin{bmatrix}
  b_{k1} & b_{k2} & \cdots & b_{km} \\
 \end{bmatrix}.$$
 
-행렬 $\mathbf{A}$의 $i^\mathrm{th}$ 행을 나타내는 행 벡터를 $\mathbf{a}^\top_{i} \in \mathbb{R}^k$로 나타내고, $\mathbf{b}_{j} \in \mathbb{R}^k$를 행렬 $\mathbf{B}$의 $j^\mathrm{th}$ 열에 있는 열 벡터로 지정합니다.행렬 곱 $\mathbf{C} = \mathbf{A}\mathbf{B}$를 생성하려면 행 벡터로 $\mathbf{A}$을 생각하고 열 벡터로 $\mathbf{B}$을 생각하는 것이 가장 쉽습니다. 
+행렬 $\mathbf{A}$의 $i^\mathrm{th}$ 행을 나타내는 행 벡터를 $\mathbf{a}^\top_{i} \in \mathbb{R}^k$로 나타내고, $\mathbf{b}_{j} \in \mathbb{R}^k$를 행렬 $\mathbf{B}$의 $j^\mathrm{th}$ 열에 있는 열 벡터로 지정합니다.행렬 곱 $\mathbf{C} = \mathbf{A}\mathbf{B}$를 생성하려면 행 벡터로 $\mathbf{A}$을 생각하고 열 벡터로 $\mathbf{B}$을 생각하는 것이 가장 쉽습니다.
 
 $$\mathbf{A}=
 \begin{bmatrix}
@@ -629,7 +629,7 @@ $$\mathbf{A}=
 \end{bmatrix}.
 $$
 
-그런 다음 각 요소 $c_{ij}$을 내적 $\mathbf{a}^\top_i \mathbf{b}_j$로 계산하여 행렬 곱 $\mathbf{C} \in \mathbb{R}^{n \times m}$가 생성됩니다. 
+그런 다음 각 요소 $c_{ij}$을 내적 $\mathbf{a}^\top_i \mathbf{b}_j$로 계산하여 행렬 곱 $\mathbf{C} \in \mathbb{R}^{n \times m}$가 생성됩니다.
 
 $$\mathbf{C} = \mathbf{AB} = \begin{bmatrix}
 \mathbf{a}^\top_{1} \\
@@ -667,34 +667,34 @@ B = tf.ones((4, 3), tf.float32)
 tf.matmul(A, B)
 ```
 
-행렬-행렬 곱셈은 단순히*행렬 곱셈*이라고 할 수 있으며, Hadamard 곱과 혼동해서는 안 됩니다. 
+행렬-행렬 곱셈은 단순히*행렬 곱셈*이라고 할 수 있으며, Hadamard 곱과 혼동해서는 안 됩니다.
 
 ## 규범
 :label:`subsec_lin-algebra-norms`
 
-선형 대수에서 가장 유용한 연산자는*norms*입니다.비공식적으로 벡터의 노름은 벡터가*큰*정도를 알려줍니다.여기서 고려중인*크기*의 개념은 차원성이 아니라 구성 요소의 크기와 관련이 있습니다. 
+선형 대수에서 가장 유용한 연산자는*norms*입니다.비공식적으로 벡터의 노름은 벡터가*큰*정도를 알려줍니다.여기서 고려중인*크기*의 개념은 차원성이 아니라 구성 요소의 크기와 관련이 있습니다.
 
-선형 대수에서 벡터 노름은 벡터를 스칼라에 매핑하여 소수의 속성을 충족하는 함수 $f$입니다.벡터 $\mathbf{x}$이 주어지면 첫 번째 속성은 벡터의 모든 요소를 상수 인수 $\alpha$로 스케일링하면 해당 노름도 동일한 상수 인자의*절대 값*에 따라 스케일링된다고 말합니다. 
+선형 대수에서 벡터 노름은 벡터를 스칼라에 매핑하여 소수의 속성을 충족하는 함수 $f$입니다.벡터 $\mathbf{x}$이 주어지면 첫 번째 속성은 벡터의 모든 요소를 상수 인수 $\alpha$로 스케일링하면 해당 노름도 동일한 상수 인자의*절대 값*에 따라 스케일링된다고 말합니다.
 
 $$f(\alpha \mathbf{x}) = |\alpha| f(\mathbf{x}).$$
 
-두 번째 속성은 익숙한 삼각형 부등식입니다. 
+두 번째 속성은 익숙한 삼각형 부등식입니다.
 
 $$f(\mathbf{x} + \mathbf{y}) \leq f(\mathbf{x}) + f(\mathbf{y}).$$
 
-세 번째 속성은 단순히 규범이 음수가 아니어야한다고 말합니다. 
+세 번째 속성은 단순히 규범이 음수가 아니어야한다고 말합니다.
 
 $$f(\mathbf{x}) \geq 0.$$
 
-대부분의 컨텍스트에서 가장 작은*크기*는 0이기 때문에 의미가 있습니다.최종 속성에서는 가장 작은 노름이 달성되고 모든 0으로 구성된 벡터에 의해서만 달성되어야 합니다. 
+대부분의 컨텍스트에서 가장 작은*크기*는 0이기 때문에 의미가 있습니다.최종 속성에서는 가장 작은 노름이 달성되고 모든 0으로 구성된 벡터에 의해서만 달성되어야 합니다.
 
 $$\forall i, [\mathbf{x}]_i = 0 \Leftrightarrow f(\mathbf{x})=0.$$
 
-규범은 거리 측정과 매우 흡사하다는 것을 알 수 있습니다.그리고 초등학교에서 유클리드 거리 (피타고라스의 정리를 생각해보십시오) 를 기억한다면, 비 부정성과 삼각형 불평등의 개념이 종을 울릴 수 있습니다.실제로 유클리드 거리는 표준입니다. 특히 $L_2$ 표준입니다.$n$차원 벡터 $\mathbf{x}$의 요소가 $x_1, \ldots, x_n$라고 가정합니다. 
+규범은 거리 측정과 매우 흡사하다는 것을 알 수 있습니다.그리고 초등학교에서 유클리드 거리 (피타고라스의 정리를 생각해보십시오) 를 기억한다면, 비 부정성과 삼각형 불평등의 개념이 종을 울릴 수 있습니다.실제로 유클리드 거리는 표준입니다. 특히 $L_2$ 표준입니다.$n$차원 벡터 $\mathbf{x}$의 요소가 $x_1, \ldots, x_n$라고 가정합니다.
 
-[**$\mathbf{x}$의 $L_2$*표준*은 벡터 요소의 제곱합의 제곱근입니다. **] 
+[**$\mathbf{x}$의 $L_2$*표준*은 벡터 요소의 제곱합의 제곱근입니다. **]
 
-(**$\|\mathbf{x}\|_2 = \sqrt{\sum_{i=1}^n x_i^2},$달러**) 
+(**$\|\mathbf{x}\|_2 = \sqrt{\sum_{i=1}^n x_i^2},$달러**)
 
 여기서 첨자 $2$는 종종 $L_2$ 규범에서 생략됩니다. 즉, $\|\mathbf{x}\|$는 $\|\mathbf{x}\|_2$과 동일합니다.코드에서 다음과 같이 벡터의 $L_2$ 노름을 계산할 수 있습니다.
 
@@ -715,11 +715,11 @@ u = tf.constant([3.0, -4.0])
 tf.norm(u)
 ```
 
-딥 러닝에서는 $L_2$ 제곱 노름으로 더 자주 작업합니다. 
+딥 러닝에서는 $L_2$ 제곱 노름으로 더 자주 작업합니다.
 
-또한 벡터 요소의 절대값의 합으로 표현되는 [**$L_1$*norm***] 을 자주 접하게 됩니다. 
+또한 벡터 요소의 절대값의 합으로 표현되는 [**$L_1$*norm***] 을 자주 접하게 됩니다.
 
-(**$\|\mathbf{x}\|_1 = \sum_{i=1}^n \left|x_i \right|.$달러**) 
+(**$\|\mathbf{x}\|_1 = \sum_{i=1}^n \left|x_i \right|.$달러**)
 
 $L_2$ 노름과 비교할 때 이상값의 영향을 덜 받습니다.$L_1$ 노름을 계산하기 위해 요소에 대한 합계를 사용하여 절대값 함수를 구성합니다.
 
@@ -737,13 +737,13 @@ torch.abs(u).sum()
 tf.reduce_sum(tf.abs(u))
 ```
 
-$L_2$ 규범과 $L_1$ 규범은 모두 보다 일반적인 $L_p$*표준*의 특수한 경우입니다. 
+$L_2$ 규범과 $L_1$ 규범은 모두 보다 일반적인 $L_p$*표준*의 특수한 경우입니다.
 
 $$\|\mathbf{x}\|_p = \left(\sum_{i=1}^n \left|x_i \right|^p \right)^{1/p}.$$
 
-벡터의 $L_2$ 노름과 유사하게, [**행렬 $\mathbf{X} \in \mathbb{R}^{m \times n}$** 의*프로베니우스 노름*] 은 행렬 요소의 제곱합의 제곱근입니다. 
+벡터의 $L_2$ 노름과 유사하게, [**행렬 $\mathbf{X} \in \mathbb{R}^{m \times n}$**] 의*프로베니우스 노름* 은 행렬 요소의 제곱합의 제곱근입니다.
 
-[**$\|\mathbf{X}\|_F = \sqrt{\sum_{i=1}^m \sum_{j=1}^n x_{ij}^2}.$$**] 
+[**$\|\mathbf{X}\|_F = \sqrt{\sum_{i=1}^m \sum_{j=1}^n x_{ij}^2}.$$**]
 
 프로베니우스 노름은 벡터 노름의 모든 속성을 충족합니다.행렬형 벡터의 $L_2$ 노름인 것처럼 동작합니다.다음 함수를 호출하면 행렬의 프로베니우스 노름이 계산됩니다.
 
@@ -767,13 +767,13 @@ tf.norm(tf.ones((4, 9)))
 우리 자신보다 너무 앞서 가고 싶지는 않지만, 이러한 개념이 왜 유용한지에 대해 이미 직관을 세울 수 있습니다.딥 러닝에서는 종종 최적화 문제를 해결하려고 합니다.
 *관측 데이터에 할당 된 확률을 최대화*;
 *예측값 사이의 거리를 최소화*
-그리고 지상 진실 관찰이 있습니다.유사한 항목 간의 거리가 최소화되고 서로 다른 항목 간의 거리가 최대화되도록 항목 (예: 단어, 제품 또는 뉴스 기사) 에 벡터 표현을 할당합니다.딥 러닝 알고리즘의 가장 중요한 구성 요소 (데이터 제외) 인 목표는 종종 규범으로 표현됩니다. 
+그리고 지상 진실 관찰이 있습니다.유사한 항목 간의 거리가 최소화되고 서로 다른 항목 간의 거리가 최대화되도록 항목 (예: 단어, 제품 또는 뉴스 기사) 에 벡터 표현을 할당합니다.딥 러닝 알고리즘의 가장 중요한 구성 요소 (데이터 제외) 인 목표는 종종 규범으로 표현됩니다.
 
 ## 선형 대수에 대해 자세히 알아보기
 
-이 섹션에서는 놀라운 현대 딥 러닝을 이해하는 데 필요한 모든 선형 대수를 가르쳤습니다.선형 대수학에는 훨씬 더 많은 것이 있으며 많은 수학이 기계 학습에 유용합니다.예를 들어 행렬은 인자로 분해될 수 있으며 이러한 분해는 실제 데이터셋에서 저차원 구조를 나타낼 수 있습니다.기계 학습에는 행렬 분해와 그 일반화를 고차 텐서에 사용하여 데이터 세트의 구조를 발견하고 예측 문제를 해결하는 데 중점을 둔 전체 하위 필드가 있습니다.하지만 이 책은 딥 러닝에 초점을 맞추고 있습니다.또한 실제 데이터 세트에 유용한 기계 학습 모델을 배포하면 더 많은 수학을 배우려는 경향이 훨씬 더 커질 것입니다.따라서 나중에 더 많은 수학을 소개 할 권리가 있지만, 이 섹션을 여기서 마무리하겠습니다. 
+이 섹션에서는 놀라운 현대 딥 러닝을 이해하는 데 필요한 모든 선형 대수를 가르쳤습니다.선형 대수학에는 훨씬 더 많은 것이 있으며 많은 수학이 기계 학습에 유용합니다.예를 들어 행렬은 인자로 분해될 수 있으며 이러한 분해는 실제 데이터셋에서 저차원 구조를 나타낼 수 있습니다.기계 학습에는 행렬 분해와 그 일반화를 고차 텐서에 사용하여 데이터 세트의 구조를 발견하고 예측 문제를 해결하는 데 중점을 둔 전체 하위 필드가 있습니다.하지만 이 책은 딥 러닝에 초점을 맞추고 있습니다.또한 실제 데이터 세트에 유용한 기계 학습 모델을 배포하면 더 많은 수학을 배우려는 경향이 훨씬 더 커질 것입니다.따라서 나중에 더 많은 수학을 소개 할 권리가 있지만, 이 섹션을 여기서 마무리하겠습니다.
 
-선형 대수에 대해 더 자세히 알고 싶다면 [online appendix on linear algebraic operations](https://d2l.ai/chapter_appendix-mathematics-for-deep-learning/geometry-linear-algebraic-ops.html) 또는 기타 우수한 리소스 :cite:`Strang.1993,Kolter.2008,Petersen.Pedersen.ea.2008`를 참조 할 수 있습니다. 
+선형 대수에 대해 더 자세히 알고 싶다면 [online appendix on linear algebraic operations](https://d2l.ai/chapter_appendix-mathematics-for-deep-learning/geometry-linear-algebraic-ops.html) 또는 기타 우수한 리소스 :cite:`Strang.1993,Kolter.2008,Petersen.Pedersen.ea.2008`를 참조 할 수 있습니다.
 
 ## 요약
 
diff --git a/chapter_recurrent-neural-networks/language-models-and-dataset.md b/chapter_recurrent-neural-networks/language-models-and-dataset.md
index 23c67768..a1b41d39 100644
--- a/chapter_recurrent-neural-networks/language-models-and-dataset.md
+++ b/chapter_recurrent-neural-networks/language-models-and-dataset.md
@@ -1,33 +1,33 @@
 # 언어 모델 및 데이터세트
 :label:`sec_language_model`
 
-:numref:`sec_text_preprocessing`에서는 텍스트 데이터를 토큰에 매핑하는 방법을 살펴봅니다. 토큰은 단어나 문자와 같은 일련의 개별 관측값으로 볼 수 있습니다.길이가 $T$인 텍스트 시퀀스의 토큰이 차례로 $x_1, x_2, \ldots, x_T$라고 가정합니다.그런 다음 텍스트 시퀀스에서 $x_t$ ($1 \leq t \leq T$) 을 시간 단계 $t$에서 관측치 또는 레이블로 간주할 수 있습니다.이러한 텍스트 시퀀스가 주어지면*언어 모델*의 목표는 시퀀스의 공동 확률을 추정하는 것입니다. 
+:numref:`sec_text_preprocessing`에서는 텍스트 데이터를 토큰에 매핑하는 방법을 살펴봅니다. 토큰은 단어나 문자와 같은 일련의 개별 관측값으로 볼 수 있습니다.길이가 $T$인 텍스트 시퀀스의 토큰이 차례로 $x_1, x_2, \ldots, x_T$라고 가정합니다.그런 다음 텍스트 시퀀스에서 $x_t$ ($1 \leq t \leq T$) 을 시간 단계 $t$에서 관측치 또는 레이블로 간주할 수 있습니다.이러한 텍스트 시퀀스가 주어지면*언어 모델*의 목표는 시퀀스의 공동 확률을 추정하는 것입니다.
 
 $$P(x_1, x_2, \ldots, x_T).$$
 
-언어 모델은 매우 유용합니다.예를 들어, 이상적인 언어 모델은 한 번에 하나의 토큰을 그리는 것만으로도 자연 텍스트를 자체적으로 생성 할 수 있습니다. $x_t \sim P(x_t \mid x_{t-1}, \ldots, x_1)$.타자기를 사용하는 원숭이와 달리 이러한 모델에서 나오는 모든 텍스트는 자연어 (예: 영어 텍스트) 로 전달됩니다.또한 이전 대화 상자 조각의 텍스트를 조절하는 것만으로도 의미 있는 대화 상자를 생성하는 데 충분할 것입니다.문법적으로 합리적인 콘텐츠를 생성하는 것이 아니라 텍스트를 이해해야하기 때문에 우리는 여전히 그러한 시스템을 설계하는 것과는 거리가 멀다. 
+언어 모델은 매우 유용합니다.예를 들어, 이상적인 언어 모델은 한 번에 하나의 토큰을 그리는 것만으로도 자연 텍스트를 자체적으로 생성 할 수 있습니다. $x_t \sim P(x_t \mid x_{t-1}, \ldots, x_1)$.타자기를 사용하는 원숭이와 달리 이러한 모델에서 나오는 모든 텍스트는 자연어 (예: 영어 텍스트) 로 전달됩니다.또한 이전 대화 상자 조각의 텍스트를 조절하는 것만으로도 의미 있는 대화 상자를 생성하는 데 충분할 것입니다.문법적으로 합리적인 콘텐츠를 생성하는 것이 아니라 텍스트를 이해해야하기 때문에 우리는 여전히 그러한 시스템을 설계하는 것과는 거리가 멀다.
 
-그럼에도 불구하고 언어 모델은 제한된 형태로도 훌륭한 서비스를 제공합니다.예를 들어, “말을 인식하는 것”과 “멋진 해변을 망치기”라는 문구는 매우 비슷하게 들립니다.이로 인해 음성 인식이 모호해질 수 있으며, 이는 두 번째 번역을 엉뚱한 것으로 거부하는 언어 모델을 통해 쉽게 해결됩니다.마찬가지로 문서 요약 알고리즘에서 “개가 사람을 물다”는 것이 “남자가 개를 물다”보다 훨씬 더 빈번하거나 “할머니를 먹고 싶다”는 것이 다소 혼란스러운 진술이라는 것을 아는 것이 가치가 있습니다. “나는 먹고 싶다, 할머니”는 훨씬 더 양성이다. 
+그럼에도 불구하고 언어 모델은 제한된 형태로도 훌륭한 서비스를 제공합니다.예를 들어, “말을 인식하는 것”과 “멋진 해변을 망치기”라는 문구는 매우 비슷하게 들립니다.이로 인해 음성 인식이 모호해질 수 있으며, 이는 두 번째 번역을 엉뚱한 것으로 거부하는 언어 모델을 통해 쉽게 해결됩니다.마찬가지로 문서 요약 알고리즘에서 “개가 사람을 물다”는 것이 “남자가 개를 물다”보다 훨씬 더 빈번하거나 “할머니를 먹고 싶다”는 것이 다소 혼란스러운 진술이라는 것을 아는 것이 가치가 있습니다. “나는 먹고 싶다, 할머니”는 훨씬 더 양성이다.
 
 ## 언어 모델 학습
 
-분명한 질문은 문서 또는 일련의 토큰을 모델링하는 방법입니다.단어 수준에서 텍스트 데이터를 토큰화한다고 가정해 보겠습니다.:numref:`sec_sequence`에서 시퀀스 모델에 적용한 분석에 의지 할 수 있습니다.기본 확률 규칙을 적용하여 시작하겠습니다. 
+분명한 질문은 문서 또는 일련의 토큰을 모델링하는 방법입니다.단어 수준에서 텍스트 데이터를 토큰화한다고 가정해 보겠습니다.:numref:`sec_sequence`에서 시퀀스 모델에 적용한 분석에 의지 할 수 있습니다.기본 확률 규칙을 적용하여 시작하겠습니다.
 
 $$P(x_1, x_2, \ldots, x_T) = \prod_{t=1}^T P(x_t  \mid  x_1, \ldots, x_{t-1}).$$
 
-예를 들어, 네 단어가 포함된 텍스트 시퀀스의 확률은 다음과 같습니다. 
+예를 들어, 네 단어가 포함된 텍스트 시퀀스의 확률은 다음과 같습니다.
 
 $$P(\text{deep}, \text{learning}, \text{is}, \text{fun}) =  P(\text{deep}) P(\text{learning}  \mid  \text{deep}) P(\text{is}  \mid  \text{deep}, \text{learning}) P(\text{fun}  \mid  \text{deep}, \text{learning}, \text{is}).$$
 
-언어 모델을 계산하려면 앞의 몇 단어가 주어진 단어의 확률과 조건부 확률을 계산해야 합니다.이러한 확률은 본질적으로 언어 모델 매개 변수입니다. 
+언어 모델을 계산하려면 앞의 몇 단어가 주어진 단어의 확률과 조건부 확률을 계산해야 합니다.이러한 확률은 본질적으로 언어 모델 매개 변수입니다.
 
-여기서는 훈련 데이터 세트가 모든 Wikipedia 항목, [Project Gutenberg](https://en.wikipedia.org/wiki/Project_Gutenberg) 및 웹에 게시된 모든 텍스트와 같은 큰 텍스트 코퍼스라고 가정합니다.단어의 확률은 훈련 데이터셋에 있는 주어진 단어의 상대적 단어 빈도로부터 계산할 수 있습니다.예를 들어, 추정값 $\hat{P}(\text{deep})$는 “deep”라는 단어로 시작하는 문장의 확률로 계산할 수 있습니다.약간 덜 정확한 접근법은 “deep”라는 단어의 모든 발생을 세고 코퍼스의 총 단어 수로 나누는 것입니다.이것은 특히 빈번한 단어의 경우 상당히 잘 작동합니다.계속 진행하면 추정하려고 시도 할 수 있습니다. 
+여기서는 훈련 데이터 세트가 모든 Wikipedia 항목, [Project Gutenberg](https://en.wikipedia.org/wiki/Project_Gutenberg) 및 웹에 게시된 모든 텍스트와 같은 큰 텍스트 코퍼스라고 가정합니다.단어의 확률은 훈련 데이터셋에 있는 주어진 단어의 상대적 단어 빈도로부터 계산할 수 있습니다.예를 들어, 추정값 $\hat{P}(\text{deep})$는 “deep”라는 단어로 시작하는 문장의 확률로 계산할 수 있습니다.약간 덜 정확한 접근법은 “deep”라는 단어의 모든 발생을 세고 코퍼스의 총 단어 수로 나누는 것입니다.이것은 특히 빈번한 단어의 경우 상당히 잘 작동합니다.계속 진행하면 추정하려고 시도 할 수 있습니다.
 
 $$\hat{P}(\text{learning} \mid \text{deep}) = \frac{n(\text{deep, learning})}{n(\text{deep})},$$
 
-여기서 $n(x)$ 및 $n(x, x')$는 각각 싱글톤과 연속적인 단어 쌍의 발생 횟수입니다.안타깝게도 단어 쌍의 확률을 추정하는 것은 다소 어렵습니다. “딥 러닝”의 발생 빈도가 훨씬 적기 때문입니다.특히 일부 비정상적인 단어 조합의 경우 정확한 추정치를 얻기에 충분한 단어를 찾는 것이 까다로울 수 있습니다.세 단어 조합과 그 이상의 경우 상황이 악화됩니다.데이터셋에서는 볼 수 없는 그럴듯한 세 단어 조합이 많이 있을 것입니다.이러한 단어 조합을 0이 아닌 개수로 할당하는 솔루션을 제공하지 않으면 언어 모델에서 사용할 수 없습니다.데이터셋이 작거나 단어가 매우 드문 경우 그중 하나도 찾지 못할 수 있습니다. 
+여기서 $n(x)$ 및 $n(x, x')$는 각각 싱글톤과 연속적인 단어 쌍의 발생 횟수입니다.안타깝게도 단어 쌍의 확률을 추정하는 것은 다소 어렵습니다. “딥 러닝”의 발생 빈도가 훨씬 적기 때문입니다.특히 일부 비정상적인 단어 조합의 경우 정확한 추정치를 얻기에 충분한 단어를 찾는 것이 까다로울 수 있습니다.세 단어 조합과 그 이상의 경우 상황이 악화됩니다.데이터셋에서는 볼 수 없는 그럴듯한 세 단어 조합이 많이 있을 것입니다.이러한 단어 조합을 0이 아닌 개수로 할당하는 솔루션을 제공하지 않으면 언어 모델에서 사용할 수 없습니다.데이터셋이 작거나 단어가 매우 드문 경우 그중 하나도 찾지 못할 수 있습니다.
 
-일반적인 전략은 어떤 형태의*라플라스 스무딩*을 수행하는 것입니다.해결책은 모든 카운트에 작은 상수를 추가하는 것입니다.훈련 세트에 포함된 총 단어 수를 $n$로 나타내고 고유한 단어의 수를 $m$로 나타냅니다.이 솔루션은 싱글톤 (예: via) 에 도움이 됩니다. 
+일반적인 전략은 어떤 형태의*라플라스 스무딩*을 수행하는 것입니다.해결책은 모든 카운트에 작은 상수를 추가하는 것입니다.훈련 세트에 포함된 총 단어 수를 $n$로 나타내고 고유한 단어의 수를 $m$로 나타냅니다.이 솔루션은 싱글톤 (예: via) 에 도움이 됩니다.
 
 $$\begin{aligned}
 	\hat{P}(x) & = \frac{n(x) + \epsilon_1/m}{n + \epsilon_1}, \\
@@ -35,13 +35,13 @@ $$\begin{aligned}
 	\hat{P}(x'' \mid x,x') & = \frac{n(x, x',x'') + \epsilon_3 \hat{P}(x'')}{n(x, x') + \epsilon_3}.
 \end{aligned}$$
 
-여기서 $\epsilon_1,\epsilon_2$과 $\epsilon_3$는 하이퍼파라미터입니다.$\epsilon_1$을 예로 들어 보겠습니다. $\epsilon_1 = 0$에서는 스무딩이 적용되지 않습니다. $\epsilon_1$이 양의 무한대에 가까워지면 $\hat{P}(x)$는 균일 확률 $1/m$에 접근합니다.위의 내용은 다른 기술이 :cite:`Wood.Gasthaus.Archambeau.ea.2011`를 달성 할 수있는 것의 다소 원시적 인 변형입니다. 
+여기서 $\epsilon_1,\epsilon_2$과 $\epsilon_3$는 하이퍼파라미터입니다.$\epsilon_1$을 예로 들어 보겠습니다. $\epsilon_1 = 0$에서는 스무딩이 적용되지 않습니다. $\epsilon_1$이 양의 무한대에 가까워지면 $\hat{P}(x)$는 균일 확률 $1/m$에 접근합니다.위의 내용은 다른 기술이 :cite:`Wood.Gasthaus.Archambeau.ea.2011`를 달성 할 수있는 것의 다소 원시적 인 변형입니다.
 
-안타깝게도 이와 같은 모델은 다음과 같은 이유로 다소 빨리 다루기 힘듭니다.먼저 모든 개수를 저장해야 합니다.둘째, 단어의 의미를 완전히 무시합니다.예를 들어, “고양이”와 “고양이”는 관련 상황에서 발생해야 합니다.이러한 모델을 추가 컨텍스트에 맞게 조정하는 것은 매우 어렵지만 딥 러닝 기반 언어 모델은 이를 고려하는 데 매우 적합합니다.마지막으로, 긴 단어 시퀀스는 거의 참신하다는 것이 확실하므로 이전에 본 단어 시퀀스의 빈도를 단순히 계산하는 모델은 그곳에서 제대로 수행되지 않을 것입니다. 
+안타깝게도 이와 같은 모델은 다음과 같은 이유로 다소 빨리 다루기 힘듭니다.먼저 모든 개수를 저장해야 합니다.둘째, 단어의 의미를 완전히 무시합니다.예를 들어, “고양이”와 “고양이”는 관련 상황에서 발생해야 합니다.이러한 모델을 추가 컨텍스트에 맞게 조정하는 것은 매우 어렵지만 딥 러닝 기반 언어 모델은 이를 고려하는 데 매우 적합합니다.마지막으로, 긴 단어 시퀀스는 거의 참신하다는 것이 확실하므로 이전에 본 단어 시퀀스의 빈도를 단순히 계산하는 모델은 그곳에서 제대로 수행되지 않을 것입니다.
 
 ## 마르코프 모델 및 $n$그램
 
-딥 러닝과 관련된 솔루션을 논의하기 전에 용어와 개념이 더 필요합니다.:numref:`sec_sequence`에서 마르코프 모델에 대한 논의를 상기하십시오.이를 언어 모델링에 적용해 보겠습니다.시퀀스에 대한 분포는 $P(x_{t+1} \mid x_t, \ldots, x_1) = P(x_{t+1} \mid x_t)$인 경우 1차 마르코프 속성을 충족합니다.주문이 높을수록 종속성이 길어집니다.이렇게 하면 시퀀스를 모델링하는 데 적용할 수 있는 여러 근사값이 생성됩니다. 
+딥 러닝과 관련된 솔루션을 논의하기 전에 용어와 개념이 더 필요합니다.:numref:`sec_sequence`에서 마르코프 모델에 대한 논의를 상기하십시오.이를 언어 모델링에 적용해 보겠습니다.시퀀스에 대한 분포는 $P(x_{t+1} \mid x_t, \ldots, x_1) = P(x_{t+1} \mid x_t)$인 경우 1차 마르코프 속성을 충족합니다.주문이 높을수록 종속성이 길어집니다.이렇게 하면 시퀀스를 모델링하는 데 적용할 수 있는 여러 근사값이 생성됩니다.
 
 $$
 \begin{aligned}
@@ -51,7 +51,7 @@ P(x_1, x_2, x_3, x_4) &=  P(x_1) P(x_2  \mid  x_1) P(x_3  \mid  x_1, x_2) P(x_4
 \end{aligned}
 $$
 
-하나, 둘, 세 개의 변수를 포함하는 확률 공식은 일반적으로*유니그램*, *바이그램* 및*트라이그램* 모형이라고 합니다.다음에서는 더 나은 모델을 설계하는 방법을 배웁니다. 
+하나, 둘, 세 개의 변수를 포함하는 확률 공식은 일반적으로*유니그램*, *바이그램* 및*트라이그램* 모형이라고 합니다.다음에서는 더 나은 모델을 설계하는 방법을 배웁니다.
 
 ## 자연어 통계
 
@@ -82,13 +82,13 @@ import random
 #@tab all
 tokens = d2l.tokenize(d2l.read_time_machine())
 # Since each text line is not necessarily a sentence or a paragraph, we
-# concatenate all text lines 
+# concatenate all text lines
 corpus = [token for line in tokens for token in line]
 vocab = d2l.Vocab(corpus)
 vocab.token_freqs[:10]
 ```
 
-우리가 볼 수 있듯이 (**가장 인기있는 단어는**) 실제로 보기에는 지루합니다.종종 (***중지 단어***) 라고 불리며 필터링됩니다.그럼에도 불구하고 그들은 여전히 의미를 지니고 있으며 우리는 여전히 그것을 사용할 것입니다.게다가 주파수라는 단어가 다소 빠르게 쇠퇴한다는 것은 분명합니다.$10^{\mathrm{th}}$의 가장 빈번한 단어는 가장 인기 있는 단어만큼 일반적인 $1/5$보다 작습니다.더 나은 아이디어를 얻기 위해 [**주파수**라는 단어의 그림을 플로팅합니다].
+우리가 볼 수 있듯이 (**가장 인기있는 단어는**) 실제로 보기에는 지루합니다.종종 (***중지 단어***) 라고 불리며 필터링됩니다.그럼에도 불구하고 그들은 여전히 의미를 지니고 있으며 우리는 여전히 그것을 사용할 것입니다.게다가 주파수라는 단어가 다소 빠르게 쇠퇴한다는 것은 분명합니다.$10^{\mathrm{th}}$의 가장 빈번한 단어는 가장 인기 있는 단어만큼 일반적인 $1/5$보다 작습니다.더 나은 아이디어를 얻기 위해 [**주파수라는 단어의 그림을 플로팅합니다**].
 
 ```{.python .input}
 #@tab all
@@ -97,16 +97,16 @@ d2l.plot(freqs, xlabel='token: x', ylabel='frequency: n(x)',
          xscale='log', yscale='log')
 ```
 
-우리는 여기서 아주 근본적인 것을 하고 있습니다. 주파수라는 단어는 잘 정의된 방식으로 빠르게 쇠퇴합니다.처음 몇 단어를 예외로 처리한 후 나머지 모든 단어는 로그 로그 플롯에서 대략적으로 직선을 따릅니다.즉, 단어가*Zipf의 법칙*을 충족한다는 것을 의미합니다. 즉, $i^\mathrm{th}$에서 가장 자주 사용되는 단어의 빈도 $n_i$는 다음과 같습니다. 
+우리는 여기서 아주 근본적인 것을 하고 있습니다. 주파수라는 단어는 잘 정의된 방식으로 빠르게 쇠퇴합니다.처음 몇 단어를 예외로 처리한 후 나머지 모든 단어는 로그 로그 플롯에서 대략적으로 직선을 따릅니다.즉, 단어가*Zipf의 법칙*을 충족한다는 것을 의미합니다. 즉, $i^\mathrm{th}$에서 가장 자주 사용되는 단어의 빈도 $n_i$는 다음과 같습니다.
 
 $$n_i \propto \frac{1}{i^\alpha},$$
 :eqlabel:`eq_zipf_law`
 
-이는 다음과 같습니다. 
+이는 다음과 같습니다.
 
 $$\log n_i = -\alpha \log i + c,$$
 
-여기서 $\alpha$는 분포를 나타내는 지수이고 $c$는 상수입니다.통계를 세고 스무딩하여 단어를 모델링하려는 경우 이미 일시 중지 될 것입니다.결국 우리는 드문 단어라고도 알려진 꼬리의 빈도를 크게 과대 평가할 것입니다.하지만 [**바이그램, 트라이그램** 같은 다른 단어 조합은 어떻습니까?]바이 그램 주파수가 유니 그램 주파수와 동일한 방식으로 작동하는지 살펴 보겠습니다.
+여기서 $\alpha$는 분포를 나타내는 지수이고 $c$는 상수입니다.통계를 세고 스무딩하여 단어를 모델링하려는 경우 이미 일시 중지 될 것입니다.결국 우리는 드문 단어라고도 알려진 꼬리의 빈도를 크게 과대 평가할 것입니다.하지만 [**바이그램, 트라이그램**] 같은 다른 단어 조합은 어떻습니까?바이 그램 주파수가 유니 그램 주파수와 동일한 방식으로 작동하는지 살펴 보겠습니다.
 
 ```{.python .input}
 #@tab all
@@ -136,13 +136,13 @@ d2l.plot([freqs, bigram_freqs, trigram_freqs], xlabel='token: x',
          legend=['unigram', 'bigram', 'trigram'])
 ```
 
-이 수치는 여러 가지 이유로 매우 흥미 롭습니다.첫째, 유니그램 단어 외에도 시퀀스 길이에 따라 :eqref:`eq_zipf_law`의 지수 $\alpha$가 더 작지만 일련의 단어가 Zipf의 법칙을 따르는 것으로 보입니다.둘째, 뚜렷한 $n$그램의 수는 그다지 크지 않습니다.이것은 언어에 상당히 많은 구조가 있다는 희망을 안겨줍니다.셋째, 많은 $n$그램이 매우 드물게 발생하기 때문에 라플라스 스무딩이 언어 모델링에 적합하지 않습니다.대신 딥 러닝 기반 모델을 사용할 것입니다. 
+이 수치는 여러 가지 이유로 매우 흥미 롭습니다.첫째, 유니그램 단어 외에도 시퀀스 길이에 따라 :eqref:`eq_zipf_law`의 지수 $\alpha$가 더 작지만 일련의 단어가 Zipf의 법칙을 따르는 것으로 보입니다.둘째, 뚜렷한 $n$그램의 수는 그다지 크지 않습니다.이것은 언어에 상당히 많은 구조가 있다는 희망을 안겨줍니다.셋째, 많은 $n$그램이 매우 드물게 발생하기 때문에 라플라스 스무딩이 언어 모델링에 적합하지 않습니다.대신 딥 러닝 기반 모델을 사용할 것입니다.
 
 ## 긴 시퀀스 데이터 읽기
 
-시퀀스 데이터는 본질적으로 순차적이므로 처리 문제를 해결해야 합니다.우리는 :numref:`sec_sequence`에서 다소 임시적인 방식으로 그렇게 했습니다.시퀀스가 너무 길어 모델이 한꺼번에 처리할 수 없는 경우, 읽기를 위해 해당 시퀀스를 분할할 수 있습니다.이제 일반적인 전략을 설명하겠습니다.모델을 도입하기 전에 신경망을 사용하여 언어 모델을 훈련한다고 가정해 보겠습니다. 여기서 네트워크는 미리 정의된 길이의 시퀀스의 미니 배치 (예: $n$ 시간 단계) 를 한 번에 처리합니다.이제 문제는 [**특징과 라벨의 미니배치를 무작위로 읽는 방법**] 입니다. 
+시퀀스 데이터는 본질적으로 순차적이므로 처리 문제를 해결해야 합니다.우리는 :numref:`sec_sequence`에서 다소 임시적인 방식으로 그렇게 했습니다.시퀀스가 너무 길어 모델이 한꺼번에 처리할 수 없는 경우, 읽기를 위해 해당 시퀀스를 분할할 수 있습니다.이제 일반적인 전략을 설명하겠습니다.모델을 도입하기 전에 신경망을 사용하여 언어 모델을 훈련한다고 가정해 보겠습니다. 여기서 네트워크는 미리 정의된 길이의 시퀀스의 미니 배치 (예: $n$ 시간 단계) 를 한 번에 처리합니다.이제 문제는 [**특징과 라벨의 미니배치를 무작위로 읽는 방법**] 입니다.
 
-우선 텍스트 시퀀스는*The Time Machine* 책 전체와 같이 임의로 길어질 수 있으므로 이러한 긴 시퀀스를 동일한 수의 시간 단계를 가진 하위 시퀀스로 나눌 수 있습니다.신경망을 훈련시킬 때 이러한 하위 시퀀스의 미니 배치가 모델에 공급됩니다.네트워크가 한 번에 $n$ 시간 스텝의 하위 시퀀스를 처리한다고 가정합니다. :numref:`fig_timemachine_5gram`는 원본 텍스트 시퀀스에서 하위 시퀀스를 얻는 다양한 방법을 보여 줍니다. 여기서 $n=5$과 각 시간 스텝의 토큰은 문자에 해당합니다.초기 위치를 나타내는 임의의 오프셋을 선택할 수 있기 때문에 상당히 자유롭습니다. 
+우선 텍스트 시퀀스는*The Time Machine* 책 전체와 같이 임의로 길어질 수 있으므로 이러한 긴 시퀀스를 동일한 수의 시간 단계를 가진 하위 시퀀스로 나눌 수 있습니다.신경망을 훈련시킬 때 이러한 하위 시퀀스의 미니 배치가 모델에 공급됩니다.네트워크가 한 번에 $n$ 시간 스텝의 하위 시퀀스를 처리한다고 가정합니다. :numref:`fig_timemachine_5gram`는 원본 텍스트 시퀀스에서 하위 시퀀스를 얻는 다양한 방법을 보여 줍니다. 여기서 $n=5$과 각 시간 스텝의 토큰은 문자에 해당합니다.초기 위치를 나타내는 임의의 오프셋을 선택할 수 있기 때문에 상당히 자유롭습니다.
 
 ![Different offsets lead to different subsequences when splitting up text.](../img/timemachine-5gram.svg)
 :label:`fig_timemachine_5gram`
@@ -152,7 +152,7 @@ d2l.plot([freqs, bigram_freqs, trigram_freqs], xlabel='token: x',
 
 ### 랜덤 샘플링
 
-(**랜덤 샘플링에서 각 예제는 원래의 긴 시퀀스에서 임의로 캡처된 하위 시퀀스입니다.**) 반복 중에 인접한 두 개의 무작위 미니 배치의 하위 시퀀스가 원래 시퀀스에서 반드시 인접하지는 않습니다.언어 모델링의 목표는 지금까지 본 토큰을 기반으로 다음 토큰을 예측하는 것입니다. 따라서 레이블은 원래 시퀀스이며 토큰 하나만큼 이동됩니다. 
+(**랜덤 샘플링에서 각 예제는 원래의 긴 시퀀스에서 임의로 캡처된 하위 시퀀스입니다.**) 반복 중에 인접한 두 개의 무작위 미니 배치의 하위 시퀀스가 원래 시퀀스에서 반드시 인접하지는 않습니다.언어 모델링의 목표는 지금까지 본 토큰을 기반으로 다음 토큰을 예측하는 것입니다. 따라서 레이블은 원래 시퀀스이며 토큰 하나만큼 이동됩니다.
 
 다음 코드에서는 매번 데이터에서 미니배치를 무작위로 생성합니다.여기서 인수 `batch_size`는 각 미니배치의 하위 시퀀스 예제 수를 지정하고 `num_steps`는 각 하위 시퀀스에서 미리 정의된 시간 단계 수입니다.
 
@@ -234,7 +234,7 @@ def seq_data_iter_sequential(corpus, batch_size, num_steps):  #@save
         yield X, Y
 ```
 
-동일한 설정을 사용하여 순차적 분할로 읽은 후속 시퀀스의 [**인쇄 기능 `X` 및 각 미니 배치마다 `Y` 레이블] 을 지정해 보겠습니다.반복하는 동안 인접한 두 미니 배치의 하위 시퀀스는 실제로 원래 시퀀스에서 인접합니다.
+동일한 설정을 사용하여 순차적 분할로 읽은 후속 시퀀스의 [**인쇄 기능 `X` 및 각 미니 배치마다 `Y` 레이블**] 을 지정해 보겠습니다.반복하는 동안 인접한 두 미니 배치의 하위 시퀀스는 실제로 원래 시퀀스에서 인접합니다.
 
 ```{.python .input}
 #@tab all