docs: 번역어 통일 - '훈련'을 '학습'으로 변경

Author: rltq

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::
@@ -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,7 +367,7 @@ 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`` 를 만들고 최적화 할 텐서로 이미지를 전달합니다.
 #
 

beginner_source/basics/autogradqs_tutorial.py

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

beginner_source/dcgan_faces_tutorial.py

@@ -496,7 +496,7 @@ def forward(self, input):
 # **Part 1 - 구분자의 학습**
 #
 # 구분자의 목적은 주어진 입력값이 진짜인지 가짜인지 판별하는 것임을 상기합시다.
-# Goodfellow의 말을 빌리자면, 구분자는 “변화도(gradient)를 상승(ascending)시키며 훈련”하게 됩니다.
+# Goodfellow의 말을 빌리자면, 구분자는 “변화도(gradient)를 상승(ascending)시키며 학습”하게 됩니다.
 # 실전적으로 얘기하면, :math:`log(D(x)) + log(1-D(G(z)))` 를 최대화시키는 것과 같습니다.
 # `ganhacks <https://github.com/soumith/ganhacks>`__ 에서 미니 배치(mini-batch)를 분리하여 사용한 개념을 가져와서,
 # 우리 역시 두 가지 스텝으로 분리해 계산을 해보겠습니다. 먼저,
@@ -517,7 +517,7 @@ def forward(self, input):
 # 바꿈으로써 :math:`log(x)` 라는 ``BCELoss`` 의 일부분을 사용할 수 있게 합니다 (앞서 우리는 BCELoss에서 라벨을 이용해 원하는 로그 계산
 # 요소를 고를 수 있음을 알아봤습니다).
 #
-# 마무리로 G의 훈련 상태를 알아보기 위하여, 몇가지 통계적인 수치들과, fixed_noise를 통과시킨
+# 마무리로 G의 학습 상태를 알아보기 위하여, 몇가지 통계적인 수치들과, fixed_noise를 통과시킨
 # 결과를 화면에 출력하는 코드를 추가하겠습니다. 이때 통계적인 수치들이라 함은:
 #
 # -  **Loss_D** - 진짜 데이터와 가짜 데이터들 모두에서 구해진 손실값. (:math:`log(D(x)) + log(1 - D(G(z)))`).
@@ -598,7 +598,7 @@ def forward(self, input):
         # G를 업데이트 합니다
         optimizerG.step()
 
