beginner_source/nn_tutorial.py fix typo (#852)

fix typo

beginner_source/nn_tutorial.py

@@ -10,21 +10,21 @@
 
 ###############################################################################
 # 이 튜토리얼을 스크립트가 아닌 노트북으로 실행하기를 권장합니다. 노트북 (``.ipynb``) 파일을 다운 받으시려면,
-# 페이지 상단에 있는 링크를 클릭해주세요.
+# 페이지 상단에 있는 링크를 클릭해 주세요.
 #
-# PyTorch 는 여러분이 신경망(neural network)를 생성하고 학습시키는 것을 도와주기 위해서
+# PyTorch는 여러분이 신경망(neural network)를 생성하고 학습시키는 것을 도와주기 위해서
 # `torch.nn <https://pytorch.org/docs/stable/nn.html>`_ ,
 # `torch.optim <https://pytorch.org/docs/stable/optim.html>`_ ,
 # `Dataset <https://pytorch.org/docs/stable/data.html?highlight=dataset#torch.utils.data.Dataset>`_ ,
 # 그리고 `DataLoader <https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.DataLoader>`_
 # 와 같은 잘 디자인된 모듈과 클래스들을 제공합니다.
 # 이들의 성능을 최대한 활용하고 여러분의 문제에 맞게 커스터마이즈하기 위해서,
 # 정확히 이들이 어떤 작업을 수행하는지 이해할 필요가 있습니다.
-# 이해를 증진하기 위해서, 우리는 먼저 이들 모델들로부터 아무 피쳐도 사용하지 않고
+# 이해를 증진하기 위해서, 우리는 먼저 이들 모델들로부터 아무 특징도 사용하지 않고
 # MNIST 데이터셋에 대해 기초적인 신경망을 학습시킬 것입니다;
 # 우리는 처음에는 가장 기초적인 PyTorch 텐서(tensor) 기능만을 사용할 것입니다.
-# 그리고나서 우리는 점차적으로 ``torch.nn``, ``torch.optim``, ``Dataset``, 또는
-# ``DataLoader`` 로부터 한번에 하나씩 피쳐를 추가하면서, 정확히 각 부분이 어떤 일을 하는지 그리고
+# 그러고 나서 우리는 점차적으로 ``torch.nn``, ``torch.optim``, ``Dataset``, 또는
+# ``DataLoader`` 로부터 한 번에 하나씩 특징을 추가하면서, 정확히 각 부분이 어떤 일을 하는지 그리고
 # 이것이 어떻게 코드를 더 간결하고 유연하게 만드는지 보여줄 것입니다.
 #
 # **이 튜토리얼은 여러분이 이미 PyTorch를 설치하였고, 그리고 텐서 연산의 기초에 대해 익숙하다고 가정합니다.**
@@ -35,7 +35,7 @@
 # -------------------
 #
 # 우리는 손으로 쓴 숫자(0에서 9 사이)의 흑백 이미지로 구성된 클래식
-# `MNIST <http://deeplearning.net/data/mnist/>`_ 데이터셋을 사용할 것 입니다.
+# `MNIST <http://deeplearning.net/data/mnist/>`_ 데이터셋을 사용할 것입니다.
 #
 # 우리는 경로 설정을 담당하는 (Python3 표준 라이브러리의 일부인)
 # `pathlib <https://docs.python.org/3/library/pathlib.html>`_ 을 사용할 것이고,
@@ -60,7 +60,7 @@
 
 ###############################################################################
 # 이 데이터셋은 NumPy 배열 포맷이고, 데이터를 직렬화하기 위한
-# python 전용 포맷 pickle 을 이용하여 저장되어 있습니다.
+# python 전용 포맷 pickle을 이용하여 저장되어 있습니다.
 
 import pickle
 import gzip
@@ -69,8 +69,8 @@
         ((x_train, y_train), (x_valid, y_valid), _) = pickle.load(f, encoding="latin-1")
 
 ###############################################################################
-# 각 이미지는 28 x 28 형태 이고, 784 (=28x28) 크기를 가진 하나의 행으로 저장되어 있습니다.
-# 하나를 살펴 봅시다; 먼저 우리는 이 이미지를 2d로 재구성해야 합니다.
+# 각 이미지는 28 x 28 형태이고, 784 (=28x28) 크기를 가진 하나의 행으로 저장되어 있습니다.
+# 한 장을 살펴봅시다; 먼저 우리는 이 이미지를 2d로 재구성해야 합니다.
 
 from matplotlib import pyplot
 import numpy as np
@@ -84,7 +84,7 @@
 print(x_train.shape)
 
 ###############################################################################
-# PyTorch는 NumPy 배열 보다는 ``torch.tensor`` 를 사용하므로, 우리는 데이터를 변환해야 합니다.
+# PyTorch는 NumPy 배열보다는 ``torch.tensor`` 를 사용하므로, 데이터를 변환해야 합니다.
 
 import torch
 
@@ -125,13 +125,13 @@
 bias = torch.zeros(10, requires_grad=True)
 
 ###############################################################################
-# PyTorch의 기울기를 자동으로 계산해주는 기능 덕분에, Python 표준 함수
+# PyTorch의 기울기를 자동으로 계산 해주는 기능 덕분에, Python 표준 함수
 # (또는 호출 가능한 객체)를 모델로 사용할 수 있습니다!
 # 그러므로 간단한 선형 모델을 만들기 위해서 단순한 행렬 곱셈과 브로드캐스트(broadcast)
 # 덧셈을 사용하여 보겠습니다. 또한, 우리는 활성화 함수(activation function)가 필요하므로,
 # `log_softmax` 를 구현하고 사용할 것입니다.
 # PyTorch에서 많은 사전 구현된 손실 함수(loss function), 활성화 함수들이 제공되지만,
-# 일반적인 python을 사용하여 자신만의 함수를 쉽게 작성할 수 있음을 기억해주세요.
+# 일반적인 python을 사용하여 자신만의 함수를 쉽게 작성할 수 있음을 기억해 주세요.
 # PyTorch는 심지어 여러분의 함수를 위해서 빠른 GPU 또는 벡터화된 CPU 코드를 만들어줄 것입니다.
 
 def log_softmax(x):
@@ -167,7 +167,7 @@ def nll(input, target):
 loss_func = nll
 
 ###############################################################################
-# 우리의 무작위 모델에 대한 손실을 점검해봅시다, 그럼으로써 우리는 나중에 역전파 이후에 개선이 있는지
+# 우리의 무작위 모델에 대한 손실을 점검해 봄으로써 역전파 이후에 개선이 있는지 나중에
 # 확인할 수 있습니다.
 
 yb = y_train[0:bs]
@@ -176,7 +176,7 @@ def nll(input, target):
 
 ###############################################################################
 # 또한, 우리 모델의 정확도(accuracy)를 계산하기 위한 함수를 구현합시다.
-# 매 예측마다, 만약 가장 큰 값의 인덱스가 목표값(target value)과 동일하다면,
+# 매 예측마다, 만약 가장 큰 값의 인덱스가 목푯값(target value)과 동일하다면,
 # 그 예측은 올바른 것입니다.
 
 def accuracy(out, yb):
@@ -190,26 +190,26 @@ def accuracy(out, yb):
 print(accuracy(preds, yb))
 
 ###############################################################################
-# 이제 우리는 훈련 루프(training loop)를 실행할 수 있습니다. 매 반복마다, 우리는 다음을 수행할 것입니다:
+# 이제 우리는 훈련 루프(training loop)를 실행할 수 있습니다. 매 반복마다, 다음을 수행할 것입니다:
 #
 # - 데이터의 미니배치를 선택 (``bs`` 크기)
 # - 모델을 이용하여 예측 수행
 # - 손실 계산
 # - ``loss.backward()`` 를 이용하여 모델의 기울기 업데이트, 이 경우에는, ``weights`` 와 ``bias``.
 #
 # 이제 우리는 이 기울기들을 이용하여 가중치와 절편을 업데이트 합니다.
-# 우리는 이것을 ``torch.no_grad()`` 컨텍스트 매니져(context manager) 내에서 실행합니다,
+# 우리는 이것을 ``torch.no_grad()`` 컨텍스트 매니저(context manager) 내에서 실행합니다,
 # 왜냐하면 이러한 실행이 다음 기울기의 계산에 기록되지 않기를 원하기 때문입니다.
 # PyTorch의 자동 기울기(Autograd)가 어떻게 연산을 기록하는지
-# `여기 <https://pytorch.org/docs/stable/notes/autograd.html>`_ 에서 더 알아볼 수 있습니다.
+# `여기 <https://pytorch.org/docs/stable/notes/autograd.html>`_\에서 더 알아볼 수 있습니다.
 #
-# 우리는 그러고나서 기울기를 0으로 설정합니다, 그럼으로써 다음 루프(loop)에 준비하게 됩니다.
-# 그렇지 않으면, 우리의 기울기들은 일어난 모든 연산의 누적 집계를 기록하게 되버립니다.
+# 그러고 나서 기울기를 0으로 설정합니다, 그럼으로써 다음 루프(loop)에 준비하게 됩니다.
+# 그렇지 않으면, 우리의 기울기들은 일어난 모든 연산의 누적 집계를 기록하게 되어버립니다.
 # (즉, ``loss.backward()`` 가 이미 저장된 것을 대체하기보단, 기존 값에 기울기를 *더하게* 됩니다).
 #
 # .. tip:: 여러분들은 PyTorch 코드에 대하여 표준 python 디버거(debugger)를 사용할 수 있으므로,
 #    매 단계마다 다양한 변수 값을 점검할 수 있습니다.
-#    아래에서 ``set_trace()`` 를 주석 해제하여 사용해보세요.
+#    아래에서 ``set_trace()`` 를 주석 해제하여 사용해 보세요.
 #
 
 from IPython.core.debugger import set_trace
@@ -235,7 +235,7 @@ def accuracy(out, yb):
             bias.grad.zero_()
 
 ###############################################################################
-# 이제 다 됐습니다: 우리는 제일 간단한 신경망(neural network)의 모든 것을 밑바닥부터 생성하고
+# 이제 다 됐습니다: 제일 간단한 신경망(neural network)의 모든 것을 밑바닥부터 생성하고
 # 훈련하였습니다! (이번에는 은닉층(hidden layer)이 없기 때문에,
 # 로지스틱 회귀(logistic regression)입니다).
 #
@@ -248,7 +248,7 @@ def accuracy(out, yb):
 # ``torch.nn.functional`` 사용하기
 # -----------------------------------
 #
-# 이제 우리는 코드를 리팩토링(refactoring) 하겠습니다, 그럼으로써 이전과 동일하지만,
+# 이제 코드를 리팩토링(refactoring) 하겠습니다. 그로써 이전과 동일하지만,
 # PyTorch의 ``nn`` 클래스의 장점을 활용하여 더 간결하고 유연하게 만들 것입니다.
 # 지금부터 매 단계에서, 우리는 코드를 더 짧고, 이해하기 쉽고, 유연하게 만들어야 합니다.
 #
@@ -257,10 +257,10 @@ def accuracy(out, yb):
 # (관례에 따라, 일반적으로 ``F`` 네임스페이스(namespace)를 통해 임포트(import) 합니다).
 # 이 모듈에는 ``torch.nn`` 라이브러리의 모든 함수가 포함되어 있습니다
 # (라이브러리의 다른 부분에는 클래스가 포함되어 있습니다.)
-# 다양한 손실 및 활성화 함수 뿐만 아니라, 풀링(pooling) 함수와 같이 신경망을 만드는데
+# 다양한 손실 및 활성화 함수뿐만 아니라, 풀링(pooling) 함수와 같이 신경망을 만드는데
 # 편리한 몇 가지 함수도 여기에서 찾을 수 있습니다.
 # (컨볼루션(convolution) 연산, 선형(linear) 레이어, 등을 수행하는 함수도 있지만,
-# 앞으로 보시겠지만 일반적으로 라이브러리의 다른 부분을 사용하여 더 잘 처리 할 수 있습니다.)
+# 앞으로 보시겠지만 대개는 라이브러리의 다른 부분을 사용하여 더 잘 처리할 수 있습니다.)
 #
 # 만약 여러분들이 음의 로그 우도 손실과 로그 소프트맥스 (log softmax) 활성화 함수를 사용하는 경우,
 # PyTorch는 이 둘을 결합하는 단일 함수인 ``F.cross_entropy`` 를 제공합니다.
@@ -274,23 +274,23 @@ def model(xb):
     return xb @ weights + bias
 
 ###############################################################################
-# 더이상 ``model`` 함수에서 ``log_softmax`` 를 호출하지 않고 있습니다.
-# 손실과 정확도과 이전과 동일한지 확인해봅시다:
+# 더 이상 ``model`` 함수에서 ``log_softmax`` 를 호출하지 않고 있습니다.
+# 손실과 정확도과 이전과 동일한지 확인해 봅시다:
 
 print(loss_func(model(xb), yb), accuracy(model(xb), yb))
 
 ###############################################################################
 # ``nn.Module`` 을 이용하여 리팩토링 하기
 # -----------------------------------------
 # 다음으로, 더 명확하고 간결한 훈련 루프를 위해 ``nn.Module`` 및 ``nn.Parameter`` 를 사용합니다.
-# 우리는 ``nn.Module`` (자체가 클래스이고 상태를 추척할 수 있는) 하위 클래스(subclass)를 만듭니다.
+# 우리는 ``nn.Module`` (자체가 클래스이고 상태를 추적할 수 있는) 하위 클래스(subclass)를 만듭니다.
 # 이 경우에는, 포워드(forward) 단계에 대한 가중치, 절편, 그리고 메소드(method) 등을 유지하는
 # 클래스를 만들고자 합니다.
 # ``nn.Module`` 은 우리가 사용할 몇 가지 속성(attribute)과 메소드를 (``.parameters()`` 와
 # ``.zero_grad()`` 같은) 가지고 있습니다.
 #
-# .. note:: ``nn.Module`` (대문자 M) 은 PyTorch 의 특정 개념이고, 우리는 이 클래스를
-#    많이 사용할 것입니다. ``nn.Module`` 를 Python 의 코드를 임포트하기 위한 코드 파일인
+# .. note:: ``nn.Module`` (대문자 M) 은 PyTorch의 특정 개념이고, 우리는 이 클래스를
+#    많이 사용할 것입니다. ``nn.Module`` 를 Python의 코드를 임포트하기 위한 코드 파일인
 #    `module <https://docs.python.org/3/tutorial/modules.html>`_ (소문자 ``m``)
 #    의 개념과 헷갈리지 말아주세요.
 
@@ -314,7 +314,7 @@ def forward(self, xb):
 ###############################################################################
 # 이제 우리는 이전과 동일한 방식으로 손실을 계산할 수 있습니다.
 # 여기서 ``nn.Module`` 오브젝트들은 마치 함수처럼 사용됩니다 (즉, 이들은 *호출가능* 합니다),
-# 그러나 배후에서 PyTorch 는 우리의 ``forward`` 메소드를 자동으로 호출합니다.
+# 그러나 배후에서 PyTorch는 우리의 ``forward`` 메소드를 자동으로 호출합니다.
 
 print(loss_func(model(xb), yb))
 
@@ -363,7 +363,7 @@ def fit():
 fit()
 
 ###############################################################################
-# 손실이 줄어들었는지 다시 한번 확인합시다:
+# 손실이 줄어들었는지 다시 한 번 확인합시다:
 
 print(loss_func(model(xb), yb))