docs: 번역어 통일 - '레이어'를 '계층'으로 정정

advanced_source/neural_style_tutorial.py

@@ -142,15 +142,15 @@ def imshow(tensor, title=None):
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #
 # Content 손실은 각 계층에 대한 Content 거리의 가중치 버전을 나타냅니다.
-# 이 함수는 입력 :math:`X` 를 처리하는 레이어 :math:`L` 의 특징 맵 :math:`F_{XL}` 을 가져와서
+# 이 함수는 입력 :math:`X` 를 처리하는 계층 :math:`L` 의 특징 맵 :math:`F_{XL}` 을 가져와서
 # 이미지 :math:`X` 와 Content 이미지 :math:`C` 사이의
 # 가중 콘텐츠 거리(weighted content distance) :math:`w_{CL}.D_C^L(X,C)` 를 반환합니다.
 # Content 거리를 계산하기 위해 Content 이미지(:math:`F_{CL}`)의 특징 맵을 함수에서 알고 있어야합니다.
 # :math:`F_{CL}` 을 입력으로 사용하는 생성자를 사용해 이 함수를 torch 모듈로 구현합니다.
 # 거리 :math:`\|F_{XL} - F_{CL}\|^2` 는 두 개의 특징 맵 집합의 평균 제곱 오차이며 ``nn.MSELoss`` 를 사용하여 계산할 수 있습니다.
 #
 # Content 거리를 계산하기 위해 사용되는 합성곱 계층 바로 뒤에 Content 손실 모듈을 추가합니다.
-# 이렇게 하면 입력 이미지가 입력될 때마다 Content 손실이 원하는 레이어에서
+# 이렇게 하면 입력 이미지가 입력될 때마다 Content 손실이 원하는 계층에서
 # 계산되고 autograd 을 통해 모든 기울기가 계산됩니다.
 # 이제 Content 손실 계층을 만들기 위해 Content 손실을 계산한 다음 계층의 입력을 반환하는
 # ``forward`` 메소드를 정의해야합니다.