-        # 훈련 상태를 출력합니다
+        # 학습 상태를 출력합니다
         if i % 50 == 0:
             print('[%d/%d][%d/%d]\tLoss_D: %.4f\tLoss_G: %.4f\tD(x): %.4f\tD(G(z)): %.4f / %.4f'
                   % (epoch, num_epochs, i, len(dataloader),
@@ -689,7 +689,7 @@ def forward(self, input):
 # 무엇을 더 시도해볼 수 있을까요?
 #
 # -  결과물이 얼마나 더 좋아지는지 확인해보기 위해서 학습시간을 늘려볼 수 있습니다
-# -  다른 데이터셋을 이용해 훈련시켜보거나, 이미지의 사이즈를 다르게 해보거나, 아키텍쳐의 구성을 바꿔볼 수도 있습니다
+# -  다른 데이터셋을 이용해 학습시켜보거나, 이미지의 사이즈를 다르게 해보거나, 아키텍쳐의 구성을 바꿔볼 수도 있습니다
 # -  `여기 <https://github.com/nashory/gans-awesome-applications>`__ 에서 더욱 멋진 GAN 프로젝트들을 찾을수도 있죠
 # -  `음악 <https://www.deepmind.com/blog/wavenet-a-generative-model-for-raw-audio/>`__ 을 작곡하는 GAN도 만들 수 있습니다
 #

beginner_source/fgsm_tutorial.py

@@ -8,7 +8,7 @@
 
 이 글을 읽고 있다면, 여러분은 이미 머신러닝 모델이 얼마나 효과적인지 그 진가를 알고 있을 것입니다.
 머신 러닝 연구는 ML(Machine Learning) 모델을 더욱 빠르고 정확하며 효율적이게 하는 방향으로 진행 되고 있습니다.
-그러나 모델을 속이려하는 적에 대한 보안과 견고함은 모델을 설계하고 훈련할 때 종종 간과되는 부분입니다.
+그러나 모델을 속이려하는 적에 대한 보안과 견고함은 모델을 설계하고 학습할 때 종종 간과되는 부분입니다.
 
 이 튜토리얼은 ML 모델들의 보안 취약점에 대한 인식을 높이고, 요즘 화두가 되고있는 적대적 머신 러닝에 대한 통찰력을 제공할 것입니다.
 이미지에 눈치챌 수 없는 작은 변화(perturbation)를 추가하면 모델 성능이 크게 달라질 수 있다는 사실에 놀랄 수 있습니다.

beginner_source/finetuning_torchvision_models_tutorial.py

@@ -32,10 +32,10 @@
 #
 # 일반적으로 두 전이 학습 방법 모두 몇 가지 단계를 동일하게 따릅니다.
 #
-# - 사전 훈련된 모델을 초기화합니다.
+# - 사전 학습된 모델을 초기화합니다.
 # - 최종 계층을 재구성하여 새 데이터 집합의 클래스 수와 동일한 수의 출력을 갖도록 합니다.
 # - 새 데이터셋의 클래스 수와 동일한 출력 수를 갖도록 최종 계층을 재구성합니다.
-# - 훈련 중에 업데이트할 매개변수를 최적화 알고리즘에 맞게 정의합니다.
+# - 학습 중에 업데이트할 매개변수를 최적화 알고리즘에 맞게 정의합니다.
 # - 학습 단계를 실행합니다.
 #
 
@@ -75,9 +75,9 @@
 #    [resnet, alexnet, vgg, squeezenet, densenet, inception]
 #
 # 다른 입력은 다음과 같습니다. ``num_classes`` 은 데이터셋의 클래스 수,
-# ``batch_size`` 는 훈련에 사용되는 배치 크기로
+# ``batch_size`` 는 학습에 사용되는 배치 크기로
 # 모델의 성능에 따라 조정할 수 있으며,
-# ``num_epochs`` 는 실행하려는 훈련 에폭 수,
+# ``num_epochs`` 는 실행하려는 학습 에폭 수,
 # ``feature_extract`` 는 미세 조정 또는 특징 추출 여부를 정의하는 부울(boolean)입니다.
 # ``feature_extract = False``이면 모델이 미세 조정되고
 # 모든 모델의 매개변수가 업데이트됩니다.
@@ -94,10 +94,10 @@
 # 데이터 집합의 클래스 수
 num_classes = 2
 
-# 훈련을 위한 배치 크기 (메모리 용량에 따라 변경됩니다.)
+# 학습을 위한 배치 크기 (메모리 용량에 따라 변경됩니다.)
 batch_size = 8
 
-# 훈련할 에폭 수
+# 학습할 에폭 수
 num_epochs = 15
 
 # 특징 추출을 위한 플래그(flag)입니다. False일 경우, 전체 모델을 미세 조정하고
@@ -112,12 +112,12 @@
 # 모델을 조정하는 코드를 작성하기 전에
 # 몇 가지 도우미 함수(Helper Functions)를 정의해 보겠습니다.
 #
-# 모델 훈련 및 검증 코드
+# 모델 학습 및 검증 코드
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #
 # ``train_model`` 함수는 주어진 모델의 학습과 검증을 처리합니다.
 # 이 함수는 PyTorch 모델, 데이터로더(dataloader) 딕셔너리, 손실 함수,
-# 옵티마이저, 훈련 및 검증을 위해 정해진 에폭 수,
+# 옵티마이저, 학습 및 검증을 위해 정해진 에폭 수,
 # 그리고 Inception 모델일 때를 나타내는 부울 플래그(boolean flag)를 입력으로 받습니다.
 # 이 아키텍처는 보조(auxiliary) 출력을 사용하고, 전체 모델 손실은
 # `여기 <https://discuss.pytorch.org/t/how-to-optimize-inception-model-with-auxiliary-classifiers/7958>`__ 에 설명된 대로
@@ -127,7 +127,7 @@
 # 각 에폭이 끝난 후 전체 검증 단계를 실행합니다.
 # 또한, 검증 정확도 측면에서 가장 성능이 좋은 모델을 추적하고
 # 학습이 끝나면 해당 모델을 반환합니다.
-# 각 에폭이 끝나면 훈련 및 검증 정확도를 볼 수 있습니다.
+# 각 에폭이 끝나면 학습 및 검증 정확도를 볼 수 있습니다.
 #
 
 def train_model(model, dataloaders, criterion, optimizer, num_epochs=25, is_inception=False):
@@ -161,7 +161,7 @@ def train_model(model, dataloaders, criterion, optimizer, num_epochs=25, is_ince
                 optimizer.zero_grad()
 
                 # 순방향
-                # 훈련 하는 동안만 기록을 추적합니다.
+                # 학습 하는 동안만 기록을 추적합니다.
                 with torch.set_grad_enabled(phase == 'train'):
                     # 모델의 출력을 가져오고 손실을 계산합니다.
                     # 학습 시 보조(auxiliary) 출력이 있는 inception의 특별한 경우입니다.

beginner_source/hyperparameter_tuning_tutorial.py

@@ -14,7 +14,7 @@
 `Ray 의 분산 기계 학습 엔진 <https://ray.io/>`_ 을 통해 학습을 지원합니다.
 
 이 튜토리얼은 Ray Tune을 파이토치 학습 workflow에 통합하는 방법을 알려줍니다.
-CIFAR10 이미지 분류기를 훈련하기 위해 `파이토치 문서에서 이 튜토리얼을 <https://tutorials.pytorch.kr/beginner/blitz/cifar10_tutorial.html>`_ 확장할 것입니다.
+CIFAR10 이미지 분류기를 학습하기 위해 `파이토치 문서에서 이 튜토리얼을 <https://tutorials.pytorch.kr/beginner/blitz/cifar10_tutorial.html>`_ 확장할 것입니다.
 
 아래와 같이 약간의 수정만 추가하면 됩니다.
 
@@ -153,7 +153,7 @@ def forward(self, x):
 # DataParallel을 이용한 GPU(다중)지원 추가
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # 이미지 분류는 GPU를 사용할 때 이점이 많습니다. 운좋게도 Ray Tune에서 파이토치의 추상화를 계속 사용할 수 있습니다.
-# 따라서 여러 GPU에서 데이터 병렬 훈련을 지원하기 위해 모델을 ``nn.DataParallel`` 으로 감쌀 수 있습니다.
+# 따라서 여러 GPU에서 데이터 병렬 학습을 지원하기 위해 모델을 ``nn.DataParallel`` 으로 감쌀 수 있습니다.
 #
 # .. code-block:: python
 #
@@ -369,7 +369,7 @@ def test_accuracy(net, device="cpu"):
 # ``lr`` (학습률)은 0.0001과 0.1 사이에서 균일하게 샘플링 되어야 합니다. 마지막으로, 배치 크기는 2, 4, 8, 16중에서 선택할 수 있습니다.
 #
 # 각 실험에서, Ray Tune은 이제 이러한 검색 공간에서 매개변수 조합을 무작위로 샘플링합니다.
-# 그런 다음 여러 모델을 병렬로 훈련하고 이 중에서 가장 성능이 좋은 모델을 찾습니다. 또한 성능이 좋지 않은 실험을 조기에 종료하는 ``ASHAScheduler`` 를 사용합니다.
+# 그런 다음 여러 모델을 병렬로 학습하고 이 중에서 가장 성능이 좋은 모델을 찾습니다. 또한 성능이 좋지 않은 실험을 조기에 종료하는 ``ASHAScheduler`` 를 사용합니다.
 #
 # 상수 ``data_dir`` 매개변수를 설정하기 위해 ``functools.partial`` 로 ``train_cifar`` 함수를 감싸둡니다. 또한 각 실험에 사용할 수 있는 자원들(resources)을 Ray Tune에 알릴 수 있습니다.
 #
@@ -390,7 +390,7 @@ def test_accuracy(net, device="cpu"):
 #
 # 부분 GPUs를 지정할 수도 있으므로, ``gpus_per_trial=0.5`` 와 같은 것 또한 가능합니다. 이후 각 실험은 GPU를 공유합니다. 사용자는 모델이 여전히 GPU메모리에 적합한지만 확인하면 됩니다.
 #
-# 모델을 훈련시킨 후, 가장 성능이 좋은 모델을 찾고 체크포인트 파일에서 학습된 모델을 로드합니다. 이후 test set 정확도(accuracy)를 얻고 모든 것들을 출력하여 확인할 수 있습니다.
+# 모델을 학습시킨 후, 가장 성능이 좋은 모델을 찾고 체크포인트 파일에서 학습된 모델을 로드합니다. 이후 test set 정확도(accuracy)를 얻고 모든 것들을 출력하여 확인할 수 있습니다.
 #
 # 전체 주요 기능은 다음과 같습니다.
 

beginner_source/introyt/introyt1_tutorial.py

@@ -573,7 +573,7 @@ def forward(self, x):
 #    [2, 12000] loss: 1.267
 #    Finished Training
 #
-# 손실 값은 단조롭게 감소하며, 이는 모델이 훈련 데이터셋에서 성능을
+# 손실 값은 단조롭게 감소하며, 이는 모델이 학습 데이터셋에서 성능을
 # 계속 향상시키고 있음을 보여줍니다.
 #
 # 마지막 단계로 모델이 단순하게 학습 데이터셋을 “기억” 하는 것이 아니라

beginner_source/introyt/tensorboardyt_tutorial.py

@@ -53,7 +53,7 @@
 
 """
 
-# PyTorch 모델과 훈련 필수 요소
+# PyTorch 모델과 학습 필수 요소
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
@@ -90,7 +90,7 @@
     [transforms.ToTensor(),
     transforms.Normalize((0.5,), (0.5,))])
 
-# 훈련과 검증으로 분할하여 각각 ./data에 저장하기
+# 학습과 검증으로 분할하여 각각 ./data에 저장하기
 training_set = torchvision.datasets.FashionMNIST('./data',
     download=True,
     train=True,
@@ -160,15 +160,15 @@ def matplotlib_imshow(img, one_channel=False):
 # 그것을 새 브라우저 탭(보통 `localhost:6006 <localhost:6006>`__)에서 열었다면, 
 # IMAGES 탭에서 이미지 격자를 확인할 수 있을 것입니다.
 #
-# 훈련 시각화를 위한 스칼라 그래프 그리기
+# 학습 시각화를 위한 스칼라 그래프 그리기
 # --------------------------------------
 #
-# TensorBoard는 훈련 진행 과정과 효과를 추적하기에 
-# 유용합니다. 아래에서 훈련 루프를 실행하고 몇몇 지표를 추적하며 
+# TensorBoard는 학습 진행 과정과 효과를 추적하기에 
+# 유용합니다. 아래에서 학습 루프를 실행하고 몇몇 지표를 추적하며 
 # TensorBoard에서 사용할 데이터를 저장할 것입니다.
 #
 # 이미지 타일을 분류할 모델과 옵티마이저 
-# 그리고 훈련의 손실 함수를 정의해 봅시다:
+# 그리고 학습의 손실 함수를 정의해 봅시다:
 #
 
 class Net(nn.Module):
@@ -197,7 +197,7 @@ def forward(self, x):
 
 
 ##########################################################################
-# 이제 단일 에폭을 훈련하고, 매 1000 배치마다 훈련 셋과 검증 셋의
+# 이제 단일 에폭을 학습하고, 매 1000 배치마다 학습 셋과 검증 셋의
 # 손실을 평가해 봅니다:
 #
 
@@ -206,7 +206,7 @@ def forward(self, x):
     running_loss = 0.0
 
     for i, data in enumerate(training_loader, 0):
-        # 기본 훈련 루프
+        # 기본 학습 루프
         inputs, labels = data
         optimizer.zero_grad()
         outputs = net(inputs)
@@ -227,7 +227,7 @@ def forward(self, x):
                 voutputs = net(vinputs)
                 vloss = criterion(voutputs, vlabels)
                 running_vloss += vloss.item()
-            net.train(True) # 훈련 모드로 돌아가기, 예시: 정규화 켜기
+            net.train(True) # 학습 모드로 돌아가기, 예시: 정규화 켜기
 
             avg_loss = running_loss / 1000
             avg_vloss = running_vloss / len(validation_loader)

beginner_source/nlp/advanced_tutorial.py

@@ -278,15 +278,15 @@ def forward(self, sentence):  # 이 함수와 위의 _forward_alg를 헷갈리
         return score, tag_seq
 
 #####################################################################
-# 훈련 실행
+# 학습 실행
 
 
 START_TAG = "<START>"
 STOP_TAG = "<STOP>"
 EMBEDDING_DIM = 5
 HIDDEN_DIM = 4
 
-# 훈련용 데이터를 만듭니다.
+# 학습용 데이터를 만듭니다.
 training_data = [(
     "the wall street journal reported today that apple corporation made money".split(),
     "B I I I O O O B I O O".split()
@@ -306,7 +306,7 @@ def forward(self, sentence):  # 이 함수와 위의 _forward_alg를 헷갈리
 model = BiLSTM_CRF(len(word_to_ix), tag_to_ix, EMBEDDING_DIM, HIDDEN_DIM)
 optimizer = optim.SGD(model.parameters(), lr=0.01, weight_decay=1e-4)
 
-# 훈련 전 예측 결과를 확인합니다.
+# 학습 전 예측 결과를 확인합니다.
 with torch.no_grad():
     precheck_sent = prepare_sequence(training_data[0][0], word_to_ix)
     precheck_tags = torch.tensor([tag_to_ix[t] for t in training_data[0][1]], dtype=torch.long)
@@ -334,7 +334,7 @@ def forward(self, sentence):  # 이 함수와 위의 _forward_alg를 헷갈리
         loss.backward()
         optimizer.step()
 
-# 훈련이 끝난 후 예측 결과를 확인합니다.
+# 학습이 끝난 후 예측 결과를 확인합니다.
 with torch.no_grad():
     precheck_sent = prepare_sequence(training_data[0][0], word_to_ix)
     print(model(precheck_sent))

beginner_source/nlp/deep_learning_tutorial.py

@@ -312,7 +312,7 @@ def make_target(label, label_to_ix):
 # Log softmax 인 이유입니다. 손실 함수 nn.CrossEntropyLoss()는 Log softmax를 제외하고는 NLLLoss()와 같습니다.
 #
 
-# 훈련하기 전에 테스트 데이터를 실행하여 전후를 볼 수 있습니다.
+# 학습하기 전에 테스트 데이터를 실행하여 전후를 볼 수 있습니다.
 with torch.no_grad():
     for instance, label in test_data:
         bow_vec = make_bow_vector(instance, word_to_ix)