docs: 기존 머지 PR 중 발견 된 용어 불일치 수정

advanced_source/neural_style_tutorial.py

@@ -75,10 +75,10 @@
 # 지금 Style, Content 이미지를 가져올 것입니다. 원본 PIL 이미지는 0과 255 사이의 값을 갖지만,
 # 텐서로 변환될 때 0에서 1사이로 변환됩니다.
 # 이미지도 동일한 차원을 가지도록 크기가 변환되어야 합니다.
-# 주목해야 할 중요한 세부 사항은 torch 라이브러리의 신경망은 0에서 1사이의 텐서 값으로 훈련된다는 것입니다.
+# 주목해야 할 중요한 세부 사항은 torch 라이브러리의 신경망은 0에서 1사이의 텐서 값으로 학습된다는 것입니다.
 # 만약 0에서 255값을 가지는 텐서 이미지가 네트워크에 입력되는 경우,
 # 활성화된 특징 맵이 Content와 Style을 감지할 수 없습니다.
-# 그러나, Caffe 라이브러리의 미리 학습된 네트워크는 0에서 255값을 가지는 입력으로 훈련됩니다.
+# 그러나, Caffe 라이브러리의 미리 학습된 네트워크는 0에서 255값을 가지는 입력으로 학습됩니다.
 #
 #
 # .. Note::
@@ -142,16 +142,16 @@ def imshow(tensor, title=None):
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #
 # Content 손실은 각 계층에 대한 Content 거리의 가중치 버전을 나타냅니다.
-# 이 함수는 입력 :math:`X` 를 처리하는 레이어 :math:`L` 의 특징 맵 :math:`F_{XL}` 을 가져와서
+# 이 함수는 입력 :math:`X` 를 처리하는 계층 :math:`L` 의 특징 맵 :math:`F_{XL}` 을 가져와서
 # 이미지 :math:`X` 와 Content 이미지 :math:`C` 사이의
 # 가중 콘텐츠 거리(weighted content distance) :math:`w_{CL}.D_C^L(X,C)` 를 반환합니다.
 # Content 거리를 계산하기 위해 Content 이미지(:math:`F_{CL}`)의 특징 맵을 함수에서 알고 있어야합니다.
 # :math:`F_{CL}` 을 입력으로 사용하는 생성자를 사용해 이 함수를 torch 모듈로 구현합니다.
 # 거리 :math:`\|F_{XL} - F_{CL}\|^2` 는 두 개의 특징 맵 집합의 평균 제곱 오차이며 ``nn.MSELoss`` 를 사용하여 계산할 수 있습니다.
 #
 # Content 거리를 계산하기 위해 사용되는 합성곱 계층 바로 뒤에 Content 손실 모듈을 추가합니다.
-# 이렇게 하면 입력 이미지가 입력될 때마다 Content 손실이 원하는 레이어에서
-# 계산되고 autograd 을 통해 모든 기울기가 계산됩니다.
+# 이렇게 하면 입력 이미지가 입력될 때마다 Content 손실이 원하는 계층에서
+# 계산되고 autograd 을 통해 모든 변화도가 계산됩니다.
 # 이제 Content 손실 계층을 만들기 위해 Content 손실을 계산한 다음 계층의 입력을 반환하는
 # ``forward`` 메소드를 정의해야합니다.
 # 계산된 손실은 모듈의 매개 변수로써 저장됩니다.
@@ -161,7 +161,7 @@ class ContentLoss(nn.Module):
 
     def __init__(self, target,):
         super(ContentLoss, self).__init__()
-        # 기울기를 동적으로 계산하는데 사용되는 tree로부터 타깃 Content를 `분리(detach)` 합니다.
+        # 변화도를 동적으로 계산하는데 사용되는 tree로부터 타깃 Content를 `분리(detach)` 합니다.
         # 이것은 변수가 아니라 명시된 값입니다.
         # 그렇지 않으면 criterion의 forward 메소드에서 오류가 발생합니다.
         self.target = target.detach()
@@ -174,7 +174,7 @@ def forward(self, input):
 # .. Note::
 #    **중요 세부 사항**: 모듈의 이름은 ``ContentLoss`` 지만, 실제 PyTorch의 손실 함수는 아닙니다.
 #    만약 Content 손실을 PyTorch의 손실 함수로 정의하려면 Pytorch의 autograd 함수를 생성하여
