docs: 번역어 통일 - '기울기'를 '변화도'로 변경

Author: rltq

advanced_source/neural_style_tutorial.py

@@ -151,7 +151,7 @@ def imshow(tensor, title=None):
 #
 # Content 거리를 계산하기 위해 사용되는 합성곱 계층 바로 뒤에 Content 손실 모듈을 추가합니다.
 # 이렇게 하면 입력 이미지가 입력될 때마다 Content 손실이 원하는 계층에서
-# 계산되고 autograd 을 통해 모든 기울기가 계산됩니다.
+# 계산되고 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)
@@ -372,15 +372,15 @@ def get_style_model_and_losses(cnn, normalization_mean, normalization_std,
 #
 
 def get_input_optimizer(input_img):
-    # 입력이 기울기가 필요한 매개 변수임을 표시하는 줄
+    # 입력이 변화도가 필요한 매개 변수임을 표시하는 줄
     optimizer = optim.LBFGS([input_img])
     return optimizer
 
 
 ######################################################################
 # 마지막으로 뉴럴 변환(neural transfer)을 수행하는 함수를 정의해야 합니다.
 # 네트워크의 각 반복 동안, 업데이트된 입력이 주어지고 새로운 손실을 계산합니다.
-# 각 손실 모듈(Loss module)의 ``backward`` 메소드를 실행하여 기울기를 동적으로 계산합니다.
+# 각 손실 모듈(Loss module)의 ``backward`` 메소드를 실행하여 변화도를 동적으로 계산합니다.
 # optimizer는 모듈을 재평가하고 손실을 반환하는 “closure” 함수가 필요합니다.
 #
 # 여전히 해결해야 할 마지막 제약이 있습니다.

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
 

beginner_source/introyt/introyt1_tutorial.py

@@ -286,7 +286,7 @@ def num_flat_features(self, x):
 #    PyTorch tensor 형태로 변환합니다.
 # -  ``transforms.Normalize()`` 는 tensor의 평균이 0이고 표준 편차가 1.0이
 #      되도록 tensor의 값을 조정합니다.
-#      대부분의 활성화 함수는 x = 0 부근에서 강한 기울기 값을 가지고 있어 데이터를
+#      대부분의 활성화 함수는 x = 0 부근에서 강한 변화도 값을 가지고 있어 데이터를
 #      중앙으로 집중화하여 학습 속도를 높일 수 있습니다.
 #
 # 변환(transform)에 전달되는 값들은 각각 데이터셋에 있는 이미지들의 RGB 채널별
@@ -516,7 +516,7 @@ def forward(self, x):
         # 데이터를 통해 이미지와 정답값을 받습니다.
         inputs, labels = data
 
-        # 초기 기울기 매개변수를 0으로 설정합니다
+        # 초기 변화도 매개변수를 0으로 설정합니다
         optimizer.zero_grad()
 
         # forward + backward + optimize
@@ -541,14 +541,14 @@ def forward(self, x):
 # **iterates over the training data** (4번째 라인)의 내부 루프가 있어
 # 변환된 입력 이미지의 batch와 올바른 레이블을 제공합니다.
 #
-# **기울기 값 초기화** (9번째 라인) 은 중요한 단계입니다. 기울기는 batch에
-# 걸쳐 누적됩니다. 모든 batch에 대해 기울기 값을 재설정하지 않으면 기울기
-# 값이 계속 누적되어 잘못된 기울기 값을 제공하여 학습이 불가능합니다.
+# **변화도 값 초기화** (9번째 라인) 은 중요한 단계입니다. 변화도는 batch에
+# 걸쳐 누적됩니다. 모든 batch에 대해 변화도 값을 재설정하지 않으면 변화도
+# 값이 계속 누적되어 잘못된 변화도 값을 제공하여 학습이 불가능합니다.
 #
 # 12번째 라인에서는 batch 데이터를 **모델에게 예측을 요청** 합니다.
 # 다음 13번째라인에서 모델의 결과 값과 정답 값 차이인 손실값을 계산합니다.
 #
-# 14번째 라인에서는 ``backward()`` 를 통해 모델의 학습 기울기를 계산합니다.
+# 14번째 라인에서는 ``backward()`` 를 통해 모델의 학습 변화도를 계산합니다.
 #
 # 15번째 라인에서는 학습 단계의 최적화를 수행하는데 ``backward()``
 # 를 통해 손실 값을 줄일 수 있는 방향으로 학습 가중치들을 조정합니다.

beginner_source/nlp/sequence_models_tutorial.py

@@ -205,7 +205,7 @@ def forward(self, sentence):
         # 3단계, 순전파 단계(forward pass)를 실행합니다.
         tag_scores = model(sentence_in)
 
-        # 4단계, 손실과 기울기를 계산하고, optimizer.step()을 호출하여 
+        # 4단계, 손실과 변화도를 계산하고, optimizer.step()을 호출하여 
         # 매개변수를 업데이트합니다. 
         loss = loss_function(tag_scores, targets)
         loss.backward()

beginner_source/nlp/word_embeddings_tutorial.py

@@ -228,8 +228,8 @@ def forward(self, inputs):
         # 바꾸고 파이토치 텐서로 감싸줍시다.)
         context_idxs = torch.tensor([word_to_ix[w] for w in context], dtype=torch.long)
 
-        # 두번째. 토치는 기울기가 *누적* 됩니다. 새 인스턴스를 넣어주기 전에
-        # 기울기를 초기화합니다.
+        # 두번째. 토치는 변화도가 *누적* 됩니다. 새 인스턴스를 넣어주기 전에
+        # 변화도를 초기화합니다.
         model.zero_grad()
 
         # 세번째. 순전파를 통해 다음에 올 단어에 대한 로그 확률을 구합니다.
@@ -238,7 +238,7 @@ def forward(self, inputs):
         # 네번째. 손실함수를 계산합니다. (파이토치에서는 목표 단어를 텐서로 감싸줘야 합니다.)
         loss = loss_function(log_probs, torch.tensor([word_to_ix[target]], dtype=torch.long))
 
-        # 다섯번째. 역전파를 통해 기울기를 업데이트 해줍니다.
+        # 다섯번째. 역전파를 통해 변화도를 업데이트 해줍니다.
         loss.backward()
         optimizer.step()
 

beginner_source/nn_tutorial.py

@@ -107,12 +107,12 @@
 # PyTorch는 랜덤 또는 0으로만 이루어진 텐서를 생성하는 메소드를 제공하고,
 # 우리는 간단한 선형 모델의 가중치(weights)와 절편(bias)을 생성하기 위해서 이것을 사용할 것입니다.
 # 이들은 일반적인 텐서에 매우 특별한 한 가지가 추가된 것입니다: 우리는 PyTorch에게 이들이
-# 기울기(gradient)가 필요하다고 알려줍니다.
+# 변화도(gradient)가 필요하다고 알려줍니다.
 # 이를 통해 PyTorch는 텐서에 행해지는 모든 연산을 기록하게 하고,
-# 따라서 *자동적으로* 역전파(back-propagation) 동안에 기울기를 계산할 수 있습니다!
+# 따라서 *자동적으로* 역전파(back-propagation) 동안에 변화도를 계산할 수 있습니다!
 #
 # 가중치에 대해서는 ``requires_grad`` 를 초기화(initialization) **다음에** 설정합니다,
-# 왜냐하면 우리는 해당 단계가 기울기에 포함되는 것을 원치 않기 때문입니다.
+# 왜냐하면 우리는 해당 단계가 변화도에 포함되는 것을 원치 않기 때문입니다.
 # (PyTorch에서 ``_`` 다음에 오는 메소드 이름은 연산이 인플레이스(in-place)로 수행되는 것을 의미합니다.)
 #
 # .. note:: `Xavier initialisation <http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf>`_
@@ -125,7 +125,7 @@
 bias = torch.zeros(10, requires_grad=True)
 
 ###############################################################################
-# PyTorch의 기울기를 자동으로 계산 해주는 기능 덕분에, Python 표준 함수
+# PyTorch의 변화도를 자동으로 계산 해주는 기능 덕분에, Python 표준 함수
 # (또는 호출 가능한 객체)를 모델로 사용할 수 있습니다!
 # 그러므로 간단한 선형 모델을 만들기 위해서 단순한 행렬 곱셈과 브로드캐스트(broadcast)
 # 덧셈을 사용하여 보겠습니다. 또한, 우리는 활성화 함수(activation function)가 필요하므로,
@@ -155,7 +155,7 @@ def model(xb):
 
 ###############################################################################
 # 여러분이 보시듯이, ``preds`` 텐서(tensor)는 텐서 값 외에도, 또한
-# 기울기 함수(gradient function)를 담고 있습니다.
+# 변화도 함수(gradient function)를 담고 있습니다.
 # 우리는 나중에 이것을 역전파(backpropagation)를 위해 사용할 것입니다.
 # 이제 손실함수(loss function)로 사용하기 위한 음의 로그 우도(negative log-likelihood)를
 # 구현합시다. (다시 말하지만, 우리는 표준 Python을 사용할 수 있습니다.):
@@ -195,17 +195,17 @@ def accuracy(out, yb):
 # - 데이터의 미니배치를 선택 (``bs`` 크기)
 # - 모델을 이용하여 예측 수행
 # - 손실 계산
-# - ``loss.backward()`` 를 이용하여 모델의 기울기 업데이트, 이 경우에는, ``weights`` 와 ``bias``.
+# - ``loss.backward()`` 를 이용하여 모델의 변화도 업데이트, 이 경우에는, ``weights`` 와 ``bias``.
 #
-# 이제 우리는 이 기울기들을 이용하여 가중치와 절편을 업데이트 합니다.
+# 이제 우리는 이 변화도들을 이용하여 가중치와 절편을 업데이트 합니다.
 # 우리는 이것을 ``torch.no_grad()`` 컨텍스트 매니저(context manager) 내에서 실행합니다,
-# 왜냐하면 이러한 실행이 다음 기울기의 계산에 기록되지 않기를 원하기 때문입니다.
-# PyTorch의 자동 기울기(Autograd)가 어떻게 연산을 기록하는지
+# 왜냐하면 이러한 실행이 다음 변화도의 계산에 기록되지 않기를 원하기 때문입니다.
+# PyTorch의 자동 변화도(Autograd)가 어떻게 연산을 기록하는지
 # `여기 <https://pytorch.org/docs/stable/notes/autograd.html>`_\에서 더 알아볼 수 있습니다.
 #
-# 그러고 나서 기울기를 0으로 설정합니다, 그럼으로써 다음 루프(loop)에 준비하게 됩니다.
-# 그렇지 않으면, 우리의 기울기들은 일어난 모든 연산의 누적 집계를 기록하게 되어버립니다.
-# (즉, ``loss.backward()`` 가 이미 저장된 것을 대체하기보단, 기존 값에 기울기를 *더하게* 됩니다).
+# 그러고 나서 변화도를 0으로 설정합니다, 그럼으로써 다음 루프(loop)에 준비하게 됩니다.
+# 그렇지 않으면, 우리의 변화도들은 일어난 모든 연산의 누적 집계를 기록하게 되어버립니다.
+# (즉, ``loss.backward()`` 가 이미 저장된 것을 대체하기보단, 기존 값에 변화도를 *더하게* 됩니다).
 #
 # .. tip:: 여러분들은 PyTorch 코드에 대하여 표준 python 디버거(debugger)를 사용할 수 있으므로,
 #    매 단계마다 다양한 변수 값을 점검할 수 있습니다.
@@ -320,7 +320,7 @@ def forward(self, xb):
 
 ###############################################################################
 # 이전에는 훈련 루프를 위해 이름 별로 각 매개변수(parameter)의 값을 업데이트하고 다음과 같이
-# 각 매개 변수에 대한 기울기들을 개별적으로 수동으로 0으로 제거해야 했습니다:
+# 각 매개 변수에 대한 변화도들을 개별적으로 수동으로 0으로 제거해야 했습니다:
 #
 # .. code-block:: python
 #
@@ -423,8 +423,8 @@ def forward(self, xb):
 #    opt.step()
 #    opt.zero_grad()
 #
-# (``optim.zero_grad()`` 는 기울기를 0으로 재설정 해줍니다. 다음 미니 배치에 대한
-# 기울기를 계산하기 전에 호출해야 합니다.)
+# (``optim.zero_grad()`` 는 변화도를 0으로 재설정 해줍니다. 다음 미니 배치에 대한
+# 변화도를 계산하기 전에 호출해야 합니다.)
 
 from torch import optim
 
@@ -572,7 +572,7 @@ def get_model():
 #
 # 검증 데이터셋에 대한 배치 크기는 학습 데이터셋 배치 크기의 2배를 사용할 것입니다.
 # 이는 검증 데이터셋에 대해서는 역전파(backpropagation)가 필요하지 않으므로 메모리를
-# 덜 사용하기 때문입니다 (기울기를 저장할 필요가 없음).
+# 덜 사용하기 때문입니다 (변화도를 저장할 필요가 없음).
 # 더 큰 배치 크기를 사용하여 손실을 더 빨리 계산하기 위해 이렇게 합니다.
 
 train_ds = TensorDataset(x_train, y_train)
@@ -867,7 +867,7 @@ def preprocess(x, y):
 #
 #    + ``Module``: 함수처럼 동작하지만, 또한 상태(state) (예를 들어, 신경망의 계층 가중치)를
 #      포함할 수 있는 호출 가능한 오브젝트를 생성합니다.
-#      이는 포함된 ``Parameter`` (들)가 어떤 것인지 알고, 모든 기울기를 0으로 설정하고 가중치
+#      이는 포함된 ``Parameter`` (들)가 어떤 것인지 알고, 모든 변화도를 0으로 설정하고 가중치
 #      업데이트 등을 위해 반복할 수 있습니다.
 #    + ``Parameter``: ``Module`` 에 역전파 동안 업데이트가 필요한 가중치가 있음을 알려주는
 #      텐서용 래퍼입니다. `requires_grad` 속성이 설정된 텐서만 업데이트 됩니다.

beginner_source/transformer_tutorial.py

@@ -272,7 +272,7 @@ def get_batch(source: Tensor, i: int) -> Tuple[Tensor, Tensor]:
 # `SGD <https://pytorch.org/docs/stable/generated/torch.optim.SGD.html>`__ (확률적 경사 하강법) 옵티마이저(optimizer)와
 # 함께 사용하였습니다. 학습률(learning rate)는 5.0으로 초기화하였으며 `StepLR <https://pytorch.org/docs/master/optim.html?highlight=steplr#torch.optim.lr_scheduler.StepLR>`__
 # 스케쥴을 따릅니다. 학습하는 동안, `nn.utils.clip_grad_norm\_ <https://pytorch.org/docs/stable/generated/torch.nn.utils.clip_grad_norm_.html>`__
-# 을 사용하여 기울기(gradient)가 폭발(exploding)하지 않도록 합니다.
+# 을 사용하여 변화도(gradient)가 폭발(exploding)하지 않도록 합니다.
 #
 
 import copy

intermediate_source/autograd_saved_tensors_hooks_tutorial.py

@@ -6,7 +6,7 @@
 
 
 ######################################################################
-# 파이토치는 일반적으로 역전파를 통해 기울기를 계산합니다.
+# 파이토치는 일반적으로 역전파를 통해 변화도를 계산합니다.
 # 그러나 특정 작업에서는 역전파를 수행하기 위한 중간결과를 저장해야 합니다.
 # 이번 튜토리얼에서는 이러한 tensor를 저장/검색하는 방법과
 # 패킹/언패킹 절차를 제어하는 hooks을 정의하는 방법을 안내합니다.

intermediate_source/forward_ad_usage.py

@@ -13,7 +13,7 @@
 
 기본 사용법
 --------------------------------------------------------------------
-역전파 모드 자동 미분(Reverse-mode Automatic Differentiation)과 달리, 순전파 모드 자동 미분은 순전파(forward pass)를 진행하며 기울기(gradient)를 즉시(계산을 미루지 않고) 계산합니다. 순전파 모드 자동 미분으로 방향성 도함수를 계산하려면, 먼저 입력을 방향성 도함수의 방향을 나타내는 다른 tensor(야코비안-벡터 곱의 `v`에 해당)와 연결한 뒤 이전과 같이 순전파를 수행하면 됩니다. 'primal'이라고 부르는 입력이 'tangent'라고 부르는 '방향' tensor와 연결될 때, 결과로 나오는 새로운 tensor 객체는 이중수(dual numbers) [0] 와의 관련성 때문에 '이중 tensor(dual tensor)'라고 불립니다.
+역전파 모드 자동 미분(Reverse-mode Automatic Differentiation)과 달리, 순전파 모드 자동 미분은 순전파(forward pass)를 진행하며 변화도(gradient)를 즉시(계산을 미루지 않고) 계산합니다. 순전파 모드 자동 미분으로 방향성 도함수를 계산하려면, 먼저 입력을 방향성 도함수의 방향을 나타내는 다른 tensor(야코비안-벡터 곱의 `v`에 해당)와 연결한 뒤 이전과 같이 순전파를 수행하면 됩니다. 'primal'이라고 부르는 입력이 'tangent'라고 부르는 '방향' tensor와 연결될 때, 결과로 나오는 새로운 tensor 객체는 이중수(dual numbers) [0] 와의 관련성 때문에 '이중 tensor(dual tensor)'라고 불립니다.
 
 순전파가 수행될 때, 입력 tensor 중 하나라도 이중 tensor이면 함수의 '민감도(sensitivity)'를 전파하기 위해 추가적인 연산이 수행됩니다.
 
@@ -121,7 +121,7 @@ class Fn(torch.autograd.Function):
     @staticmethod
     def forward(ctx, foo):
         result = torch.exp(foo)
-        # ``ctx`` 에 저장된 tensor는 이후의 순전파 기울기
+        # ``ctx`` 에 저장된 tensor는 이후의 순전파 변화도
         # 계산에 사용할 수 있습니다.
         ctx.result = result
         return result
@@ -144,10 +144,10 @@ def jvp(ctx, gI):
     dual_output = fn(dual_input)
     jvp = fwAD.unpack_dual(dual_output).tangent
 
-# 사용자 정의 autograd 함수가 기울기를 올바르게 계산하는지 확인하려면
+# 사용자 정의 autograd 함수가 변화도를 올바르게 계산하는지 확인하려면
 # ``autograd.gradcheck`` 를 사용하는 것이 중요합니다. 기본적으로
-# ``gradcheck`` 는 역전파 모드(reverse-mode) 자동 미분 기울기만 확인합니다.
-# ``check_forward_ad=True`` 를 지정하여 순전파 기울기도 확인하도록 할 수 있습니다.
+# ``gradcheck`` 는 역전파 모드(reverse-mode) 자동 미분 변화도만 확인합니다.
+# ``check_forward_ad=True`` 를 지정하여 순전파 변화도도 확인하도록 할 수 있습니다.
 # 만약 함수에 대한 역전파를 구현하지 않았다면, ``check_backward_ad=False``,
 # ``check_undefined_grad=False``, ``check_batched_grad=False`` 를 지정하여
 # ``gradcheck`` 가 역전파 모드 자동 미분이 필요한 테스트를 건너뛰도록 할 수 있습니다.