docs: 번역어 통일 - '파라미터'를 '매개변수'로 정정

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/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) 코드

beginner_source/fgsm_tutorial.py

@@ -56,7 +56,7 @@
 #
 # 그림으로부터, :math:`\mathbf{x}` 는 원본 입력 이미지가 "판다" 로 올바르게 분류된 것을 의미하고,
 # :math:`y` 는 :math:`\mathbf{x}` 를 위한 정답 라벨이며, :math:`\mathbf{\theta}` 는 모델의
-# 파라미터를, :math:`J(\mathbf{\theta}, \mathbf{x}, y)` 는 네트워크의 학습을 위해서 사용되는 손실을 나타냅니다.
+# 매개변수를, :math:`J(\mathbf{\theta}, \mathbf{x}, y)` 는 네트워크의 학습을 위해서 사용되는 손실을 나타냅니다.
 # 공격은 :math:`\nabla_{x} J(\mathbf{\theta}, \mathbf{x}, y)` 계산을 위해 입력 데이터에 변화도를 역전파합니다.
 # 그러고 나서, 변화도는 손실 값이 최대화되는 방향으로 (예를 들면, :math:`sign(\nabla_{x} J(\mathbf{\theta}, \mathbf{x}, y))` )
 # 작은 스텝(step) 만큼 (그림에서는 :math:`\epsilon` 혹은 :math:`0.007`) 입력 데이터에 적용됩니다.
@@ -166,7 +166,7 @@ def forward(self, x):
 # ~~~~~~~~~~~
 #
 # 이제 원래 입력을 교란시켜 적대적인 예를 만드는 함수를 정의 할 수 있습니다.
-# ``fgsm_attack`` 함수는 입력 파라미터로 3가지를 가집니다. 첫 번째는 원본 *이미지* ( :math:`x` ),
+# ``fgsm_attack`` 함수는 입력 매개변수로 3가지를 가집니다. 첫 번째는 원본 *이미지* ( :math:`x` ),
 # 두 번째는 *엡실론* 으로 픽셀 단위의 작은 변화를 주는 값입니다 ( :math:`\epsilon` ).
 # 마지막은 *data_grad* 로 입력 영상 ( :math:`\nabla_{x} J(\mathbf{\theta}, \mathbf{x}, y)` ) 에 대한 변화도 손실 값입니다.
 # 아래 식에 따른 작은 변화가 적용된 이미지를 생성합니다.

beginner_source/finetuning_torchvision_models_tutorial.py