-#    ``backward`` 메소드에서 수동으로 기울기를 다시 계산 및 구현 해야 합니다.
+#    ``backward`` 메소드에서 수동으로 변화도를 다시 계산 및 구현 해야 합니다.
 
 ######################################################################
 # 스타일 손실(Style Loss)
@@ -232,13 +232,13 @@ def forward(self, input):
 # 모델 가져오기
 # -------------------
 #
-# 이제는 사전 훈련된 신경망을 가져와야 합니다.
+# 이제는 사전 학습된 신경망을 가져와야 합니다.
 # 논문에서 사용된 것과 같이 19 계층을 가진 VGG 네트워크를 사용할 것입니다.
 #
 # PyTorch의 VGG 구현은 ``features`` (합성곱 및 풀링 계층 포함) 와
 # ``classifier`` (완전 연결 계층 포함) 두 가지 하위 ``Sequential`` 모듈로 구분 된 모듈입니다.
 # Content 및 Style 손실을 측정하기 위해서 각 합성곱 계층의 출력이 필요하기 때문에 ``features`` 모듈을 사용할 것입니다.
-# 일부 계층은 훈련하는 중 평가와 다른 동작을 하므로, 네트워크를 ``.eval()`` 를 사용해 평가 모드로 설정해야합니다.
+# 일부 계층은 학습하는 중 평가와 다른 동작을 하므로, 네트워크를 ``.eval()`` 를 사용해 평가 모드로 설정해야합니다.
 #
 
 cnn = vgg19(weights=VGG19_Weights.DEFAULT).features.eval()
@@ -248,7 +248,7 @@ def forward(self, input):
 ######################################################################
 # 추가적으로, VGG 네트워크는
 # mean=[0.485, 0.456, 0.406] 와 std=[0.229, 0.224, 0.225]로 각 채널이 정규화 된
-# 이미지로 훈련됩니다.
+# 이미지로 학습됩니다.
 # 이미지를 네트워크로 입력하기 전에 정규화하는데 사용합니다.
 #
 
