diff --git a/advanced_source/static_quantization_tutorial.rst b/advanced_source/static_quantization_tutorial.rst index e5f299859..4fc3db962 100644 --- a/advanced_source/static_quantization_tutorial.rst +++ b/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 아키텍처에서 양자화를 위한 권장 설정을 그대로 쓰기만 해도 됩니다. diff --git a/beginner_source/basics/optimization_tutorial.py b/beginner_source/basics/optimization_tutorial.py index d6d9ce9f7..391390320 100644 --- a/beginner_source/basics/optimization_tutorial.py +++ b/beginner_source/basics/optimization_tutorial.py @@ -15,7 +15,7 @@ 이제 모델과 데이터가 준비되었으니, 데이터에 매개변수를 최적화하여 모델을 학습하고, 검증하고, 테스트할 차례입니다. 모델을 학습하는 과정은 반복적인 과정을 거칩니다; 각 반복 단계에서 모델은 출력을 추측하고, 추측과 정답 사이의 오류(\ *손실(loss)*\ )를 계산하고, (`이전 장 `_\ 에서 본 것처럼) -매개변수에 대한 오류의 도함수(derivative)를 수집한 뒤, 경사하강법을 사용하여 이 파라미터들을 **최적화(optimize)**\ 합니다. +매개변수에 대한 오류의 도함수(derivative)를 수집한 뒤, 경사하강법을 사용하여 이 매개변수들을 **최적화(optimize)**\ 합니다. 이 과정에 대한 자세한 설명은 `3Blue1Brown의 역전파 `__ 영상을 참고하세요. 기본(Pre-requisite) 코드 diff --git a/beginner_source/fgsm_tutorial.py b/beginner_source/fgsm_tutorial.py index 5c0d93cc4..46e82ed5e 100644 --- a/beginner_source/fgsm_tutorial.py +++ b/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)` ) 에 대한 변화도 손실 값입니다. # 아래 식에 따른 작은 변화가 적용된 이미지를 생성합니다. diff --git a/beginner_source/finetuning_torchvision_models_tutorial.py b/beginner_source/finetuning_torchvision_models_tutorial.py index 68d0332cb..97f487677 100644 --- a/beginner_source/finetuning_torchvision_models_tutorial.py +++ b/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인 모든 매개변수가 # 최적화되어야 한다는 것을 알았습니다.* diff --git a/beginner_source/hyperparameter_tuning_tutorial.py b/beginner_source/hyperparameter_tuning_tutorial.py index 9bd3ab5bb..56c352654 100644 --- a/beginner_source/hyperparameter_tuning_tutorial.py +++ b/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 # diff --git a/beginner_source/introyt/introyt1_tutorial.py b/beginner_source/introyt/introyt1_tutorial.py index a56783a6a..0e846ceb7 100644 --- a/beginner_source/introyt/introyt1_tutorial.py +++ b/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): # 마지막 단계로 모델이 단순하게 학습 데이터셋을 “기억” 하는 것이 아니라 # 실제로 *일반화* 학습을 잘 수행하고 있는 확인해야 합니다. 이를 # **과적합** 이라 부르며 일반적으로 데이터셋이 너무 작거나, 모델이 데이터셋 -# 을 올바르게 모델링하는 데 필요한 것보다 더 많은 학습 파라미터 변수를 +# 을 올바르게 모델링하는 데 필요한 것보다 더 많은 학습 매개변수 변수를 # 가지고 있음을 보여줍니다. (일반적인 학습에 충분한 예제가 아닙니다) # # 위와 같이 데이터셋이 학습 및 테스트 데이터셋으로 분할되는 이유입니다. diff --git a/beginner_source/nlp/deep_learning_tutorial.py b/beginner_source/nlp/deep_learning_tutorial.py index d11fa52cc..4ae180bfd 100644 --- a/beginner_source/nlp/deep_learning_tutorial.py +++ b/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() diff --git a/intermediate_source/TP_tutorial.rst b/intermediate_source/TP_tutorial.rst index 3a55be8da..837c54428 100644 --- a/intermediate_source/TP_tutorial.rst +++ b/intermediate_source/TP_tutorial.rst @@ -38,7 +38,7 @@ Tensor Parallel (TP)는 기존 `Megatron-LM `_ **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 diff --git a/intermediate_source/ensembling.py b/intermediate_source/ensembling.py index e2d11dbf3..54a711894 100644 --- a/intermediate_source/ensembling.py +++ b/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 diff --git a/intermediate_source/pipeline_tutorial.py b/intermediate_source/pipeline_tutorial.py index 973f8ebb1..d1090ab91 100644 --- a/intermediate_source/pipeline_tutorial.py +++ b/intermediate_source/pipeline_tutorial.py @@ -27,7 +27,7 @@ # 이번 튜토리얼에서는, 트랜스포머 모델을 두 개의 GPU에 걸쳐서 나누고 파이프라인 병렬화로 학습시켜 보겠습니다. # 모델은 바로 `NN.TRANSFORMER 와 TORCHTEXT 로 시퀀스-투-시퀀스(SEQUENCE-TO-SEQUENCE) 모델링하기 # `__ 튜토리얼과 -# 똑같은 모델이지만 두 단계로 나뉩니다. 대부분 파라미터(parameter)들은 +# 똑같은 모델이지만 두 단계로 나뉩니다. 대부분 매개변수(parameter)들은 # `nn.TransformerEncoder `__ 계층(layer)에 포함됩니다. # `nn.TransformerEncoder `__ 는 # `nn.TransformerEncoderLayer `__ 의 ``nlayers`` 로 구성되어 있습니다. @@ -220,7 +220,7 @@ def get_batch(source, i): # 트랜스포머 계층 규모를 적절히 확장시킵니다. 4096차원의 임베딩 벡터, 4096의 은닉 사이즈, # 16개의 어텐션 헤드(attention head)와 총 12 개의 트랜스포머 계층 # (``nn.TransformerEncoderLayer``)를 사용합니다. 이는 최대 -# **1.4억** 개의 파라미터를 갖는 모델을 생성합니다. +# **1.4억** 개의 매개변수를 갖는 모델을 생성합니다. # # Pipe는 `RRef `__ 를 통해 # `RPC 프레임워크 `__ 에 의존하는데 diff --git a/intermediate_source/pruning_tutorial.py b/intermediate_source/pruning_tutorial.py index cb3556281..11db90761 100644 --- a/intermediate_source/pruning_tutorial.py +++ b/intermediate_source/pruning_tutorial.py @@ -6,14 +6,14 @@ **Author**: `Michela Paganini `_ **번역**: `안상준 `_ -최첨단 딥러닝 모델들은 굉장히 많은 수의 파라미터값들로 구성되기 때문에, 쉽게 배포하기가 어렵습니다. +최첨단 딥러닝 모델들은 굉장히 많은 수의 매개변수값들로 구성되기 때문에, 쉽게 배포하기가 어렵습니다. 이와 반대로, 생물학적 신경망들은 효율적으로 희소하게 연결된 것으로 알려져 있습니다. -모델의 정확도를 훼손하지 않으면서 모델에 포함된 파라미터 수를 줄여 압축하는 최적의 기법을 파악하는 것은 +모델의 정확도를 훼손하지 않으면서 모델에 포함된 매개변수 수를 줄여 압축하는 최적의 기법을 파악하는 것은 메모리, 배터리, 하드웨어 소비량을 줄일 수 있기 때문에 중요합니다. 그럼으로서 기기에 경량화된 모델을 배포하여 개개인이 사용하고 있는 기기에서 연산을 수행하여 프라이버시를 보장할 수 있기 때문입니다. -연구 측면에서는, 가지치기 기법은 굉장히 많은 수의 파라미터 값들로 구성된 모델과 -굉장히 적은 수의 파라미터 값들로 구성된 모델 간 학습 역학 차이를 조사하는데 주로 이용되기도 하며, -하위 신경망 모델과 파라미터 값들의 초기화가 운이 좋게 잘 된 케이스("`lottery tickets `_")를 +연구 측면에서는, 가지치기 기법은 굉장히 많은 수의 매개변수 값들로 구성된 모델과 +굉장히 적은 수의 매개변수 값들로 구성된 모델 간 학습 역학 차이를 조사하는데 주로 이용되기도 하며, +하위 신경망 모델과 매개변수 값들의 초기화가 운이 좋게 잘 된 케이스("`lottery tickets `_")를 파괴적 신경망 구조 탐색 관점에서 살펴보는 등 여러 연구 목적으로 사용합니다. 이번 튜토리얼에서는, ``torch.nn.utils.prune`` 을 사용하여 여러분이 설계한 딥러닝 모델에 대해 가지치기 기법을 적용해보는 것을 배워보고, @@ -68,7 +68,7 @@ def forward(self, x): # ----------------- # # 가지치기 기법이 적용되지 않은 LeNet 모델의 ``conv1`` 층을 점검해봅시다. -# 여기에는 2개의 파라미터값들인 ``가중치`` 값과 ``편향`` 값이 포함될 것이며, 버퍼는 존재하지 않을 것입니다. +# 여기에는 2개의 매개변수값들인 ``가중치`` 값과 ``편향`` 값이 포함될 것이며, 버퍼는 존재하지 않을 것입니다. # module = model.conv1 @@ -85,7 +85,7 @@ def forward(self, x): # 첫 번째로는, ``torch.nn.utils.prune`` (또는 ``BasePruningMethod`` 의 서브 클래스로 직접 # `구현 `_ ) # 내 존재하는 가지치기 기법을 선택합니다. -# 그 후, 해당 모듈 내에서 가지치기 기법을 적용하고자 하는 모듈과 파라미터를 지정합니다. +# 그 후, 해당 모듈 내에서 가지치기 기법을 적용하고자 하는 모듈과 매개변수를 지정합니다. # 마지막으로, 가지치기 기법에 적당한 키워드 인자값을 이용하여 가지치기 매개변수를 지정합니다. # 이번 예제에서는, ``conv1`` 층의 가중치의 30%값들을 랜덤으로 가지치기 기법을 적용해보겠습니다. # 모듈은 함수에 대한 첫 번째 인자값으로 전달되며, ``name`` 은 문자열 식별자를 이용하여 해당 모듈 내 매개변수를 구분합니다. @@ -95,14 +95,14 @@ def forward(self, x): prune.random_unstructured(module, name="weight", amount=0.3) ###################################################################### -# 가지치기 기법은 가중치값들을 파라미터값들로부터 제거하고 ``weight_orig`` (즉, 초기 가중치 이름에 "_orig"을 붙인) 이라는 -# 새로운 파라미터값으로 대체하는 것으로 실행됩니다. +# 가지치기 기법은 가중치값들을 매개변수값들로부터 제거하고 ``weight_orig`` (즉, 초기 가중치 이름에 "_orig"을 붙인) 이라는 +# 새로운 매개변수값으로 대체하는 것으로 실행됩니다. # ``weight_orig`` 은 텐서값에 가지치기 기법이 적용되지 않은 상태를 저장합니다. # ``bias`` 은 가지치기 기법이 적용되지 않았기 때문에 그대로 남아 있습니다. print(list(module.named_parameters())) ###################################################################### -# 위에서 선택한 가지치기 기법에 의해 생성되는 가지치기 마스크는 초기 파라미터 ``name`` 에 ``weight_mask`` +# 위에서 선택한 가지치기 기법에 의해 생성되는 가지치기 마스크는 초기 매개변수 ``name`` 에 ``weight_mask`` # (즉, 초기 가중치 이름에 "_mask"를 붙인) 이름의 모듈 버퍼로 저장됩니다. print(list(module.named_buffers())) @@ -116,20 +116,20 @@ def forward(self, x): ###################################################################### # 최종적으로, 가지치기 기법은 파이토치의 ``forward_pre_hooks`` 를 이용하여 각 순전파가 진행되기 전에 가지치기 기법이 적용됩니다. # 구체적으로, 지금까지 진행한 것 처럼, 모듈이 가지치기 기법이 적용되었을 때, -# 가지치기 기법이 적용된 각 파라미터값들이 ``forward_pre_hook`` 를 얻게됩니다. -# 이러한 경우, ``weight`` 이름인 기존 파라미터값에 대해서만 가지치기 기법을 적용하였기 때문에, +# 가지치기 기법이 적용된 각 매개변수값들이 ``forward_pre_hook`` 를 얻게됩니다. +# 이러한 경우, ``weight`` 이름인 기존 매개변수값에 대해서만 가지치기 기법을 적용하였기 때문에, # 훅은 오직 1개만 존재할 것입니다. print(module._forward_pre_hooks) ###################################################################### # 완결성을 위해, 편향값에 대해서도 가지치기 기법을 적용할 수 있으며, -# 모듈의 파라미터, 버퍼, 훅, 속성값들이 어떻게 변경되는지 확인할 수 있습니다. +# 모듈의 매개변수, 버퍼, 훅, 속성값들이 어떻게 변경되는지 확인할 수 있습니다. # 또 다른 가지치기 기법을 적용해보기 위해, ``l1_unstructured`` 가지치기 함수에서 구현된 내용과 같이, # L1 Norm 값이 가장 작은 편향값 3개를 가지치기를 시도해봅시다. prune.l1_unstructured(module, name="bias", amount=3) ###################################################################### -# 이전에서 실습한 내용을 토대로, 명명된 파라미터값들이 ``weight_orig``, ``bias_orig`` 2개를 모두 포함할 것이라 예상할 수 있습니다. +# 이전에서 실습한 내용을 토대로, 명명된 매개변수값들이 ``weight_orig``, ``bias_orig`` 2개를 모두 포함할 것이라 예상할 수 있습니다. # 버퍼들은 ``weight_mask``, ``bias_mask`` 2개를 포함할 것입니다. # 가지치기 기법이 적용된 2개의 텐서값들은 모듈의 속성값으로 존재할 것이며, 모듈은 2개의 ``forward_pre_hooks`` 을 갖게 될 것입니다. print(list(module.named_parameters())) @@ -147,7 +147,7 @@ def forward(self, x): # 가지치기 기법 반복 적용 # ------------------------------------ # -# 모듈 내 같은 파라미터값에 대해 가지치기 기법이 여러번 적용될 수 있으며, 다양한 가지치기 기법의 조합이 적용된 것과 동일하게 적용될 수 있습니다. +# 모듈 내 같은 매개변수값에 대해 가지치기 기법이 여러번 적용될 수 있으며, 다양한 가지치기 기법의 조합이 적용된 것과 동일하게 적용될 수 있습니다. # 새로운 마스크와 이전의 마스크의 결합은 ``PruningContainer`` 의 ``compute_mask`` 메소드를 통해 처리할 수 있습니다. # # 예를 들어, 만약 ``module.weight`` 값에 가지치기 기법을 적용하고 싶을 때, 텐서의 0번째 축의 L2 norm값을 기준으로 구조화된 가지치기 기법을 적용합니다. @@ -170,23 +170,23 @@ def forward(self, x): ###################################################################### # 가지치기 기법이 적용된 모델의 직렬화 # --------------------------------------------- -# 마스크 버퍼들과 가지치기 기법이 적용된 텐서 계산에 사용된 기존의 파라미터를 포함하여 관련된 모든 텐서값들은 +# 마스크 버퍼들과 가지치기 기법이 적용된 텐서 계산에 사용된 기존의 매개변수를 포함하여 관련된 모든 텐서값들은 # 필요한 경우 모델의 ``state_dict`` 에 저장되기 때문에, 쉽게 직렬화하여 저장할 수 있습니다. print(model.state_dict().keys()) ###################################################################### -# 가지치기 기법의 재-파라미터화 제거 +# 가지치기 기법의 재-매개변수화 제거 # ----------------------------------------- # -# 가지치기 기법이 적용된 것을 영구적으로 만들기 위해서, 재-파라미터화 관점의 +# 가지치기 기법이 적용된 것을 영구적으로 만들기 위해서, 재-매개변수화 관점의 # ``weight_orig`` 와 ``weight_mask`` 값을 제거하고, ``forward_pre_hook`` 값을 제거합니다. # 제거하기 위해 ``torch.nn.utils.prune`` 내 ``remove`` 함수를 이용할 수 있습니다. # 가지치기 기법이 적용되지 않은 것처럼 실행되는 것이 아닌 점을 주의하세요. -# 이는 단지 가지치기 기법이 적용된 상태에서 가중치 파라미터값을 모델 파라미터값으로 재할당하는 것을 통해 영구적으로 만드는 것일 뿐입니다. +# 이는 단지 가지치기 기법이 적용된 상태에서 가중치 매개변수값을 모델 매개변수값으로 재할당하는 것을 통해 영구적으로 만드는 것일 뿐입니다. ###################################################################### -# 재-파라미터화를 제거하기 전 상태 +# 재-매개변수화를 제거하기 전 상태 print(list(module.named_parameters())) ###################################################################### print(list(module.named_buffers())) @@ -194,17 +194,17 @@ def forward(self, x): print(module.weight) ###################################################################### -# 재-파라미터를 제거한 후 상태 +# 재-매개변수를 제거한 후 상태 prune.remove(module, 'weight') print(list(module.named_parameters())) ###################################################################### print(list(module.named_buffers())) ###################################################################### -# 모델 내 여러 파라미터값들에 대하여 가지치기 기법 적용 +# 모델 내 여러 매개변수값들에 대하여 가지치기 기법 적용 # ---------------------------------------------------------- # -# 가지치기 기법을 적용하고 싶은 파라미터값들을 지정함으로써, 이번 예제에서 볼 수 있는 것 처럼, +# 가지치기 기법을 적용하고 싶은 매개변수값들을 지정함으로써, 이번 예제에서 볼 수 있는 것 처럼, # 신경망 모델 내 여러 텐서값들에 대해서 쉽게 가지치기 기법을 적용할 수 있습니다. new_model = LeNet() @@ -310,12 +310,12 @@ def forward(self, x): # (지원되는 옵션은 ``global``, ``structured``, ``unstructured`` 입니다.) # 이러한 방식은, 가지치기 기법을 반복적으로 적용해야 하는 경우 마스크를 결합하는 방법을 결정하기 위해 필요합니다. # 즉, 이미 가지치기 기법이 적용된 모델에 대해서 가지치기 기법을 적용할 때, -# 기존의 가지치기 기법이 적용되지 않은 파라미터 값에 대해 가지치기 기법이 영향을 미칠 것으로 예상됩니다. -# ``PRUNING_TYPE`` 을 지정한다면, 가지치기 기법을 적용하기 위해 파라미터 값을 올바르게 제거하는 +# 기존의 가지치기 기법이 적용되지 않은 매개변수 값에 대해 가지치기 기법이 영향을 미칠 것으로 예상됩니다. +# ``PRUNING_TYPE`` 을 지정한다면, 가지치기 기법을 적용하기 위해 매개변수 값을 올바르게 제거하는 # ``PruningContainer`` (마스크 가지치기 기법을 반복적으로 적용하는 것을 처리하는)를 가능하게 합니다. # 예를 들어, 다른 모든 항목이 존재하는 텐서를 가지치기 기법을 구현하고 싶을 때, # (또는, 텐서가 이전에 가지치기 기법에 의해 제거되었거나 남아있는 텐서에 대해) -# 한 층의 개별 연결에 작용하며 전체 유닛/채널 (``'structured'``), 또는 다른 파라미터 간 +# 한 층의 개별 연결에 작용하며 전체 유닛/채널 (``'structured'``), 또는 다른 매개변수 간 # (``'global'``) 연결에는 작용하지 않기 때문에 ``PRUNING_TYPE='unstructured'`` 방식으로 진행됩니다. class FooBarPruningMethod(prune.BasePruningMethod): @@ -333,15 +333,15 @@ def compute_mask(self, t, default_mask): # ``nn.Module`` 의 매개변수에 적용하기 위해 인스턴스화하고 적용하는 간단한 기능을 구현해봅니다. def foobar_unstructured(module, name): """ - 텐서 내 다른 모든 항목들을 제거하여 `module` 에서 `name` 이라는 파라미터에 대해 가자치기 기법을 적용 + 텐서 내 다른 모든 항목들을 제거하여 `module` 에서 `name` 이라는 매개변수에 대해 가자치기 기법을 적용 다음 내용에 따라 모듈을 수정 (또는 수정된 모듈을 반환): 1) 가지치기 기법에 의해 매개변수 `name` 에 적용된 이진 마스크에 해당하는 명명된 버퍼 `name+'_mask'` 를 추가합니다. - `name` 파라미터는 가지치기 기법이 적용된 것으로 대체되며, 가지치기 기법이 적용되지 않은 - 기존의 파라미터는 `name+'_orig'` 라는 이름의 새로운 매개변수에 저장됩니다. + `name` 매개변수는 가지치기 기법이 적용된 것으로 대체되며, 가지치기 기법이 적용되지 않은 + 기존의 매개변수는 `name+'_orig'` 라는 이름의 새로운 매개변수에 저장됩니다. 인자값: module (nn.Module): 가지치기 기법을 적용해야 하는 텐서를 포함하는 모듈 - name (string): 모듈 내 가지치기 기법이 적용될 파라미터의 이름 + name (string): 모듈 내 가지치기 기법이 적용될 매개변수의 이름 반환값: module (nn.Module): 입력 모듈에 대해서 가지치기 기법이 적용된 모듈 diff --git a/intermediate_source/spatial_transformer_tutorial.py b/intermediate_source/spatial_transformer_tutorial.py index 612e7d528..72aa1d865 100644 --- a/intermediate_source/spatial_transformer_tutorial.py +++ b/intermediate_source/spatial_transformer_tutorial.py @@ -72,12 +72,12 @@ # # STN은 다음의 세 가지 주요 구성 요소로 요약됩니다. # -# - 위치 결정 네트워크(localization network)는 공간 변환 파라미터를 예측(regress) +# - 위치 결정 네트워크(localization network)는 공간 변환 매개변수를 예측(regress) # 하는 일반적인 CNN 입니다. 공간 변환은 데이터 셋으로부터 명시적으로 학습되지 않고, # 신경망이 전체 정확도를 향상 시키도록 공간 변환을 자동으로 학습합니다. # - 그리드 생성기(grid generator)는 출력 이미지로부터 각 픽셀에 대응하는 입력 # 이미지 내 좌표 그리드를 생성합니다. -# - 샘플러(sampler)는 공간 변환 파라미터를 입력 이미지에 적용합니다. +# - 샘플러(sampler)는 공간 변환 매개변수를 입력 이미지에 적용합니다. # # .. figure:: /_static/img/stn/stn-arch.png # diff --git a/recipes_source/compiling_optimizer.rst b/recipes_source/compiling_optimizer.rst index 8296d6dc7..176c4484a 100644 --- a/recipes_source/compiling_optimizer.rst +++ b/recipes_source/compiling_optimizer.rst @@ -5,7 +5,7 @@ **번역:** `김승환 `_ 옵티마이저는 딥러닝 모델을 훈련하는 핵심 알고리즘입니다. -모든 모델 파라미터를 업데이트하는 역할을 하기 때문에, 대규모 모델에서는 종종 훈련 성능의 병목이 될 수 있습니다. +모든 모델 매개변수를 업데이트하는 역할을 하기 때문에, 대규모 모델에서는 종종 훈련 성능의 병목이 될 수 있습니다. 이 레시피에서는 옵티마이저에 ``torch.compile``을 적용하여 GPU 성능 향상을 관찰해보겠습니다. .. note:: @@ -16,7 +16,7 @@ ~~~~~~~~~~~~~~~~~~~~~ 이 예제에서는 간단한 선형 계층의 시퀀스를 사용할 것입니다. 우리는 옵티마이저의 성능만 벤치마킹할 것이기 때문에, 모델의 선택은 중요하지 않습니다. -옵티마이저의 성능은 파라미터의 수에 따라 달라지기 때문입니다. +옵티마이저의 성능은 매개변수의 수에 따라 달라지기 때문입니다. 사용하는 머신에 따라 정확한 결과는 다를 수 있습니다. diff --git a/recipes_source/recipes/amp_recipe.py b/recipes_source/recipes/amp_recipe.py index 35105687d..adfd35069 100644 --- a/recipes_source/recipes/amp_recipe.py +++ b/recipes_source/recipes/amp_recipe.py @@ -198,7 +198,7 @@ def make_model(in_size, out_size, num_layers): # 변화도 확인/수정하기 (예: 클리핑) # -------------------------- # ``scaler.scale(loss).backward()`` 로 생성된 모든 변화도는 조정됩니다. -# 만약 ``backward()`` 와 ``scaler.step(optimizer)`` 사이에서 파라미터의 +# 만약 ``backward()`` 와 ``scaler.step(optimizer)`` 사이에서 매개변수의 # ``.grad`` 속성을 수정하거나 확인하고 싶다면, 먼저 # `scaler.unscale_(optimizer) `_ # 를 사용하여 변화도를 복원해야 합니다. @@ -210,10 +210,10 @@ def make_model(in_size, out_size, num_layers): loss = loss_fn(output, target) scaler.scale(loss).backward() - # 옵티마이저에 할당된 파라미터의 변화도를 제자리에서 복원합니다. + # 옵티마이저에 할당된 매개변수의 변화도를 제자리에서 복원합니다. scaler.unscale_(opt) - # 옵티마이저에 할당된 파라미터의 변화도가 이제 복원되었으므로, 평소와 같이 클리핑할 수 있습니다. + # 옵티마이저에 할당된 매개변수의 변화도가 이제 복원되었으므로, 평소와 같이 클리핑할 수 있습니다. # 이때 클리핑에 사용하는 max_norm 값은 변화도 조정이 없을 때와 동일하게 사용할 수 있습니다. torch.nn.utils.clip_grad_norm_(net.parameters(), max_norm=0.1) diff --git a/recipes_source/recipes/tuning_guide.py b/recipes_source/recipes/tuning_guide.py index c2e19a5e8..d312f0dbe 100644 --- a/recipes_source/recipes/tuning_guide.py +++ b/recipes_source/recipes/tuning_guide.py @@ -481,10 +481,10 @@ def gelu(x): # ``DistributedDataParallel(find_unused_parameters=True)`` 를 사용할 때 생성자와 실행 레이어 순서를 일치시키는 방법 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # `torch.nn.parallel.DistributedDataParallel `_ -# 은 ``find_unused_parameters=True`` 와 함께 모델 생성자에서의 레이어와 파라미터 순서를 +# 은 ``find_unused_parameters=True`` 와 함께 모델 생성자에서의 계층과 매개변수 순서를 # 사용하여 ``DistributedDataParallel`` 변화도 all-reduce를 위한 버킷을 만듭니다. # ``DistributedDataParallel`` 은 all-reduce를 역전파와 겹치게 수행합니다. 특정 버킷에 대한 -# all-reduce는 주어진 버킷의 모든 파라미터에 대한 변화도가 모두 준비되었을 때 비동기적으로 작동됩니다. +# all-reduce는 주어진 버킷의 모든 매개변수에 대한 변화도가 모두 준비되었을 때 비동기적으로 작동됩니다. # # 최대로 겹치게 하려면 모델 생성자에서의 순서가 실제 실행 중인 순서와 대략적으로 일치해야 합니다. # 순서가 맞지 않으면 전체 버킷에 대한 all-reduce는 마지막으로 도착하는 변화도를 기다리게 되며, @@ -493,8 +493,8 @@ def gelu(x): # # ``find_unused_parameters=False`` 가 (기본 설정)인 ``DistributedDataParallel`` 은 # 역전파 중에 발견된 연산 순서를 기반으로 자동으로 버킷을 형성합니다. -# ``find_unused_parameters=False`` 를 사용할 때는 최적의 성능을 달성하기 위해 레이어나 -# 파라미터의 순서를 재조정할 필요가 없습니다. +# ``find_unused_parameters=False`` 를 사용할 때는 최적의 성능을 달성하기 위해 계층이나 +# 매개변수의 순서를 재조정할 필요가 없습니다. ############################################################################### # 분산 설정에서 작업 부하를 분산하는 방법 diff --git a/recipes_source/recipes/zeroing_out_gradients.py b/recipes_source/recipes/zeroing_out_gradients.py index 7cae928ac..cc5550484 100644 --- a/recipes_source/recipes/zeroing_out_gradients.py +++ b/recipes_source/recipes/zeroing_out_gradients.py @@ -149,7 +149,7 @@ def forward(self, x): # 입력 받기: 데이터는 [inputs, labels] 형태의 리스트 inputs, labels = data - # 파라미터 변화도를 0으로 만들기 + # 매개변수 변화도를 0으로 만들기 optimizer.zero_grad() # 순전파 + 역전파 + 최적화 @@ -170,7 +170,7 @@ def forward(self, x): ###################################################################### # ``model.zero_grad()`` 를 사용해도 변화도를 0으로 만들 수 있습니다. -# 이는 옵티마이저에 모든 모델 파라미터가 포함되는 한 ``optimizer.zero_grad()`` 를 +# 이는 옵티마이저에 모든 모델 매개변수가 포함되는 한 ``optimizer.zero_grad()`` 를 # 사용하는 것과 동일합니다. 어떤 것을 사용할 것인지 최선의 선택을 하기 바랍니다. # # 축하합니다! 이제 PyTorch에서 변화도를 0으로 만들 수 있습니다.