@@ -400,7 +400,7 @@ def run_style_transfer(cnn, normalization_mean, normalization_std,
     # 이에 맞춰서 requires_grad 값을 갱신합니다.
     input_img.requires_grad_(True)
     # 또한, 모델을 평가(eval) 모드로 전환하여
-    # 드롭아웃(dropout) 및 배치 정규화(batch normalization)와 같은 특정 레이어가 올바르게 동작하도록 합니다.
+    # 드롭아웃(dropout) 및 배치 정규화(batch normalization)와 같은 특정 계층이 올바르게 동작하도록 합니다.
     model.eval()
     model.requires_grad_(False)
 

advanced_source/semi_structured_sparse.py

@@ -40,7 +40,7 @@
 #
 # 이 튜토리얼은 초보자에게 반구조적 희소성 및 일반적인 희소성을 맞춤 설명합니다.
 # 이미 2:4 희소 모델을 보유한 사용자에게는 ``to_sparse_semi_structured``를 사용하여
-# 추론을 위한 ``nn.Linear`` 레이어를 가속화하는 것이 매우 간단합니다. 다음은 그 예시입니다:
+# 추론을 위한 ``nn.Linear`` 계층을 가속화하는 것이 매우 간단합니다. 다음은 그 예시입니다:
 #
 
 import torch
@@ -467,10 +467,10 @@ def measure_execution_time(model, batch_sizes, dataset):
 # 도구가 포함되어 있습니다. 이러한 희소화 도구는 모델의 가중치 텐서에 마스크 매개변수화를 적용하여
 # 작동합니다. 이를 통해 가지치기된 가중치를 마스킹하여 희소성을 시뮬레이션할 수 있습니다.
 #
-# 또한, 모델의 어느 레이어에 희소성을 적용할지 결정해야 합니다. 이 경우에는 각각의 테스크 헤드 출력을
-# 제외한 모든 ``nn.Linear`` 레이어에 적용합니다. 이는 반구조적 희소성(semi-structured sparsity)이
+# 또한, 모델의 어느 계층에 희소성을 적용할지 결정해야 합니다. 이 경우에는 각각의 테스크 헤드 출력을
+# 제외한 모든 ``nn.Linear`` 계층에 적용합니다. 이는 반구조적 희소성(semi-structured sparsity)이
 # `형상 제약 <https://pytorch.org/docs/2.1/sparse.html#constructing-sparse-semi-structured-tensors>`_
-# 을 가지기 때문이며, 각각의 task ``nn.Linear`` 레이어는 이러한 제약을 충족하지 않기 때문입니다.
+# 을 가지기 때문이며, 각각의 task ``nn.Linear`` 계층은 이러한 제약을 충족하지 않기 때문입니다.
 #
 
 sparsifier = WeightNormSparsifier(

beginner_source/basics/optimization_tutorial.py

@@ -149,7 +149,7 @@ def forward(self, x):
 
 def train_loop(dataloader, model, loss_fn, optimizer):
     size = len(dataloader.dataset)
-    # 모델을 학습(train) 모드로 설정합니다 - 배치 정규화(Batch Normalization) 및 드롭아웃(Dropout) 레이어들에 중요합니다.
+    # 모델을 학습(train) 모드로 설정합니다 - 배치 정규화(Batch Normalization) 및 드롭아웃(Dropout) 계층들에 중요합니다.
     # 이 예시에서는 없어도 되지만, 모범 사례를 위해 추가해두었습니다.
     model.train()
     for batch, (X, y) in enumerate(dataloader):
@@ -168,7 +168,7 @@ def train_loop(dataloader, model, loss_fn, optimizer):
 
 
 def test_loop(dataloader, model, loss_fn):
-    # 모델을 평가(eval) 모드로 설정합니다 - 배치 정규화(Batch Normalization) 및 드롭아웃(Dropout) 레이어들에 중요합니다.
+    # 모델을 평가(eval) 모드로 설정합니다 - 배치 정규화(Batch Normalization) 및 드롭아웃(Dropout) 계층들에 중요합니다.
     # 이 예시에서는 없어도 되지만, 모범 사례를 위해 추가해두었습니다.
     model.eval()
     size = len(dataloader.dataset)

beginner_source/blitz/neural_networks_tutorial.py

@@ -54,29 +54,29 @@ def __init__(self):
         self.fc3 = nn.Linear(84, 10)
 
     def forward(self, input):
-        # 합성곱(Convolution) 레이어 c1: 입력 이미지 채널 1, 출력 채널 6,
+        # 합성곱(Convolution) 계층 c1: 입력 이미지 채널 1, 출력 채널 6,
         # 5x5 정사각 합성곱, 활성 함수로 RELU 사용 및 (N, 6, 28, 28)의 크기를
         # 갖는 Tensor를 출력 (N은 배치 크기)
         c1 = F.relu(self.conv1(input))
-        # 서브샘플링(Subsampling) 레이어 s2: 2x2 격자, 순전히 기능적인 레이어로,
-        # 이 레이어는 어떠한 매개변수도 가지지 않고 (N, 6, 14, 14) Tensor를 출력
+        # 서브샘플링(Subsampling) 계층 s2: 2x2 격자, 순전히 기능적인 계층으로,
+        # 이 계층은 어떠한 매개변수도 가지지 않고 (N, 6, 14, 14) Tensor를 출력
         s2 = F.max_pool2d(c1, (2, 2))
-        # 합성곱(Convolution) 레이어 c3: 입력 채널 6, 출력 채널 16,
+        # 합성곱(Convolution) 계층 c3: 입력 채널 6, 출력 채널 16,
         # 5x5 정사각 합성곱, 활성 함수로 RELU 사용 및 (N, 16, 10, 10)의 크기를
         # 갖는 Tensor를 출력
         c3 = F.relu(self.conv2(s2))
-        # 서브샘플링(Subsampling) 레이어 s4: 2x2 격자, 순전히 기능적인 레이어로,
-        # 이 레이어는 어떠한 매개변수도 가지지 않고 (N, 16, 5, 5) Tensor를 출력
+        # 서브샘플링(Subsampling) 계층 s4: 2x2 격자, 순전히 기능적인 계층으로,
+        # 이 계층은 어떠한 매개변수도 가지지 않고 (N, 16, 5, 5) Tensor를 출력
         s4 = F.max_pool2d(c3, 2)
         # 평탄화(flatten) 연산: 순전히 기능적으로 동작하며, (N, 400) Tensor를 출력
         s4 = torch.flatten(s4, 1)
-        # 완전히 연결된 레이어 f5: (N, 400) Tensor를 입력으로 받아서
+        # 완전히 연결된 계층 f5: (N, 400) Tensor를 입력으로 받아서
         # (N, 120) Tensor를 출력하며, 활성 함수로 RELU 사용
         f5 = F.relu(self.fc1(s4))
-        # 완전히 연결된 레이어 f6: (N, 120) Tensor를 입력으로 받아서
+        # 완전히 연결된 계층 f6: (N, 120) Tensor를 입력으로 받아서
         # (N, 84) Tensor를 출력하며, 활성 함수로 RELU 사용
         f6 = F.relu(self.fc2(f5))
-        # 가우시안 레이어 출력: (N, 84) Tensor를 입력으로 받아서
+        # 가우시안 계층 출력: (N, 84) Tensor를 입력으로 받아서
         # (N, 10) Tensor를 출력
         output = self.fc3(f6)
         return output

beginner_source/chatbot_tutorial.py

@@ -568,7 +568,7 @@ def batch2TrainData(voc, pair_batch):
 # 순환 신경망을 같이 이용하여 이러한 목적을 달성할 수 있음을 발견했습니다.
 # RNN 하나는 **인코더** 로, 가변 길이 입력 시퀀스를 고정된 길이의 문맥
 # 벡터(context vector)로 인코딩합니다. 이론상 문맥 벡터(RNN의 마지막
-# 은닉 레이어)는 봇에게 입력으로 주어지는 질의 문장에 대한 의미론적 정보를
+# 은닉 계층)는 봇에게 입력으로 주어지는 질의 문장에 대한 의미론적 정보를
 # 담고 있을 것입니다. 두 번째 RNN은 **디코더** 입니다. 디코더는 단어 하나와
 # 문맥 벡터를 입력으로 받고, 시퀀스의 다음 단어가 무엇일지를 추론하여
 # 반환하며, 다음 단계에서 사용할 은닉 상태도 같이 반환합니다.
@@ -594,7 +594,7 @@ def batch2TrainData(voc, pair_batch):
 # 나중에 디코더는 이를 이용하여 주어진 문제에 대해 의미 있는 출력을
 # 구할 것입니다.
 #
-# 인코더의 핵심 부분에는 다중 레이어 게이트 순환 유닛(multi-layered Gated
+# 인코더의 핵심 부분에는 다중 계층 게이트 순환 유닛(multi-layered Gated
 # Recurrent Unit)이 있습니다. 이는 `Cho 등 <https://arxiv.org/pdf/1406.1078v3.pdf>`__
 # 이 2014년에 고안한 것입니다. 우리는 GRU를 양방향으로 변환한 형태를
 # 사용할 것이며, 이는 본질적으로 두 개의 독립된 RNN이 존재한다는
@@ -612,9 +612,9 @@ def batch2TrainData(voc, pair_batch):
 #
 # 그림 출처: https://colah.github.io/posts/2015-09-NN-Types-FP/
 #
-# ``embedding`` 레이어가 단어 인덱스를 임의 크기의 피처 공간으로
+# ``embedding`` 계층이 단어 인덱스를 임의 크기의 피처 공간으로
 # 인코딩하는 데 사용되었음에 유의하기 바랍니다. 우리의 모델에서는 이
-# 레이어가 각 단어를 크기가 *hidden_size* 인 피처 공간으로 매핑할
+# 계층이 각 단어를 크기가 *hidden_size* 인 피처 공간으로 매핑할
 # 것입니다. 학습을 거치면 서로 뜻이 유사한 단어는 의미적으로 유사하게
 # 인코딩될 것입니다.
 #
@@ -643,7 +643,7 @@ def batch2TrainData(voc, pair_batch):
 #
 # **출력:**
 #
-# -  ``outputs``: GRU의 마지막 은닉 레이어에 대한 출력 피처 값(양방향
+# -  ``outputs``: GRU의 마지막 은닉 계층에 대한 출력 피처 값(양방향
 #    (출력을 합산한 것). shape=\ *(max_length, batch_size, hidden_size)*
 # -  ``hidden``: GRU의 최종 은닉 상태. shape=\ *(n_layers x
 #    num_directions, batch_size, hidden_size)*
@@ -727,7 +727,7 @@ def forward(self, input_seq, input_lengths, hidden=None):
 # 모든 상태를 뜻합니다.
 #
 # 종합해 보면, 전역 어텐션 메커니즘을 다음 그림과 같이 요약할 수 있을
-# 것입니다. 우리가 '어텐션 레이어'를 ``Attn`` 라는 독립적인 ``nn.Module`` 로
+# 것입니다. 우리가 '어텐션 계층'을 ``Attn`` 라는 독립적인 ``nn.Module`` 로
 # 구현할 것임에 유의하기 바랍니다. 이 모듈의 출력은 모양이 *(batch_size, 1,
 # max_length)* 인 정규화된 softmax 가중치 텐서입니다.
 #
@@ -737,7 +737,7 @@ def forward(self, input_seq, input_lengths, hidden=None):
 #    :alt: global_attn
 #
 
-# Luong 어텐션 레이어
+# Luong 어텐션 계층
 class Attn(nn.Module):
     def __init__(self, method, hidden_size):
         super(Attn, self).__init__()
@@ -798,7 +798,7 @@ def forward(self, hidden, encoder_outputs):
 #
 # -  ``input_step``: 입력 시퀀스 배치에 대한 한 단위 시간(한 단어).
 #    shape=\ *(1, batch_size)*
-# -  ``last_hidden``: GRU의 마지막 은닉 레이어. shape=\ *(n_layers x
+# -  ``last_hidden``: GRU의 마지막 은닉 계층. shape=\ *(n_layers x
 #    num_directions, batch_size, hidden_size)*
 # -  ``encoder_outputs``: 인코더 모델의 출력. shape=\ *(max_length,
 #    batch_size, hidden_size)*
@@ -823,7 +823,7 @@ def __init__(self, attn_model, embedding, hidden_size, output_size, n_layers=1,
         self.n_layers = n_layers
         self.dropout = dropout
 
-        # 레이어를 정의합니다
+        # 계층을 정의합니다
         self.embedding = embedding
         self.embedding_dropout = nn.Dropout(dropout)
         self.gru = nn.GRU(hidden_size, hidden_size, n_layers, dropout=(0 if n_layers == 1 else dropout))
@@ -924,8 +924,8 @@ def maskNLLLoss(inp, target, mask):
 # .. warning::
 #
 #   PyTorch의 RNN 모듈( ``RNN``, ``LSTM``, ``GRU`` )은 전체 입력 시퀀스(또는
-#   시퀀스의 배치)를 단순히 넣어주기만 하면 다른 비순환 레이어처럼 사용할 수
-#   있습니다. 우리는 ``encoder`` 에서 ``GRU`` 레이어를 이런 식으로 사용합니다.
+#   시퀀스의 배치)를 단순히 넣어주기만 하면 다른 비순환 계층처럼 사용할 수
+#   있습니다. 우리는 ``encoder`` 에서 ``GRU`` 계층을 이런 식으로 사용합니다.
 #   그 안이 실제로 어떻게 되어 있는지를 살펴보면, 매 시간 단계마다 은닉 상태를
 #   계산하는 반복 프로세스가 존재합니다. 또 다른 방법은, 이 모듈을 매번 한 단위
 #   시간만큼 수행할 수도 있습니다. 그 경우에는 우리가 ``decoder`` 모델을 다룰
@@ -1102,7 +1102,7 @@ def trainIters(model_name, voc, pairs, encoder, decoder, encoder_optimizer, deco
 # **연산 그래프:**
 #
 #    1) 인코더 모델로 입력을 포워드 패스합니다.
-#    2) 인코더의 마지막 은닉 레이어가 디코더의 첫 번째 은닉 레이어의 입력이 되도록 준비합니다.
+#    2) 인코더의 마지막 은닉 계층이 디코더의 첫 번째 은닉 계층의 입력이 되도록 준비합니다.
 #    3) 디코더의 첫 번째 입력을 SOS_token으로 초기화합니다.
 #    4) 디코더가 단어를 덧붙여 나갈 텐서를 초기화합니다.
 #    5) 반복적으로 각 단계마다 하나의 단어 토큰을 디코딩합니다.
@@ -1122,7 +1122,7 @@ def __init__(self, encoder, decoder):
     def forward(self, input_seq, input_length, max_length):
         # 인코더 모델로 입력을 포워드 패스합니다
         encoder_outputs, encoder_hidden = self.encoder(input_seq, input_length)
-        # 인코더의 마지막 은닉 레이어가 디코더의 첫 번째 은닉 레이어의 입력이 되도록 준비합니다
+        # 인코더의 마지막 은닉 계층이 디코더의 첫 번째 은닉 계층의 입력이 되도록 준비합니다
         decoder_hidden = encoder_hidden[:decoder.n_layers]
         # 디코더의 첫 번째 입력을 SOS_token으로 초기화합니다
         decoder_input = torch.ones(1, 1, device=device, dtype=torch.long) * SOS_token
@@ -1298,7 +1298,7 @@ def evaluateInput(encoder, decoder, searcher, voc):
 print_every = 1
 save_every = 500
 
-# Dropout 레이어를 학습 모드로 둡니다
+# Dropout 계층을 학습 모드로 둡니다
 encoder.train()
 decoder.train()
 
@@ -1335,7 +1335,7 @@ def evaluateInput(encoder, decoder, searcher, voc):
 # 여러분의 모델과 채팅을 해보고 싶다면 다음 블록을 수행하면 됩니다.
 #
 
-# Dropout 레이어를 평가( ``eval`` ) 모드로 설정합니다
+# Dropout 계층을 평가( ``eval`` ) 모드로 설정합니다
 encoder.eval()
 decoder.eval()
 

beginner_source/dcgan_faces_tutorial.py

@@ -374,7 +374,7 @@ def forward(self, input):
 # 판별하는 전통적인 이진 분류 신경망으로 볼 수 있습니다. 이때 :math:`D` 는
 # 3x64x64 이미지를 입력받아, Conv2d, BatchNorm2d, 그리고 LeakyReLU 계층을 통과시켜
 # 데이터를 가공시키고, 마지막 출력에서 Sigmoid 함수를 이용하여
-# 0~1 사이의 확률값으로 조정합니다. 이 아키텍쳐는 필요한 경우 더 다양한 레이어를 쌓을 수 있지만,
+# 0~1 사이의 확률값으로 조정합니다. 이 아키텍쳐는 필요한 경우 더 다양한 계층을 쌓을 수 있지만,
 # 배치 정규화와 LeakyReLU, 특히 보폭이 있는 (strided) 합성곱 계층을
 # 사용하는 것에는 이유가 있습니다.
 # DCGAN 논문에서는 보폭이 있는 합성곱 계층을 사용하는 것이 신경망 내에서 스스로의

beginner_source/fgsm_tutorial.py

@@ -157,7 +157,7 @@ def forward(self, x):
 # 미리 학습된 모델 읽어오기
 model.load_state_dict(torch.load(pretrained_model, map_location=device))
 
-# 모델을 평가 모드로 설정하기. 드롭아웃 레이어들을 위해 사용됨
+# 모델을 평가 모드로 설정하기. 드롭아웃 계층들을 위해 사용됨
 model.eval()