@@ -538,7 +538,7 @@ def initialize_model(model_name, num_classes, feature_extract, use_pretrained=Tr
 # 사전 학습된 모델을 읽어 들인 후 구조를 재조정하기 전에
 # ``feature_extract=True``인 경우 매개변수의
 # 모든 ``.requires_grad`` 속성을 일일이 False로 설정한 것을 기억하세요.
-# 그러면 재초기화된 레이어의 파라미터는
+# 그러면 재초기화된 계층의 매개변수는
 # 기본적으로 ``.requires_grad=True``를 갖습니다.
 # 이제 *.requires_grad=True인 모든 매개변수가
 # 최적화되어야 한다는 것을 알았습니다.*

beginner_source/hyperparameter_tuning_tutorial.py

@@ -19,7 +19,7 @@
 아래와 같이 약간의 수정만 추가하면 됩니다.
 
 1. 함수에서 데이터 로딩 및 학습 부분을 감싸두고,
-2. 일부 네트워크 파라미터를 구성 가능하게 하고,
+2. 일부 네트워크 매개변수를 구성 가능하게 하고,
 3. 체크포인트를 추가하고 (선택 사항),
 4. 모델 튜닝을 위한 검색 공간을 정의합니다.
 
@@ -88,7 +88,7 @@ def load_data(data_dir="./data"):
 ######################################################################
 # 구성 가능한 신경망
 # ---------------------------
-# 구성 가능한 파라미터만 튜닝이 가능합니다.
+# 구성 가능한 매개변수만 튜닝이 가능합니다.
 # 이 예시를 통해 fully connected layer 크기를 지정할 수 있습니다:
 
 
@@ -349,7 +349,7 @@ def test_accuracy(net, device="cpu"):
 
 
 ######################################################################
-# 이 함수는 또한 ``device`` 파라미터를 요구하므로, test set 평가를 GPU에서 수행할 수 있습니다.
+# 이 함수는 또한 ``device`` 매개변수를 요구하므로, test set 평가를 GPU에서 수행할 수 있습니다.
 #
 # 검색 공간 구성
 # ----------------------------
@@ -365,13 +365,13 @@ def test_accuracy(net, device="cpu"):
 #     }
 #
 # ``tune.choice()`` 함수는 균일하게 샘플링된 값들의 목록을 입력으로 받습니다.
-# 위 예시에서 ``l1`` 및 ``l2`` 파라미터는 4와 256 사이의 2의 거듭제곱 값인 4, 8, 16, 32, 64, 128, 256 입니다.
+# 위 예시에서 ``l1`` 및 ``l2`` 매개변수는 4와 256 사이의 2의 거듭제곱 값인 4, 8, 16, 32, 64, 128, 256 입니다.
 # ``lr`` (학습률)은 0.0001과 0.1 사이에서 균일하게 샘플링 되어야 합니다. 마지막으로, 배치 크기는 2, 4, 8, 16중에서 선택할 수 있습니다.
 #
 # 각 실험에서, Ray Tune은 이제 이러한 검색 공간에서 매개변수 조합을 무작위로 샘플링합니다.
 # 그런 다음 여러 모델을 병렬로 훈련하고 이 중에서 가장 성능이 좋은 모델을 찾습니다. 또한 성능이 좋지 않은 실험을 조기에 종료하는 ``ASHAScheduler`` 를 사용합니다.
 #
-# 상수 ``data_dir`` 파라미터를 설정하기 위해 ``functools.partial`` 로 ``train_cifar`` 함수를 감싸둡니다. 또한 각 실험에 사용할 수 있는 자원들(resources)을 Ray Tune에 알릴 수 있습니다.
+# 상수 ``data_dir`` 매개변수를 설정하기 위해 ``functools.partial`` 로 ``train_cifar`` 함수를 감싸둡니다. 또한 각 실험에 사용할 수 있는 자원들(resources)을 Ray Tune에 알릴 수 있습니다.
 #
 # .. code-block:: python
 #

beginner_source/introyt/introyt1_tutorial.py

@@ -236,7 +236,7 @@ def num_flat_features(self, x):
 # 위에서 몇가지 중요한 일들이 일어나고 있습니다.
 #
 # 첫째, ``LeNet`` 클래스를 인스턴스화하고 ``net`` 객체를 출력합니다.
-# ``torch.nn.Module`` 의 하위 클래스는 생성된 레이어의 모양과 파라미터를 알려줍니다.
+# ``torch.nn.Module`` 의 하위 클래스는 생성된 계층의 모양과 매개변수를 알려줍니다.
 # 모델의 처리 결과를 얻으려는 경우, 모델의 편리한 기능을 제공할 수 있습니다.
 #
 # 아래에서 1 채널과 32x32 이미지크기를 가진 더미 입력을 생성합니다.
@@ -331,7 +331,7 @@ def num_flat_features(self, x):
 # ``torchvision.datasets.ImageFolder`` 와 같은 유틸리티 데이터셋 클래스가
 # 포함됩니다. 또한, ``Dataset`` 의 하위 클래스를 직접 만들 수 있습니다.
 #
-# 데이터셋을 인스턴스화할 때 몇 가지 파라미터를 선언해야 합니다.
+# 데이터셋을 인스턴스화할 때 몇 가지 매개변수를 선언해야 합니다.
 #
 # -  데이터를 저장하려는 파일 시스템 경로입니다.
 # -  데이터셋을 학습에 사용하는지 여부를 확인하여 대부분의 데이터셋은
@@ -350,7 +350,7 @@ def num_flat_features(self, x):
 # ``Dataset`` 하위 클래스는 데이터 접근에 대한 클래스를 포함하며, 해당 서브
 # 클래스가 제공하는 데이터 유형에 특화되어 있습니다.
 # ``DataLoader`` 는 데이터에 대해 *아무것도* 알지 못하지만
-# ``Dataset`` 이 제공하는 입력 tensor를 사용자가 지정한 파라미터로 구성합니다.
+# ``Dataset`` 이 제공하는 입력 tensor를 사용자가 지정한 매개변수로 구성합니다.
 #
 # 위 예제에서 ``DataLoader`` 에서에서 무작위 추출( ``shuffle=True`` )한 4개의
 # batch 이미지를 ``trainset`` 에서 추출하고 disk에서 데이터를 로드하기
@@ -503,7 +503,7 @@ def forward(self, x):
 # **optimizer** 는 학습의 필수요소입니다. 아래 예제에서 간단한 최적화 알고리즘인
 # *stochastic gradient descent* 를 구현하겠습니다. SGD 알고리즘은 학습 속도인
 # (``lr``) 및 momentum 과 같은 매개 변수 외에도 모델의 모든 학습 가중치 값인
-# ``net.parameters()`` 를 전달하는데, 이 함수는 최적화를 위해 파라미터를 조정합니다.
+# ``net.parameters()`` 를 전달하는데, 이 함수는 최적화를 위해 매개변수를 조정합니다.
 #
 # 마지막으로, 모든 것이 학습 loop에 들어갑니다. 이제 아래 셀을 실행하세요.
 # 실행 시 몇 분 정도 걸릴 수 있습니다:
@@ -516,7 +516,7 @@ def forward(self, x):
         # 데이터를 통해 이미지와 정답값을 받습니다.
         inputs, labels = data
 
-        # 초기 기울기 파라미터를 0으로 설정합니다
+        # 초기 기울기 매개변수를 0으로 설정합니다
         optimizer.zero_grad()
 
         # forward + backward + optimize
@@ -579,7 +579,7 @@ def forward(self, x):
 # 마지막 단계로 모델이 단순하게 학습 데이터셋을 “기억” 하는 것이 아니라
 # 실제로 *일반화* 학습을 잘 수행하고 있는 확인해야 합니다. 이를
 # **과적합** 이라 부르며 일반적으로 데이터셋이 너무 작거나, 모델이 데이터셋
-# 을 올바르게 모델링하는 데 필요한 것보다 더 많은 학습 파라미터 변수를
+# 을 올바르게 모델링하는 데 필요한 것보다 더 많은 학습 매개변수 변수를
 # 가지고 있음을 보여줍니다. (일반적인 학습에 충분한 예제가 아닙니다)
 #
 # 위와 같이 데이터셋이 학습 및 테스트 데이터셋으로 분할되는 이유입니다.

beginner_source/nlp/deep_learning_tutorial.py

@@ -88,7 +88,7 @@
 #
 
 # Pytorch에서 대부분의 비선형성은 torch.functional에 있습니다 ( F 로 가져옵니다)
-# 일반적으로 비선형성은 아핀맵과 같은 파라미터를 가지고 있지 않습니다.
+# 일반적으로 비선형성은 아핀맵과 같은 매개변수를 가지고 있지 않습니다.
 # 즉, 학습 중에 업데이트되는 가중치가 없습니다.
 data = torch.randn(2, 2)
 print(data)
@@ -129,7 +129,7 @@
 # 목적 함수는 네트워크가 최소화하도록 학습되는 함수입니다
 # ( *손실 함수* 또는 *비용 함수* 라고 함).
 # 먼저 학습 인스턴스를 선택하고 신경망을 통해 실행한 다음 출력의 손실을 계산합니다.
-# 그런 다음 손실 함수의 미분을 취함으로써 모델의 파라미터가 업데이트됩니다.
+# 그런 다음 손실 함수의 미분을 취함으로써 모델의 매개변수가 업데이트됩니다.
 # 직관적으로 모델이 자신의 대답에 완전히 확신하고 대답이 잘못되면 손실이 높아집니다.
 # 답변에 자신이 있고 답변이 맞으면 손실이 적습니다.
 #
@@ -151,9 +151,9 @@
 # 그럼 인스턴스에 대해 손실 함수를 계산할 수 있다는 것은 무엇입니까? 그걸 어떻게 할까요?
 # 우리는 이전에 Tensor가 그것을 계산하는데 사용된 것들에 해당하는 변화도를
 # 계산하는 방법을 알고 있다는 것을 보았습니다.
-# 손실은 Tensor이기 때문에 그것을 계산하는데 사용된 모든 파라미터와 관련하여
+# 손실은 Tensor이기 때문에 그것을 계산하는데 사용된 모든 매개변수와 관련하여
 # 변화도를 계산할 수 있습니다! 그런 다음 표준 변화도 업데이트를 수행 할 수 있습니다.
-# :math:`\theta` 가 우리의 파라미터라고 합시다.
+# :math:`\theta` 가 우리의 매개변수라고 합시다.
 # :math:`L(\theta)` 는 손실 함수, 그리고 :math:`\eta` 는 양의 러닝 레이트 입니다. 그러면
 #
 # .. math::  \theta^{(t+1)} = \theta^{(t)} - \eta \nabla_\theta L(\theta)
@@ -165,7 +165,7 @@
 # 필요가 없습니다. Torch는 torch.optim  패키지에서 많은 것을 제공하며
 # 완전히 공개되어 있습니다. 가장 단순한 변화도 업데이트 사용은
 # 더 복잡한 알고리즘을 사용하는 것과 동일합니다.
-# 다른 업데이트 알고리즘과 업데이트 알고리즘을 위한 다른 파라미터(다른 초기 러닝 레이트)를
+# 다른 업데이트 알고리즘과 업데이트 알고리즘을 위한 다른 매개변수(다른 초기 러닝 레이트)를
 # 시도해 보는 것은 네트워크의 성능을 최적화하는데 중요합니다.
 # 종종 기본 SGD를 Adam 또는 RMSprop 으로 교체하는 것이 눈에 띄게 성능
 # 향상 시킵니다.
@@ -183,7 +183,7 @@
 #
 # 모든 네트워크 구성 요소는 nn.Module에서 상속 받아 forward() 메서드를 재정의해야합니다.
 # 이것은 상용구에 관한 것입니다. nn.Module에서의 상속은 구성 요소에 기능을 제공합니다.
-# 예를 들어 그것은 학습 가능한 파라미터를 추적하도록 만들고,
+# 예를 들어 그것은 학습 가능한 매개변수를 추적하도록 만들고,
 # ``.to(device)`` 로 CPU와 GPU 를 교환할수 있습니다.
 # ``torch.device("cpu")`` 는 CPU 장치를 ``torch.device("cuda:0")`` 는 GPU 장치를 사용합니다.
 #
@@ -247,12 +247,12 @@ def __init__(self, num_labels, vocab_size):
         # 문법에 혼란스러워 하지 마시고 단지 항상 nn.Module 에서 수행하십시오.
         super(BoWClassifier, self).__init__()
 
-        # 필요한 파라미터를 정의 하십시오. 이 경우에는 아핀 매핑의 매개 변수 인 A와 b가 필요합니다.
+        # 필요한 매개변수를 정의 하십시오. 이 경우에는 아핀 매핑의 매개 변수 인 A와 b가 필요합니다.
         # Torch는 아핀 맵을 제공하는 nn.Linear()를 정의합니다
         # 입력 차원이 vocab_size이고 출력이 num_labels 인 이유를 이해했는지 확인하십시오!
         self.linear = nn.Linear(vocab_size, num_labels)
 
-        # 주의! 비선형성 Log Softmax에는 파라미터가 없습니다!
+        # 주의! 비선형성 Log Softmax에는 매개변수가 없습니다!
         # 그래서 여기에 대해 걱정할 필요가 없습니다.
 
     def forward(self, bow_vec):
@@ -275,11 +275,11 @@ def make_target(label, label_to_ix):
 
 model = BoWClassifier(NUM_LABELS, VOCAB_SIZE)
 
-# 모델은 자신의 파라미터를 알고 있습니다. 아래에 있는 첫번째 출력은 A 두번째는 b 입니다.
+# 모델은 자신의 매개변수를 알고 있습니다. 아래에 있는 첫번째 출력은 A 두번째는 b 입니다.
 # 모듈의 __init__ 함수에서 클래스 변수에 구성 요소를 할당 할 때마다 다음 행을 사용하여 완료합니다.
 # self.linear = nn.Linear(...)
 # 그런 다음 PyTorch 개발자의 Python 마법을 통해, 모듈(이 경우 BoWClassifier)은
-# nn.Linear 파라미터에 대한 지식을 저장합니다
+# nn.Linear 매개변수에 대한 지식을 저장합니다
 for param in model.parameters():
     print(param)
 
@@ -302,7 +302,7 @@ def make_target(label, label_to_ix):
 
 ######################################################################
 # 그럼 학습을 해봅시다! 이를 위해 로그 확률을 얻고, 손실 함수를 계산하고,
-# 손실 함수의 변화도를 계산한 다음 변화도 단계로 파라미터를
+# 손실 함수의 변화도를 계산한 다음 변화도 단계로 매개변수를
 # 업데이트하기 위해 인스턴스를 통과시킵니다.  손실 기능은 nn 패키지의 Torch에서 제공합니다.
 # nn.NLLLoss()는 원하는 음의 로그 우도 손실입니다. 또한 torch.optim에서 최적화 함수를 정의합니다.
 # 여기서는 SGD 만 사용합니다.
@@ -344,7 +344,7 @@ def make_target(label, label_to_ix):
         # 3 단계. 순전파를 실행합니다.
         log_probs = model(bow_vec)
 
-        # 4 단계. optimizer.step()을 호출하여 손실, 변화도를 계산하고 파라미터를 업데이트합니다.
+        # 4 단계. optimizer.step()을 호출하여 손실, 변화도를 계산하고 매개변수를 업데이트합니다.
         loss = loss_function(log_probs, target)
         loss.backward()
         optimizer.step()

intermediate_source/TP_tutorial.rst

@@ -38,7 +38,7 @@ Tensor Parallel (TP)는 기존 `Megatron-LM <https://arxiv.org/abs/1909.08053>`_
 **Sharding 초기화**
 
 * 각 계층에 어떤 ``ParallelStyle`` 을 적용할지 결정하고, ``parallelize_module`` 을 호출해서 초기화된 모듈을 샤딩합니다.
-* 병렬화된 모듈은 모델 파라미터를 DTensor로 교체하고, DTensor는 샤딩하는 연산을 사용하여 병렬화된 모듈을 실행하는 역할을 담당합니다.
+* 병렬화된 모듈은 모델 매개변수를 DTensor로 교체하고, DTensor는 샤딩하는 연산을 사용하여 병렬화된 모듈을 실행하는 역할을 담당합니다.
 
 **런타임 순방향/역방향**
 
@@ -138,7 +138,7 @@ PyTorch 네이티브 Tensor Parallel을 사용하여 다음과 같이 ``FeedForw
 
 Llama 모델의 경우, 어텐션 계층에서는 형태와 관련된 여러 뷰 연산이 있습니다. 구체적으로, ``wq`` / ``wk`` / ``wv`` 선형 계층에서 열 단위 병렬화의 경우, 활성화 tensor는  ``num_heads`` 차원에서 샤딩됩니다.
 
-마지막으로, 각 ``TransformerBlock`` 에 대한 계획을 효과적으로 실행하려면 ``parallelize_module`` API를 호출해야 합니다. 내부적으로는 ``Attention``  및  ``FeedForward`` 계층 내부 모델 파라미터를 DTensor에 분배하고, 필요하다면 모델 입력과 출력(각각 모듈 이전 및 이후)에 대한 통신 훅을 등록합니다.
+마지막으로, 각 ``TransformerBlock`` 에 대한 계획을 효과적으로 실행하려면 ``parallelize_module`` API를 호출해야 합니다. 내부적으로는 ``Attention``  및  ``FeedForward`` 계층 내부 모델 매개변수를 DTensor에 분배하고, 필요하다면 모델 입력과 출력(각각 모듈 이전 및 이후)에 대한 통신 훅을 등록합니다.
 
 .. code-block:: python
 

intermediate_source/ensembling.py

@@ -93,7 +93,7 @@ def forward(self, x):
 params, buffers = stack_module_state(models)
 
 ######################################################################
-# 다음으로, ``vmap`` 에 대한 함수를 정의해야 합니다. 이 함수는 파라미터, 버퍼, 입력값이 주어지면 모델을 실행합니다.
+# 다음으로, ``vmap`` 에 대한 함수를 정의해야 합니다. 이 함수는 매개변수, 버퍼, 입력값이 주어지면 모델을 실행합니다.
 # 여기서는 ``torch.func.functional_call`` 을 활용하겠습니다.
 
 from torch.func import functional_call