@@ -367,20 +367,20 @@ def get_style_model_and_losses(cnn, normalization_mean, normalization_std,
 # 알고리즘 작성자인 Leon Gatys가
 # `여기 <https://discuss.pytorch.org/t/pytorch-tutorial-for-neural-transfert-of-artistic-style/336/20?u=alexis-jacq>`__ 에서 제안했던 것처럼,
 # L-BFGS 알고리즘을 사용하여 경사 하강법을 수행합니다.
-# 네트워크 훈련과 다르게 Content / Style 손실을 최소화하기 위해 입력 이미지를 훈련하려고 합니다.
+# 네트워크 학습과 다르게 Content / Style 손실을 최소화하기 위해 입력 이미지를 학습하려고 합니다.
 # 파이토치 L-BFGS optimizer ``optim.LBFGS`` 를 만들고 최적화 할 텐서로 이미지를 전달합니다.
 #
 
 def get_input_optimizer(input_img):
-    # 입력이 기울기가 필요한 매개 변수임을 표시하는 줄
+    # 입력이 변화도가 필요한 매개 변수임을 표시하는 줄
     optimizer = optim.LBFGS([input_img])
     return optimizer
 
 
 ######################################################################
 # 마지막으로 뉴럴 변환(neural transfer)을 수행하는 함수를 정의해야 합니다.
 # 네트워크의 각 반복 동안, 업데이트된 입력이 주어지고 새로운 손실을 계산합니다.
-# 각 손실 모듈(Loss module)의 ``backward`` 메소드를 실행하여 기울기를 동적으로 계산합니다.
+# 각 손실 모듈(Loss module)의 ``backward`` 메소드를 실행하여 변화도를 동적으로 계산합니다.
 # optimizer는 모듈을 재평가하고 손실을 반환하는 “closure” 함수가 필요합니다.
 #
 # 여전히 해결해야 할 마지막 제약이 있습니다.
@@ -400,7 +400,7 @@ def run_style_transfer(cnn, normalization_mean, normalization_std,
     # 이에 맞춰서 requires_grad 값을 갱신합니다.
     input_img.requires_grad_(True)
     # 또한, 모델을 평가(eval) 모드로 전환하여
-    # 드롭아웃(dropout) 및 배치 정규화(batch normalization)와 같은 특정 레이어가 올바르게 동작하도록 합니다.
+    # 드롭아웃(dropout) 및 배치 정규화(batch normalization)와 같은 특정 계층이 올바르게 동작하도록 합니다.
     model.eval()
     model.requires_grad_(False)
 

advanced_source/numpy_extensions_tutorial.py

@@ -72,7 +72,7 @@ def incorrect_fft(input):
 #
 # 학습 가능한 가중치를 가는 필터(커널)를 갖는 상호 상관 계층을 구현해보겠습니다.
 #
-# 역전파 단계(backward pass)에서는 입력에 대한 기울기(gradient)와 필터에 대한 기울기를 계산합니다.
+# 역전파 단계(backward pass)에서는 입력에 대한 변화도(gradient)와 필터에 대한 변화도를 계산합니다.
 
 from numpy import flip
 import numpy as np
@@ -126,7 +126,7 @@ def forward(self, input):
 print("Gradient for the input map: ", input.grad)
 
 ###############################################################
-# **기울기(gradient) 확인:**
+# **변화도(gradient) 확인:**
 
 from torch.autograd.gradcheck import gradcheck
 

advanced_source/semi_structured_sparse.py

@@ -40,7 +40,7 @@
 #
 # 이 튜토리얼은 초보자에게 반구조적 희소성 및 일반적인 희소성을 맞춤 설명합니다.
 # 이미 2:4 희소 모델을 보유한 사용자에게는 ``to_sparse_semi_structured``를 사용하여
-# 추론을 위한 ``nn.Linear`` 레이어를 가속화하는 것이 매우 간단합니다. 다음은 그 예시입니다:
+# 추론을 위한 ``nn.Linear`` 계층을 가속화하는 것이 매우 간단합니다. 다음은 그 예시입니다:
 #
 
 import torch
@@ -467,10 +467,10 @@ def measure_execution_time(model, batch_sizes, dataset):
 # 도구가 포함되어 있습니다. 이러한 희소화 도구는 모델의 가중치 텐서에 마스크 매개변수화를 적용하여
 # 작동합니다. 이를 통해 가지치기된 가중치를 마스킹하여 희소성을 시뮬레이션할 수 있습니다.
 #
-# 또한, 모델의 어느 레이어에 희소성을 적용할지 결정해야 합니다. 이 경우에는 각각의 테스크 헤드 출력을
-# 제외한 모든 ``nn.Linear`` 레이어에 적용합니다. 이는 반구조적 희소성(semi-structured sparsity)이
+# 또한, 모델의 어느 계층에 희소성을 적용할지 결정해야 합니다. 이 경우에는 각각의 테스크 헤드 출력을
+# 제외한 모든 ``nn.Linear`` 계층에 적용합니다. 이는 반구조적 희소성(semi-structured sparsity)이
 # `형상 제약 <https://pytorch.org/docs/2.1/sparse.html#constructing-sparse-semi-structured-tensors>`_
-# 을 가지기 때문이며, 각각의 task ``nn.Linear`` 레이어는 이러한 제약을 충족하지 않기 때문입니다.
+# 을 가지기 때문이며, 각각의 task ``nn.Linear`` 계층은 이러한 제약을 충족하지 않기 때문입니다.
 #
 
 sparsifier = WeightNormSparsifier(
@@ -491,7 +491,7 @@ def measure_execution_time(model, batch_sizes, dataset):
 
 
 ######################################################################
-# 모델의 매개변수화는 첫 번째 단계는 모델의 가중치를 마스킹하기 위한 매개변수화를 삽입하는 것입니다.
+# 모델의 가지치기를 위한 첫번째 단계는 모델의 가중치를 마스킹하기 위한 매개변수화를 삽입하는 것입니다.
 # 이는 준비 단계에서 수행됩니다. 이렇게 하면 ``.weight``에 접근할 때마다 대신 ``mask * weight``를
 # 얻게 됩니다.
 #
@@ -503,7 +503,7 @@ def measure_execution_time(model, batch_sizes, dataset):
 
 ######################################################################
 # 그 다음, 단일 가지치기 단계를 수행합니다. 모든 가지치기 도구(pruner)는 가지치기 도구의 구현
-# 논리에 따라 마스크를 업데이트하는 ``update_mask()`` 메서드를 구현합니다. 이 단계 메서드는
+# 논리에 따라 마스크를 업데이트하는 ``update_mask()`` 메소드를 구현합니다. 이 단계 메소드는
 # 희소성 설정(sparse config)에서 지정된 가중치에 대해 이 ``update_mask`` 함수를 호출합니다.
 #
 # 또한 모델을 평가하여 미세 조정/재학습 없이 가지치기(zero-shot) 또는 가지치기의 정확도 저하를 보여줄 것입니다.

advanced_source/static_quantization_tutorial.rst

@@ -449,7 +449,7 @@ ImageNet 데이터
     top1, top5 = evaluate(myModel, criterion, data_loader_test, neval_batches=num_eval_batches)
     print('Evaluation accuracy on %d images, %2.2f'%(num_eval_batches * eval_batch_size, top1.avg))
 
-양자화된 모델은 eval 데이터셋에서 56.7%의 정확도를 보여줍니다. 이는 양자화 파라미터를 결정하기 위해 단순 min/max Observer를 사용했기 때문입니다. 그럼에도 불구하고 모델의 크기를 3.6 MB 밑으로 줄였습니다. 이는 거의 4분의 1 로 줄어든 크기입니다.
+양자화된 모델은 eval 데이터셋에서 56.7%의 정확도를 보여줍니다. 이는 양자화 매개변수를 결정하기 위해 단순 min/max Observer를 사용했기 때문입니다. 그럼에도 불구하고 모델의 크기를 3.6 MB 밑으로 줄였습니다. 이는 거의 4분의 1 로 줄어든 크기입니다.
 
 이에 더해 단순히 다른 양자화 설정을 사용하기만 해도 정확도를 큰 폭으로 향상시킬 수 있습니다.
 x86 아키텍처에서 양자화를 위한 권장 설정을 그대로 쓰기만 해도 됩니다.

beginner_source/basics/autogradqs_tutorial.py

@@ -201,7 +201,7 @@
 ######################################################################
 # .. note:: 이전에는 매개변수 없이 ``backward()`` 함수를 호출했습니다. 이는 본질적으로
 #           ``backward(torch.tensor(1.0))`` 을 호출하는 것과 동일하며,
-#           신경망 훈련 중의 손실과 같은 스칼라-값 함수의 변화도를 계산하는 유용한 방법입니다.
+#           신경망 학습 중의 손실과 같은 스칼라-값 함수의 변화도를 계산하는 유용한 방법입니다.
 #
 
 ######################################################################

beginner_source/basics/optimization_tutorial.py

@@ -15,7 +15,7 @@
 이제 모델과 데이터가 준비되었으니, 데이터에 매개변수를 최적화하여 모델을 학습하고, 검증하고, 테스트할 차례입니다.
 모델을 학습하는 과정은 반복적인 과정을 거칩니다; 각 반복 단계에서 모델은 출력을 추측하고,
 추측과 정답 사이의 오류(\ *손실(loss)*\ )를 계산하고, (`이전 장 <autograd_tutorial.html>`_\ 에서 본 것처럼)
-매개변수에 대한 오류의 도함수(derivative)를 수집한 뒤, 경사하강법을 사용하여 이 파라미터들을 **최적화(optimize)**\ 합니다.
+매개변수에 대한 오류의 도함수(derivative)를 수집한 뒤, 경사하강법을 사용하여 이 매개변수들을 **최적화(optimize)**\ 합니다.
 이 과정에 대한 자세한 설명은 `3Blue1Brown의 역전파 <https://www.youtube.com/watch?v=tIeHLnjs5U8>`__ 영상을 참고하세요.
 
 기본(Pre-requisite) 코드
@@ -149,7 +149,7 @@ def forward(self, x):
 
 def train_loop(dataloader, model, loss_fn, optimizer):
     size = len(dataloader.dataset)
-    # 모델을 학습(train) 모드로 설정합니다 - 배치 정규화(Batch Normalization) 및 드롭아웃(Dropout) 레이어들에 중요합니다.
+    # 모델을 학습(train) 모드로 설정합니다 - 배치 정규화(Batch Normalization) 및 드롭아웃(Dropout) 계층들에 중요합니다.
     # 이 예시에서는 없어도 되지만, 모범 사례를 위해 추가해두었습니다.
     model.train()
     for batch, (X, y) in enumerate(dataloader):
@@ -168,7 +168,7 @@ def train_loop(dataloader, model, loss_fn, optimizer):
 
 
 def test_loop(dataloader, model, loss_fn):
-    # 모델을 평가(eval) 모드로 설정합니다 - 배치 정규화(Batch Normalization) 및 드롭아웃(Dropout) 레이어들에 중요합니다.
+    # 모델을 평가(eval) 모드로 설정합니다 - 배치 정규화(Batch Normalization) 및 드롭아웃(Dropout) 계층들에 중요합니다.
     # 이 예시에서는 없어도 되지만, 모범 사례를 위해 추가해두었습니다.
     model.eval()
     size = len(dataloader.dataset)

beginner_source/blitz/neural_networks_tutorial.py

@@ -8,7 +8,7 @@
 지금까지 ``autograd`` 를 살펴봤는데요, ``nn`` 은 모델을 정의하고 미분하는데
 ``autograd`` 를 사용합니다.
 ``nn.Module`` 은 계층(layer)과 ``output`` 을 반환하는 ``forward(input)``
-메서드를 포함하고 있습니다.
+메소드를 포함하고 있습니다.
 
 숫자 이미지를 분류하는 신경망을 예제로 살펴보겠습니다:
 
@@ -54,29 +54,29 @@ def __init__(self):
         self.fc3 = nn.Linear(84, 10)
 
     def forward(self, input):
-        # 합성곱(Convolution) 레이어 c1: 입력 이미지 채널 1, 출력 채널 6,
+        # 합성곱(Convolution) 계층 c1: 입력 이미지 채널 1, 출력 채널 6,
         # 5x5 정사각 합성곱, 활성 함수로 RELU 사용 및 (N, 6, 28, 28)의 크기를
         # 갖는 Tensor를 출력 (N은 배치 크기)
         c1 = F.relu(self.conv1(input))
-        # 서브샘플링(Subsampling) 레이어 s2: 2x2 격자, 순전히 기능적인 레이어로,
-        # 이 레이어는 어떠한 매개변수도 가지지 않고 (N, 6, 14, 14) Tensor를 출력
+        # 서브샘플링(Subsampling) 계층 s2: 2x2 격자, 순전히 기능적인 계층으로,
+        # 이 계층은 어떠한 매개변수도 가지지 않고 (N, 6, 14, 14) Tensor를 출력
         s2 = F.max_pool2d(c1, (2, 2))
-        # 합성곱(Convolution) 레이어 c3: 입력 채널 6, 출력 채널 16,
+        # 합성곱(Convolution) 계층 c3: 입력 채널 6, 출력 채널 16,
         # 5x5 정사각 합성곱, 활성 함수로 RELU 사용 및 (N, 16, 10, 10)의 크기를
         # 갖는 Tensor를 출력
         c3 = F.relu(self.conv2(s2))
-        # 서브샘플링(Subsampling) 레이어 s4: 2x2 격자, 순전히 기능적인 레이어로,
-        # 이 레이어는 어떠한 매개변수도 가지지 않고 (N, 16, 5, 5) Tensor를 출력
+        # 서브샘플링(Subsampling) 계층 s4: 2x2 격자, 순전히 기능적인 계층으로,
+        # 이 계층은 어떠한 매개변수도 가지지 않고 (N, 16, 5, 5) Tensor를 출력
         s4 = F.max_pool2d(c3, 2)
         # 평탄화(flatten) 연산: 순전히 기능적으로 동작하며, (N, 400) Tensor를 출력
         s4 = torch.flatten(s4, 1)
-        # 완전히 연결된 레이어 f5: (N, 400) Tensor를 입력으로 받아서
+        # 완전히 연결된 계층 f5: (N, 400) Tensor를 입력으로 받아서
         # (N, 120) Tensor를 출력하며, 활성 함수로 RELU 사용
         f5 = F.relu(self.fc1(s4))
-        # 완전히 연결된 레이어 f6: (N, 120) Tensor를 입력으로 받아서
+        # 완전히 연결된 계층 f6: (N, 120) Tensor를 입력으로 받아서
         # (N, 84) Tensor를 출력하며, 활성 함수로 RELU 사용
         f6 = F.relu(self.fc2(f5))
-        # 가우시안 레이어 출력: (N, 84) Tensor를 입력으로 받아서
+        # 가우시안 계층 출력: (N, 84) Tensor를 입력으로 받아서
         # (N, 10) Tensor를 출력
         output = self.fc3(f6)
         return output