From d5eeed281e936184168519e36fb7d61705cac260 Mon Sep 17 00:00:00 2001 From: rltq Date: Wed, 6 May 2026 12:08:33 +0900 Subject: [PATCH 1/9] =?UTF-8?q?docs:=20=EB=B2=88=EC=97=AD=EC=96=B4=20?= =?UTF-8?q?=ED=86=B5=EC=9D=BC=20-=20'=EB=A0=88=EC=9D=B4=EC=96=B4'=EB=A5=BC?= =?UTF-8?q?=20'=EA=B3=84=EC=B8=B5'=EC=9C=BC=EB=A1=9C=20=ED=86=B5=EC=9D=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- advanced_source/neural_style_tutorial.py | 6 +- advanced_source/semi_structured_sparse.py | 8 +-- .../basics/optimization_tutorial.py | 4 +- .../blitz/neural_networks_tutorial.py | 18 +++--- beginner_source/chatbot_tutorial.py | 30 ++++----- beginner_source/dcgan_faces_tutorial.py | 2 +- beginner_source/fgsm_tutorial.py | 2 +- .../finetuning_torchvision_models_tutorial.py | 62 +++++++++---------- beginner_source/introyt/introyt1_tutorial.py | 2 +- .../introyt/tensorboardyt_tutorial.py | 2 +- .../nlp/sequence_models_tutorial.py | 2 +- beginner_source/nn_tutorial.py | 26 ++++---- beginner_source/torchtext_translation.py | 2 +- beginner_source/transformer_tutorial.py | 8 +-- .../char_rnn_classification_tutorial.py | 4 +- .../char_rnn_generation_tutorial.py | 2 +- intermediate_source/pipeline_tutorial.py | 2 +- .../seq2seq_translation_tutorial.py | 4 +- recipes_source/recipes/tuning_guide.py | 12 ++-- ...using_parameters_from_a_different_model.py | 2 +- 20 files changed, 100 insertions(+), 100 deletions(-) diff --git a/advanced_source/neural_style_tutorial.py b/advanced_source/neural_style_tutorial.py index 5accb2988..548cdaa35 100644 --- a/advanced_source/neural_style_tutorial.py +++ b/advanced_source/neural_style_tutorial.py @@ -142,7 +142,7 @@ 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}`)의 특징 맵을 함수에서 알고 있어야합니다. @@ -150,7 +150,7 @@ def imshow(tensor, title=None): # 거리 :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) diff --git a/advanced_source/semi_structured_sparse.py b/advanced_source/semi_structured_sparse.py index f7336189f..463c8e4af 100644 --- a/advanced_source/semi_structured_sparse.py +++ b/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)이 # `형상 제약 `_ -# 을 가지기 때문이며, 각각의 task ``nn.Linear`` 레이어는 이러한 제약을 충족하지 않기 때문입니다. +# 을 가지기 때문이며, 각각의 task ``nn.Linear`` 계층은 이러한 제약을 충족하지 않기 때문입니다. # sparsifier = WeightNormSparsifier( diff --git a/beginner_source/basics/optimization_tutorial.py b/beginner_source/basics/optimization_tutorial.py index d6d9ce9f7..565ae1e2f 100644 --- a/beginner_source/basics/optimization_tutorial.py +++ b/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) diff --git a/beginner_source/blitz/neural_networks_tutorial.py b/beginner_source/blitz/neural_networks_tutorial.py index 52330c763..1ac765075 100644 --- a/beginner_source/blitz/neural_networks_tutorial.py +++ b/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 diff --git a/beginner_source/chatbot_tutorial.py b/beginner_source/chatbot_tutorial.py index aa75059fc..636ad4865 100644 --- a/beginner_source/chatbot_tutorial.py +++ b/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 등 `__ # 이 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() diff --git a/beginner_source/dcgan_faces_tutorial.py b/beginner_source/dcgan_faces_tutorial.py index 244c71947..396e40ff4 100644 --- a/beginner_source/dcgan_faces_tutorial.py +++ b/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 논문에서는 보폭이 있는 합성곱 계층을 사용하는 것이 신경망 내에서 스스로의 diff --git a/beginner_source/fgsm_tutorial.py b/beginner_source/fgsm_tutorial.py index 5c0d93cc4..5293d7844 100644 --- a/beginner_source/fgsm_tutorial.py +++ b/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() diff --git a/beginner_source/finetuning_torchvision_models_tutorial.py b/beginner_source/finetuning_torchvision_models_tutorial.py index 68d0332cb..60c5fa141 100644 --- a/beginner_source/finetuning_torchvision_models_tutorial.py +++ b/beginner_source/finetuning_torchvision_models_tutorial.py @@ -23,9 +23,9 @@ # **미세 조정** 에서는, 사전 학습된 모델로 시작해 # 새로운 작업을 위해 모델의 매개변수 *모두* 를 업데이트 하여 본질적으로 전체 모델을 재학습합니다. # **특징 추출**에서는, 사전 학습된 모델로 시작해 -# 예측을 도출하는 최종 레이어의 가중치만 업데이트합니다. +# 예측을 도출하는 최종 계층의 가중치만 업데이트합니다. # 사전 학습된 CNN을 고정된 특징 추출기(feature-extractor)로 사용하고 -# 출력 레이어만 변경하기 때문에 이를 특징 추출이라고 합니다. +# 출력 계층만 변경하기 때문에 이를 특징 추출이라고 합니다. # 전송(transfer)에 대한 자세한 기술 정보는 # `여기 `__ 와 # `여기 `__ 를 재구성합니다. @@ -33,8 +33,8 @@ # 일반적으로 두 전이 학습 방법 모두 몇 가지 단계를 동일하게 따릅니다. # # - 사전 훈련된 모델을 초기화합니다. -# - 최종 레이어를 재구성하여 새 데이터 집합의 클래스 수와 동일한 수의 출력을 갖도록 합니다. -# - 새 데이터셋의 클래스 수와 동일한 출력 수를 갖도록 최종 레이어를 재구성합니다. +# - 최종 계층을 재구성하여 새 데이터 집합의 클래스 수와 동일한 수의 출력을 갖도록 합니다. +# - 새 데이터셋의 클래스 수와 동일한 출력 수를 갖도록 최종 계층을 재구성합니다. # - 훈련 중에 업데이트할 매개변수를 최적화 알고리즘에 맞게 정의합니다. # - 학습 단계를 실행합니다. # @@ -81,7 +81,7 @@ # ``feature_extract`` 는 미세 조정 또는 특징 추출 여부를 정의하는 부울(boolean)입니다. # ``feature_extract = False``이면 모델이 미세 조정되고 # 모든 모델의 매개변수가 업데이트됩니다. -# ``feature_extract = True``인 경우 마지막 레이어의 매개변수만 업데이트되고 +# ``feature_extract = True``인 경우 마지막 계층의 매개변수만 업데이트되고 # 다른 매개변수는 고정된 상태로 유지됩니다. # 최상위 데이터 디렉토리입니다. 여기서는 디렉토리 형식이 @@ -101,7 +101,7 @@ num_epochs = 15 # 특징 추출을 위한 플래그(flag)입니다. False일 경우, 전체 모델을 미세 조정하고 -# True일 경우 재형성된 레이어어의 매개변수만 업데이트합니다. +# True일 경우 재형성된 계층의 매개변수만 업데이트합니다. feature_extract = True @@ -220,7 +220,7 @@ def train_model(model, dataloaders, criterion, optimizer, num_epochs=25, is_ince # 기본적으로, 사전 학습된 모델을 읽어 들일 때 모든 매개변수가 # ``.requires_grad=True``로 설정되어 있으므로 # 처음부터 학습하거나 미세 조정하는 경우라면 괜찮습니다. -# 그러나 특징 추출 중이고 새로 초기화된 레이어에 대한 경사도만 계산하려는 경우 +# 그러나 특징 추출 중이고 새로 초기화된 계층에 대한 경사도만 계산하려는 경우 # 다른 모든 매개변수에는 경사도가 필요하지 않아야 합니다. # 이것은 나중에 더 이해를 할 수 있을 것입니다. # @@ -238,24 +238,24 @@ def set_parameter_requires_grad(model, feature_extracting): # 이제 가장 흥미로운 부분입니다. # 여기서는 각 네트워크의 재구성을 처리합니다. # 이 절차는 자동 절차가 아니며 각 모델마다 고유합니다. -# CNN 모델의 최종 레이어(FC layer라고도 불림)는 +# CNN 모델의 최종 계층(FC layer라고도 불림)는 # 데이터셋의 출력 클래스 수와 동일한 수의 노드를 가지고 있습니다. # 모든 모델은 이미 ImageNet에서 사전 학습 되었기 때문에 -# 각 클래스당 하나의 노드씩 1000 크기의 출력 레이어를 가지고 있습니다. +# 각 클래스당 하나의 노드씩 1000 크기의 출력 계층을 가지고 있습니다. # 여기서의 목표는 이전과 동일한 수의 입력을 갖고, -# 데이터셋의 클래스 수와 동일한 수의 출력을 갖도록 마지막 레이어를 재구성하는 것입니다. +# 데이터셋의 클래스 수와 동일한 수의 출력을 갖도록 마지막 계층을 재구성하는 것입니다. # 다음 섹션에서는 각 모델의 아키텍처를 # 개별적으로 변경하는 방법에 대해 설명하겠습니다. # 하지만 먼저, 미세 조정과 특징 추출의 차이점에 대한 # 한 가지 중요한 세부 사항이 있습니다. # -# 특징 추출 시 마지막 레이어의 매개변수만 업데이트 하고 싶을 때 -# 다시 말해, 재구성하는 레이어의 매개변수만 업데이트를 하고 싶은 경우가 있습니다. +# 특징 추출 시 마지막 계층의 매개변수만 업데이트 하고 싶을 때 +# 다시 말해, 재구성하는 계층의 매개변수만 업데이트를 하고 싶은 경우가 있습니다. # 이런 경우에는 변경하지 않는 매개변수의 경사도를 계산할 필요가 없으므로 # 효율성을 위해 .requires_grad 속성을 False로 설정합니다. # 기본적으로 이 속성은 True로 설정되어 있기 때문에 이 설정은 중요합니다. -# 그런 다음 새 레이어를 초기화할 때 기본적으로 새 매개변수에는 ``.requires_grad=True``가 있으므로 -# 새 레이어의 매개변수만 업데이트됩니다. +# 그런 다음 새 계층을 초기화할 때 기본적으로 새 매개변수에는 ``.requires_grad=True``가 있으므로 +# 새 계층의 매개변수만 업데이트됩니다. # 미세 조정할 때는 모든 .requires_grad를 기본값인 True로 설정할 수 있습니다. # # 마지막으로, inception_v3는 입력 크기를 (299,299)로 요구하지만, @@ -270,13 +270,13 @@ def set_parameter_requires_grad(model, feature_extracting): # 모두 torchvision 모델에서 사용할 수 있습니다. # 여기서는 데이터셋이 작고 클래스가 두 개 뿐인 Resnet18을 사용합니다. # 모델을 출력하면 아래 그림과 같이 -# 마지막 레이어가 완전히 연결된 레이어임을 알 수 있습니다. +# 마지막 계층이 완전히 연결된 계층임을 알 수 있습니다. # # :: # # (fc): Linear(in_features=512, out_features=1000, bias=True) # -# 입력 특징이 512개, 출력 특징이 2개인 선형 레이어가 되도록 +# 입력 특징이 512개, 출력 특징이 2개인 선형 계층이 되도록 # ``model.fc``를 다시 초기화해야 합니다. # # :: @@ -291,7 +291,7 @@ def set_parameter_requires_grad(model, feature_extracting): # Networks `__ 논문에 소개된 바 있으며 # ImageNet 데이터셋에서 최초로 매우 성공적인 CNN을 구현한 바 있습니다. # 모델의 아키텍처를 출력하면 모델 출력이 -# 분류기(classifier)의 6번째 레이어에서 나오는 것을 볼 수 있습니다. +# 분류기(classifier)의 6번째 계층에서 나오는 것을 볼 수 있습니다. # # :: # @@ -300,7 +300,7 @@ def set_parameter_requires_grad(model, feature_extracting): # (6): Linear(in_features=4096, out_features=1000, bias=True) # ) # -# 데이터셋과 함께 모델을 사용하려면 이 레이어를 다음과 같이 다시 초기화합니다. +# 데이터셋과 함께 모델을 사용하려면 이 계층을 다음과 같이 다시 초기화합니다. # # :: # @@ -311,10 +311,10 @@ def set_parameter_requires_grad(model, feature_extracting): # # VGG는 `Very Deep Convolutional Networks for # Large-Scale Image Recognition `__ 논문에서 소개되었습니다. -# Torchvision 다양한 길이와 배치 정규화 레이어가 있는 +# Torchvision 다양한 길이와 배치 정규화 계층이 있는 # 8가지 버전의 VGG를 제공합니다. # 여기서는 배치 정규화 기능이 있는 VGG-11을 사용합니다. -# 출력 레이어는 Alexnet과 유사합니다. +# 출력 계층은 Alexnet과 유사합니다. # # :: # @@ -323,7 +323,7 @@ def set_parameter_requires_grad(model, feature_extracting): # (6): Linear(in_features=4096, out_features=1000, bias=True) # ) # -# 따라서 동일한 기술을 사용해 출력 레이어를 수정합니다. +# 따라서 동일한 기술을 사용해 출력 계층을 수정합니다. # # :: # @@ -338,8 +338,8 @@ def set_parameter_requires_grad(model, feature_extracting): # AlexNet 수준의 정확도를 제공하면서 # 여기에 표시된 모델들과는 다른 출력 구조를 사용합니다. # Torchvision에는 두 가지 버전의 Squeezenet이 있고 여기서는 1.0 버전을 사용합니다. -# 출력은 분류기(classifier)의 첫 번째 레이어인 -# 1x1 합성곱 레이어에서 나옵니다. +# 출력은 분류기(classifier)의 첫 번째 계층인 +# 1x1 합성곱 계층에서 나옵니다. # # :: # @@ -350,7 +350,7 @@ def set_parameter_requires_grad(model, feature_extracting): # (3): AvgPool2d(kernel_size=13, stride=1, padding=0) # ) # -# 네트워크를 수정하기 위해 Conv2d 레이어를 다시 초기화하여 +# 네트워크를 수정하기 위해 Conv2d 계층을 다시 초기화하여 # 깊이 2의 특징 맵을 다음과 같이 출력합니다. # # :: @@ -364,13 +364,13 @@ def set_parameter_requires_grad(model, feature_extracting): # Networks `__ 논문에서 소개되었습니다. # Torchvision에는 4가지의 변형 Densenet이 있지만 # 여기서는 Densenet-121만 사용합니다. -# 출력 레이는 1024개의 입력 특징을 가진 선형 레이어 입니다. +# 출력 계층은 1024개의 입력 특징을 가진 선형 계층 입니다. # # :: # # (classifier): Linear(in_features=1024, out_features=1000, bias=True) # -# 네트워크를 재구성하기 위해 분류기(classifier)의 선형 레이어를 +# 네트워크를 재구성하기 위해 분류기(classifier)의 선형 계층을 # 다음과 같이 다시 초기화합니다. # # :: @@ -383,10 +383,10 @@ def set_parameter_requires_grad(model, feature_extracting): # 마지막으로 Inception v3은 `Rethinking the Inception # Architecture for Computer # Vision `__ 에서 처음 설명했습니다. -# 이 네트워크는 학습 시 두 개의 출력 레이어가 있다는 점이 독특합니다. +# 이 네트워크는 학습 시 두 개의 출력 계층이 있다는 점이 독특합니다. # 두 번째 출력은 보조(axuiliary) 출력으로 알려져 있으며 # 네트워크의 AuxLogits 부분에 포함되어 있습니다. -# 기본 출력은 네트워크 끝에 있는 선형 레이어이며 +# 기본 출력은 네트워크 끝에 있는 선형 계층이며 # 테스트할 때는 기본 출력만 고려합니다. # 읽어 들인 모델의 보조(auxiliary) 출력과 기본 출력은 다음과 같이 출력됩니다. # @@ -399,7 +399,7 @@ def set_parameter_requires_grad(model, feature_extracting): # ... # (fc): Linear(in_features=2048, out_features=1000, bias=True) # -# 이 모델을 미세 조정하려면 두 레이어를 +# 이 모델을 미세 조정하려면 두 계층을 # 다음과 같이 모두 재구성해야 합니다. # # :: @@ -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인 모든 매개변수가 # 최적화되어야 한다는 것을 알았습니다.* @@ -549,7 +549,7 @@ def initialize_model(model_name, num_classes, feature_extract, use_pretrained=Tr # 미세 조정할 때 이 목록은 길어야 하며 # 모든 모델의 매개변수를 포함해야 합니다. # 하지만, 특징을 추출할 때는 이 목록이 짧아야 하며 -# 재구성된 레이어의 가중치와 편향(bias)만 포함해야 합니다. +# 재구성된 계층의 가중치와 편향(bias)만 포함해야 합니다. # # GPU로 모델 전송 diff --git a/beginner_source/introyt/introyt1_tutorial.py b/beginner_source/introyt/introyt1_tutorial.py index a56783a6a..296649ec6 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 이미지크기를 가진 더미 입력을 생성합니다. diff --git a/beginner_source/introyt/tensorboardyt_tutorial.py b/beginner_source/introyt/tensorboardyt_tutorial.py index 19bbb2708..9c6d08f1a 100644 --- a/beginner_source/introyt/tensorboardyt_tutorial.py +++ b/beginner_source/introyt/tensorboardyt_tutorial.py @@ -220,7 +220,7 @@ def forward(self, x): # 검증 셋과 비교 running_vloss = 0.0 - # 평가 모드에서는 일부 모델의 특정 작업을 생략할 수 있습니다 예시: 드롭아웃 레이어 + # 평가 모드에서는 일부 모델의 특정 작업을 생략할 수 있습니다 예시: 드롭아웃 계층 net.train(False) # 평가 모드로 전환, 예시: 정규화(regularisation) 끄기 for j, vdata in enumerate(validation_loader, 0): vinputs, vlabels = vdata diff --git a/beginner_source/nlp/sequence_models_tutorial.py b/beginner_source/nlp/sequence_models_tutorial.py index 7f61e5231..e76d5fe23 100644 --- a/beginner_source/nlp/sequence_models_tutorial.py +++ b/beginner_source/nlp/sequence_models_tutorial.py @@ -165,7 +165,7 @@ def __init__(self, embedding_dim, hidden_dim, vocab_size, tagset_size): # 차원이 hidden_dim인 은닉 상태를 출력합니다. self.lstm = nn.LSTM(embedding_dim, hidden_dim) - # 은닉 상태 공간에서 태그 공간으로 매핑하는 선형 레이어 + # 은닉 상태 공간에서 태그 공간으로 매핑하는 선형 계층 self.hidden2tag = nn.Linear(hidden_dim, tagset_size) def forward(self, sentence): diff --git a/beginner_source/nn_tutorial.py b/beginner_source/nn_tutorial.py index b68b5a27e..c87d6a9c8 100644 --- a/beginner_source/nn_tutorial.py +++ b/beginner_source/nn_tutorial.py @@ -259,7 +259,7 @@ def accuracy(out, yb): # (라이브러리의 다른 부분에는 클래스가 포함되어 있습니다.) # 다양한 손실 및 활성화 함수뿐만 아니라, 풀링(pooling) 함수와 같이 신경망을 만드는데 # 편리한 몇 가지 함수도 여기에서 찾을 수 있습니다. -# (컨볼루션(convolution) 연산, 선형(linear) 레이어, 등을 수행하는 함수도 있지만, +# (컨볼루션(convolution) 연산, 선형(linear) 계층, 등을 수행하는 함수도 있지만, # 앞으로 보시겠지만 대개는 라이브러리의 다른 부분을 사용하여 더 잘 처리할 수 있습니다.) # # 만약 여러분들이 음의 로그 우도 손실과 로그 소프트맥스 (log softmax) 활성화 함수를 사용하는 경우, @@ -375,8 +375,8 @@ def fit(): # 초기화하고, ``xb @ self.weights + self.bias`` 를 계산하는 대신에, # 위의 모든 것을 해줄 PyTorch 클래스인 # `nn.Linear `_ 를 선형 -# 레이어로 사용합니다. -# PyTorch 에는 다양한 유형의 코드를 크게 단순화 할 수 있는 미리 정의된 레이어가 있고 이는 또한 +# 계층으로 사용합니다. +# PyTorch 에는 다양한 유형의 코드를 크게 단순화 할 수 있는 미리 정의된 계층이 있고 이는 또한 # 종종 기존 코드보다 속도를 빠르게 합니다. class Mnist_Logistic(nn.Module): @@ -585,7 +585,7 @@ def get_model(): # 각 에폭이 끝날 때 검증 손실을 계산하고 프린트 할 것입니다. # # (훈련 전에 항상 ``model.train()`` 을 호출하고, 추론(inference) 전에 ``model.eval()`` -# 을 호출합니다, 이는 ``nn.BatchNorm2d`` 및 ``nn.Dropout`` 과 같은 레이어에서 +# 을 호출합니다, 이는 ``nn.BatchNorm2d`` 및 ``nn.Dropout`` 과 같은 계층에서 # 이러한 다른 단계(훈련, 추론) 에 대한 적절한 동작이 일어나게 하기 위함입니다.) model, opt = get_model() @@ -672,13 +672,13 @@ def get_data(train_ds, valid_ds, bs): # CNN 으로 넘어가기 # -------------------- # -# 이제 3개의 컨볼루션 레이어로 신경망을 구축할 것입니다. +# 이제 3개의 컨볼루션 계층으로 신경망을 구축할 것입니다. # 이전 섹션의 어떤 함수도 모델의 형식에 대해 가정하지 않기 때문에, # 별도의 수정없이 CNN을 학습하는 데 사용할 수 있습니다. # # Pytorch의 사전정의된 # `Conv2d `_ 클래스를 -# 컨볼루션 레이어로 사용합니다. 3개의 컨볼루션 레이어로 CNN을 정의합니다. +# 컨볼루션 계층으로 사용합니다. 3개의 컨볼루션 계층으로 CNN을 정의합니다. # 각 컨볼루션 뒤에는 ReLU가 있습니다. 마지막으로 평균 풀링(average pooling)을 수행합니다. # (``view`` 는 PyTorch의 NumPy ``reshape`` 버전입니다.) @@ -719,10 +719,10 @@ def forward(self, xb): # ``Sequential`` 객체는 그 안에 포함된 각 모듈을 순차적으로 실행합니다. # 이것은 우리의 신경망을 작성하는 더 간단한 방법입니다. # -# 이를 활용하려면 주어진 함수에서 **사용자정의 레이어(custom layer)** 를 쉽게 +# 이를 활용하려면 주어진 함수에서 **사용자정의 계층(custom layer)** 을 쉽게 # 정의할 수 있어야 합니다. -# 예를 들어, PyTorch에는 `view` 레이어가 없으므로 우리의 신경망 용으로 만들어야 합니다. -# ``Lambda`` 는 ``Sequential`` 로 신경망을 정의할 때 사용할 수 있는 레이어를 생성할 것입니다. +# 예를 들어, PyTorch에는 `view` 계층이 없으므로 우리의 신경망 용으로 만들어야 합니다. +# ``Lambda`` 는 ``Sequential`` 로 신경망을 정의할 때 사용할 수 있는 계층을 생성할 것입니다. class Lambda(nn.Module): def __init__(self, func): @@ -764,7 +764,7 @@ def preprocess(x): # - 최종적으로 CNN 그리드 크기는 4\*4 라고 가정합니다. (이것은 우리가 사용한 평균 풀링 커널 크기 때문입니다.) # # 이 두 가지 가정을 제거하여 모델이 모든 2d 단일 채널(channel) 이미지에서 작동하도록 하겠습니다. -# 먼저 초기 Lambda 레이어를 제거하고 데이터 전처리를 제네레이터(generator)로 이동시킬 수 있습니다: +# 먼저 초기 Lambda 계층을 제거하고 데이터 전처리를 제네레이터(generator)로 이동시킬 수 있습니다: def preprocess(x, y): return x.view(-1, 1, 28, 28), y @@ -865,15 +865,15 @@ def preprocess(x, y): # # - ``torch.nn``: # -# + ``Module``: 함수처럼 동작하지만, 또한 상태(state) (예를 들어, 신경망의 레이어 가중치)를 +# + ``Module``: 함수처럼 동작하지만, 또한 상태(state) (예를 들어, 신경망의 계층 가중치)를 # 포함할 수 있는 호출 가능한 오브젝트를 생성합니다. # 이는 포함된 ``Parameter`` (들)가 어떤 것인지 알고, 모든 기울기를 0으로 설정하고 가중치 # 업데이트 등을 위해 반복할 수 있습니다. # + ``Parameter``: ``Module`` 에 역전파 동안 업데이트가 필요한 가중치가 있음을 알려주는 # 텐서용 래퍼입니다. `requires_grad` 속성이 설정된 텐서만 업데이트 됩니다. # + ``functional``: 활성화 함수, 손실 함수 등을 포함하는 모듈 (관례에 따라 일반적으로 -# ``F`` 네임스페이스로 임포트 됩니다) 이고, 물론 컨볼루션 및 선형 레이어 등에 대해서 -# 상태를 저장하지않는(non-stateful) 버전의 레이어를 포함합니다. +# ``F`` 네임스페이스로 임포트 됩니다) 이고, 물론 컨볼루션 및 선형 계층 등에 대해서 +# 상태를 저장하지않는(non-stateful) 버전의 계층을 포함합니다. # - ``torch.optim``: 역전파 단계에서 ``Parameter`` 의 가중치를 업데이트하는, # ``SGD`` 와 같은 옵티마이저를 포함합니다. # - ``Dataset``: ``TensorDataset`` 과 같이 PyTorch와 함께 제공되는 클래스를 포함하여 ``__len__`` 및 diff --git a/beginner_source/torchtext_translation.py b/beginner_source/torchtext_translation.py index 4656ed897..89408483e 100644 --- a/beginner_source/torchtext_translation.py +++ b/beginner_source/torchtext_translation.py @@ -142,7 +142,7 @@ def generate_batch(data_batch): # 참고 : 이 튜토리얼에서 사용하는 모델은 언어 번역을 위해 사용할 예시 모델입니다. 이 모델을 사용하는 것은 # 이 작업에 적당한 표준 모델이기 때문이지, 번역에 적합한 모델이기 때문은 아닙니다. 여러분이 최신 기술 트렌드를 # 잘 따라가고 있다면 잘 아시겠지만, 현재 번역에서 가장 뛰어난 모델은 Transformers입니다. PyTorch가 -# Transformer 레이어를 구현한 내용은 `여기 `__ +# Transformer 계층을 구현한 내용은 `여기 `__ # 에서 확인할 수 있으며 이 튜토리얼의 모델이 사용하는 "attention" 은 Transformer 모델에서 제안하는 # 멀티 헤드 셀프 어텐션(multi-headed self-attention) 과는 다르다는 점을 알려드립니다. diff --git a/beginner_source/transformer_tutorial.py b/beginner_source/transformer_tutorial.py index 5fe3bc27e..a2c659f60 100644 --- a/beginner_source/transformer_tutorial.py +++ b/beginner_source/transformer_tutorial.py @@ -30,15 +30,15 @@ ###################################################################### # 이 튜토리얼에서, 우리는 ``nn.TransformerEncoder`` 모델을 언어 모델링(language modeling) 과제에 대해서 학습시킬 것입니다. # 언어 모델링 과제는 주어진 단어 (또는 단어의 시퀀스) 가 다음에 이어지는 단어 시퀀스를 따를 가능성(likelihood)에 대한 확률을 할당하는 것입니다. -# 먼저, 토큰(token) 들의 시퀀스가 임베딩(embedding) 레이어로 전달되며, 이어서 포지셔널 인코딩(positional encoding) 레이어가 각 단어의 순서를 설명합니다. +# 먼저, 토큰(token) 들의 시퀀스가 임베딩(embedding) 계층으로 전달되며, 이어서 포지셔널 인코딩(positional encoding) 계층이 각 단어의 순서를 설명합니다. # (더 자세한 설명은 다음 단락을 참고해주세요.) # ``nn.TransformerEncoder`` 는 여러 개의 # `nn.TransformerEncoderLayer `__ -# 레이어로 구성되어 있습니다. -# ``nn.TransformerEncoder`` 내부의 셀프-어텐션(self-attention) 레이어들은 시퀀스 안에서의 이전 포지션에만 집중하도록 허용되기 때문에, +# 계층으로 구성되어 있습니다. +# ``nn.TransformerEncoder`` 내부의 셀프-어텐션(self-attention) 계층들은 시퀀스 안에서의 이전 포지션에만 집중하도록 허용되기 때문에, # 입력(input) 순서와 함께, 정사각 형태의 어텐션 마스크(attention mask) 가 필요합니다. # 언어 모델링 과제를 위해서, 미래의 포지션에 있는 모든 토큰들은 마스킹 되어야(가려져야) 합니다. -# 실제 단어를 얻기 위해서, ``nn.TransformerEncoder`` 의 출력은 로그-소프트맥스(log-Softmax) 로 이어지는 최종 선형(Linear) 레이어로 전달 됩니다. +# 실제 단어를 얻기 위해서, ``nn.TransformerEncoder`` 의 출력은 로그-소프트맥스(log-Softmax) 로 이어지는 최종 선형(Linear) 계층으로 전달 됩니다. # import math diff --git a/intermediate_source/char_rnn_classification_tutorial.py b/intermediate_source/char_rnn_classification_tutorial.py index 2be448c6a..5d55c7cbf 100644 --- a/intermediate_source/char_rnn_classification_tutorial.py +++ b/intermediate_source/char_rnn_classification_tutorial.py @@ -54,7 +54,7 @@ # (하지만 유니코드에서 ASCII로 변환은 해야 합니다) # # 첫번째 단계는 데이터를 정의하고 정리하는 것입니다. 초기에는 유니코드를 일반 ASCII로 변환하여 -# RNN 입력 레이어를 제한해야 합니다. 이는 유니코드 문자열을 ASCII로 변환하고 허용된 문자의 작은 집합만을 허용하여 이루어집니다. +# RNN 입력 계층을 제한해야 합니다. 이는 유니코드 문자열을 ASCII로 변환하고 허용된 문자의 작은 집합만을 허용하여 이루어집니다. import string import unicodedata @@ -72,7 +72,7 @@ def unicodeToAscii(s): ) ######################### -# 유니코드 알파벳 이름을 일반 ASCII로 변환하는 예시입니다. 이렇게 하면 입력 레이어를 단순화할 수 있습니다. +# 유니코드 알파벳 이름을 일반 ASCII로 변환하는 예시입니다. 이렇게 하면 입력 계층을 단순화할 수 있습니다. # print (f"converting 'Ślusàrski' to {unicodeToAscii('Ślusàrski')}") diff --git a/intermediate_source/char_rnn_generation_tutorial.py b/intermediate_source/char_rnn_generation_tutorial.py index dea92fb53..642b9b28e 100644 --- a/intermediate_source/char_rnn_generation_tutorial.py +++ b/intermediate_source/char_rnn_generation_tutorial.py @@ -138,7 +138,7 @@ def readLines(filename): # 우리는 출력을 다음 문자의 확률로 해석합니다. 샘플링 할 때, # 가장 확률이 높은 문자가 다음 입력 문자로 사용됩니다. # -# 더 나은 동작을 위해 두 번째 선형 레이어 +# 더 나은 동작을 위해 두 번째 선형 계층 # ``o2o`` (은닉과 출력을 결합한 후) 를 추가했습니다 . # 또한 Drop-out 계층이 있습니다. 이 계층은 주어진 확률(여기서는 0.1)로 # `무작위로 입력을 0 # `__ 으로 만듭니다. diff --git a/intermediate_source/pipeline_tutorial.py b/intermediate_source/pipeline_tutorial.py index 973f8ebb1..9093720d1 100644 --- a/intermediate_source/pipeline_tutorial.py +++ b/intermediate_source/pipeline_tutorial.py @@ -229,7 +229,7 @@ def get_batch(source, i): # 여러 GPU를 다루기 위해 프로세스 하나만 사용하고 있기 때문입니다. # # 그런 다음 파이프라인은 한 GPU에 8개의 트랜스포머와 -# 다른 GPU에 8개의 트랜스포머 레이어로 초기화됩니다. +# 다른 GPU에 8개의 트랜스포머 계층으로 초기화됩니다. # # .. note:: # 효율성을 위해 ``Pipe`` 에 전달된 ``nn.Sequential`` 이 diff --git a/intermediate_source/seq2seq_translation_tutorial.py b/intermediate_source/seq2seq_translation_tutorial.py index edfc6f01d..0c94a5eb4 100644 --- a/intermediate_source/seq2seq_translation_tutorial.py +++ b/intermediate_source/seq2seq_translation_tutorial.py @@ -792,7 +792,7 @@ def evaluateRandomly(encoder, decoder, n=10): ###################################################################### # # -# 드롭아웃(dropout) 레이어들을 평가 (``eval``) 모드로 설정합니다. +# 드롭아웃(dropout) 계층들을 평가 (``eval``) 모드로 설정합니다. encoder.eval() decoder.eval() @@ -860,7 +860,7 @@ def evaluateAndShowAttention(input_sentence): # - ``word2vec`` 또는 ``GloVe`` 같은 미리 학습된 word embedding 으로 # embedding 을 교체하십시오 # -# - 더 많은 레이어, 은닉 유닛, 더 많은 문장을 사용하십시오. +# - 더 많은 계층, 은닉 유닛, 더 많은 문장을 사용하십시오. # 학습 시간과 결과를 비교해 보십시오 # - 만약 같은 구문 두개의 쌍으로 된 번역 파일을 이용한다면, # (``I am test \t I am test``), 이것을 오토인코더로 diff --git a/recipes_source/recipes/tuning_guide.py b/recipes_source/recipes/tuning_guide.py index c2e19a5e8..9316bff64 100644 --- a/recipes_source/recipes/tuning_guide.py +++ b/recipes_source/recipes/tuning_guide.py @@ -142,7 +142,7 @@ def gelu(x): # 효율을 개선할 수 있습니다. # # 체크포인트 저장할 대상은 신중하게 선택해야 합니다. 가장 좋은 방법은 재계산 비용이 적은 대규모 -# 레이어의 출력을 저장하지 않는 것입니다. 예를 들어, 활성화 함수(예시: ``ReLU`` , ``Sigmoid`` +# 계층의 출력을 저장하지 않는 것입니다. 예를 들어, 활성화 함수(예시: ``ReLU`` , ``Sigmoid`` # , ``Tanh`` ), up/down 샘플링, 작은 누적 깊이(accumulation depth)를 가진 행렬-벡터 연산 # 등이 체크포인트 저장 대상으로 적합합니다. # @@ -408,8 +408,8 @@ def gelu(x): # # * `Deep Learning Performance Documentation # `_ -# 에서 자세한 정보와 레이어 유형에 따른 가이드라인을 참조하세요. -# * 레이어 크기가 고정되지 않고 다른 매개변수에서 유도되는 경우에도 명시적으로 패딩할 수 있습니다. +# 에서 자세한 정보와 계층 유형에 따른 가이드라인을 참조하세요. +# * 계층 크기가 고정되지 않고 다른 매개변수에서 유도되는 경우에도 명시적으로 패딩할 수 있습니다. # (예시: NLP 모델의 어휘 크기 등). # # * AMP 활성화하기 @@ -478,10 +478,10 @@ def gelu(x): # 따르고 필요한 변화도 all-reduce를 수행해야 합니다. ############################################################################### -# ``DistributedDataParallel(find_unused_parameters=True)`` 를 사용할 때 생성자와 실행 레이어 순서를 일치시키는 방법 +# ``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는 주어진 버킷의 모든 파라미터에 대한 변화도가 모두 준비되었을 때 비동기적으로 작동됩니다. @@ -493,7 +493,7 @@ def gelu(x): # # ``find_unused_parameters=False`` 가 (기본 설정)인 ``DistributedDataParallel`` 은 # 역전파 중에 발견된 연산 순서를 기반으로 자동으로 버킷을 형성합니다. -# ``find_unused_parameters=False`` 를 사용할 때는 최적의 성능을 달성하기 위해 레이어나 +# ``find_unused_parameters=False`` 를 사용할 때는 최적의 성능을 달성하기 위해 계층이나 # 파라미터의 순서를 재조정할 필요가 없습니다. ############################################################################### diff --git a/recipes_source/recipes/warmstarting_model_using_parameters_from_a_different_model.py b/recipes_source/recipes/warmstarting_model_using_parameters_from_a_different_model.py index 0a362a251..2a561014e 100644 --- a/recipes_source/recipes/warmstarting_model_using_parameters_from_a_different_model.py +++ b/recipes_source/recipes/warmstarting_model_using_parameters_from_a_different_model.py @@ -118,7 +118,7 @@ def forward(self, x): # 4. 모델 B로 불러오기 # ~~~~~~~~~~~~~~~~~~~~~~~ # -# 한 레이어의 매개변수를 다른 레이어로 불러오려 하는데 일부 키가 매치되지 +# 한 계층의 매개변수를 다른 계층으로 불러오려 하는데 일부 키가 매치되지 # 않는 상황이라고 해 봅시다. 그럴 때는 불러오려 하는 state_dict 의 # 매개변수 키의 이름을 바꿔서, 불러온 모델을 저장하려는 모델의 키와 # 매치되도록 해 주면 됩니다. From edcdb83b4fb444781ba5bb285c6e317e8bfe567c Mon Sep 17 00:00:00 2001 From: rltq Date: Wed, 6 May 2026 12:13:49 +0900 Subject: [PATCH 2/9] =?UTF-8?q?docs:=20=EB=B2=88=EC=97=AD=EC=96=B4=20?= =?UTF-8?q?=ED=86=B5=EC=9D=BC=20-=20'Dropout'=EC=9D=84=20'=EB=93=9C?= =?UTF-8?q?=EB=A1=AD=EC=95=84=EC=9B=83'=EC=9C=BC=EB=A1=9C=20=ED=86=B5?= =?UTF-8?q?=EC=9D=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- beginner_source/chatbot_tutorial.py | 4 ++-- beginner_source/transformer_tutorial.py | 2 +- intermediate_source/pipeline_tutorial.py | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/beginner_source/chatbot_tutorial.py b/beginner_source/chatbot_tutorial.py index 636ad4865..bc205174e 100644 --- a/beginner_source/chatbot_tutorial.py +++ b/beginner_source/chatbot_tutorial.py @@ -1298,7 +1298,7 @@ def evaluateInput(encoder, decoder, searcher, voc): print_every = 1 save_every = 500 -# Dropout 계층을 학습 모드로 둡니다 +# 드롭아웃 계층을 학습 모드로 둡니다 encoder.train() decoder.train() @@ -1335,7 +1335,7 @@ def evaluateInput(encoder, decoder, searcher, voc): # 여러분의 모델과 채팅을 해보고 싶다면 다음 블록을 수행하면 됩니다. # -# Dropout 계층을 평가( ``eval`` ) 모드로 설정합니다 +# 드롭아웃 계층을 평가( ``eval`` ) 모드로 설정합니다 encoder.eval() decoder.eval() diff --git a/beginner_source/transformer_tutorial.py b/beginner_source/transformer_tutorial.py index a2c659f60..2244fbbdd 100644 --- a/beginner_source/transformer_tutorial.py +++ b/beginner_source/transformer_tutorial.py @@ -257,7 +257,7 @@ def get_batch(source: Tensor, i: int) -> Tuple[Tensor, Tensor]: d_hid = 200 # ``nn.TransformerEncoder`` 에서 피드포워드 네트워크(feedforward network) 모델의 차원 nlayers = 2 # ``nn.TransformerEncoder`` 내부의 nn.TransformerEncoderLayer 개수 nhead = 2 # ``nn.MultiheadAttention`` 의 헤드 개수 -dropout = 0.2 # 드랍아웃(dropout) 확률 +dropout = 0.2 # 드롭아웃(dropout) 확률 model = TransformerModel(ntokens, emsize, nhead, d_hid, nlayers, dropout).to(device) diff --git a/intermediate_source/pipeline_tutorial.py b/intermediate_source/pipeline_tutorial.py index 9093720d1..876e8aafb 100644 --- a/intermediate_source/pipeline_tutorial.py +++ b/intermediate_source/pipeline_tutorial.py @@ -242,7 +242,7 @@ def get_batch(source, i): nhid = 4096 # ``nn.TransformerEncoder`` 에서 순전파(feedforward) 신경망 모델의 차원 nlayers = 12 # ``nn.TransformerEncoder`` 내부의 ``nn.TransformerEncoderLayer`` 개수 nhead = 16 # Multihead Attention 모델의 헤드 개수 -dropout = 0.2 # dropout 값 +dropout = 0.2 # 드롭아웃 값 from torch.distributed import rpc tmpfile = tempfile.NamedTemporaryFile() From 39d8f528d997f0ad65e70bc4346a84fa22f7e695 Mon Sep 17 00:00:00 2001 From: rltq Date: Wed, 6 May 2026 12:21:58 +0900 Subject: [PATCH 3/9] =?UTF-8?q?docs:=20=EB=B2=88=EC=97=AD=EC=96=B4=20?= =?UTF-8?q?=ED=86=B5=EC=9D=BC=20-=20'=EC=9D=B8=EC=88=98'=EB=A5=BC=20'?= =?UTF-8?q?=EC=9D=B8=EC=9E=90'=EB=A1=9C=20=ED=86=B5=EC=9D=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- beginner_source/introyt/tensorboardyt_tutorial.py | 2 +- beginner_source/nlp/deep_learning_tutorial.py | 2 +- beginner_source/nlp/sequence_models_tutorial.py | 2 +- intermediate_source/tensorboard_profiler_tutorial.py | 2 +- recipes_source/recipes/amp_recipe.py | 2 +- recipes_source/recipes/tuning_guide.py | 2 +- .../torch_compile_user_defined_triton_kernel_tutorial.py | 2 +- 7 files changed, 7 insertions(+), 7 deletions(-) diff --git a/beginner_source/introyt/tensorboardyt_tutorial.py b/beginner_source/introyt/tensorboardyt_tutorial.py index 9c6d08f1a..c7f15c6c9 100644 --- a/beginner_source/introyt/tensorboardyt_tutorial.py +++ b/beginner_source/introyt/tensorboardyt_tutorial.py @@ -142,7 +142,7 @@ def matplotlib_imshow(img, one_channel=False): # 또한 ``flush()`` 를 호출하여 이미지가 즉시 디스크에 기록되도록 합니다. # -# log_dir 인수 기본값은 "runs"입니다 - 하지만 구체적으로 정하는 것이 좋습니다. +# log_dir 인자 기본값은 "runs"입니다 - 하지만 구체적으로 정하는 것이 좋습니다. # 위에서 torch.utils.tensorboard.SummaryWriter를 가져왔습니다. writer = SummaryWriter('runs/fashion_mnist_experiment_1') diff --git a/beginner_source/nlp/deep_learning_tutorial.py b/beginner_source/nlp/deep_learning_tutorial.py index d11fa52cc..81418e10c 100644 --- a/beginner_source/nlp/deep_learning_tutorial.py +++ b/beginner_source/nlp/deep_learning_tutorial.py @@ -82,7 +82,7 @@ # # 빠른 참고: AI 클래스에 대한 소개에서 일부 신경망을 배웠지만 :math:`\sigma(x)` 가 기본이었을 것입니다. # 일반적으로 사람들은 실제로 그것을 사용하지 않고 피합니다. -# 이것은 변화도가 인수의 절댓값이 커짐에 따라 매우 빨리 *사라지기* 때문입니다. +# 이것은 변화도가 인자의 절댓값이 커짐에 따라 매우 빨리 *사라지기* 때문입니다. # 작은 변화도는 학습하기 어렵다는 것을 의미합니다. # 대부분의 사람들은 tanh 또는 ReLU를 기본값으로 사용합니다. # diff --git a/beginner_source/nlp/sequence_models_tutorial.py b/beginner_source/nlp/sequence_models_tutorial.py index e76d5fe23..6c968210a 100644 --- a/beginner_source/nlp/sequence_models_tutorial.py +++ b/beginner_source/nlp/sequence_models_tutorial.py @@ -78,7 +78,7 @@ # (아래의 "hidden"과 "out"의 마지막 슬라이스(slice)를 비교해 보면 둘은 동일합니다.) # 이렇게 하는 이유는 다음과 같습니다: # "out"은 시퀀스의 모든 은닉 상태에 대한 액세스를 제공하고, -# "hidden"은 나중에 lstm에 인수 형태로 전달하여 +# "hidden"은 나중에 lstm에 인자 형태로 전달하여 # 시퀀스를 계속하고, 역전파 하도록 합니다. # 추가로 두 번째 차원을 더합니다. inputs = torch.cat(inputs).view(len(inputs), 1, -1) diff --git a/intermediate_source/tensorboard_profiler_tutorial.py b/intermediate_source/tensorboard_profiler_tutorial.py index b4bdbee11..2aca8e3f8 100644 --- a/intermediate_source/tensorboard_profiler_tutorial.py +++ b/intermediate_source/tensorboard_profiler_tutorial.py @@ -339,7 +339,7 @@ def train(data): # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # # - 메모리 보기(Memory view) -# 메모리 프로파일을 설정하려면 ``torch.profiler.profile`` 인수에서 ``profile_memory``를 ``True``로 설정해야 합니다. +# 메모리 프로파일을 설정하려면 ``torch.profiler.profile`` 인자에서 ``profile_memory``를 ``True``로 설정해야 합니다. # # Azure의 기존 예제를 사용해 볼 수 있습니다. # diff --git a/recipes_source/recipes/amp_recipe.py b/recipes_source/recipes/amp_recipe.py index 35105687d..332f67595 100644 --- a/recipes_source/recipes/amp_recipe.py +++ b/recipes_source/recipes/amp_recipe.py @@ -143,7 +143,7 @@ def make_model(in_size, out_size, num_layers): # 는 변화도 스케일링 단계를 편리하게 수행합니다. # 수렴 실행의 시작에서 기본 인자를 사용하여 한 번 ``scaler`` 를 생성합니다. -# 신경망이 기본 ``GradScaler`` 인수로 수렴하지 않는다면, 이슈를 제출해주세요. +# 신경망이 기본 ``GradScaler`` 인자로 수렴하지 않는다면, 이슈를 제출해주세요. # 수렴 실행 전체에서 동일한 ``GradScaler`` 인스턴스를 사용해야 합니다. # 동일한 스크립트에서 여러 번의 수렴 실행을 수행할 경우, 각 실행은 전용의 새로운 ``GradScaler`` 인스턴스를 사용해야 합니다. # ``GradScaler`` 인스턴스는 가볍습니다. diff --git a/recipes_source/recipes/tuning_guide.py b/recipes_source/recipes/tuning_guide.py index 9316bff64..c4e2e29db 100644 --- a/recipes_source/recipes/tuning_guide.py +++ b/recipes_source/recipes/tuning_guide.py @@ -387,7 +387,7 @@ def gelu(x): # 장치에서 생성합니다. # ``torch.rand(size, device='cuda')`` # -# 이는 다음과 같이 ``device`` 인수를 받아 새로운 tensor를 생성하는 모든 함수에 적용됩니다: +# 이는 다음과 같이 ``device`` 인자를 받아 새로운 tensor를 생성하는 모든 함수에 적용됩니다: # `torch.rand() `_, # `torch.zeros() `_, # `torch.full() `_ diff --git a/recipes_source/torch_compile_user_defined_triton_kernel_tutorial.py b/recipes_source/torch_compile_user_defined_triton_kernel_tutorial.py index 6cc04c04f..f4e3c3f03 100644 --- a/recipes_source/torch_compile_user_defined_triton_kernel_tutorial.py +++ b/recipes_source/torch_compile_user_defined_triton_kernel_tutorial.py @@ -89,7 +89,7 @@ def add_fn(x, y): # 실행할 수 있습니다. 아래는 ``torch.compile``과 ``triton.autotune``을 사용하는 예제입니다. # # .. note:: -# ``torch.compile``은 ``triton.autotune``에 대한 configs와 key 인수만 지원합니다. +# ``torch.compile``은 ``triton.autotune``에 대한 configs와 key 인자만 지원합니다. # if not has_triton(): From e50899c175dd7959be736deda5a8fdfb64b4bcc5 Mon Sep 17 00:00:00 2001 From: rltq Date: Wed, 6 May 2026 12:27:17 +0900 Subject: [PATCH 4/9] =?UTF-8?q?docs:=20=EB=B2=88=EC=97=AD=EC=96=B4=20?= =?UTF-8?q?=ED=86=B5=EC=9D=BC=20-=20'=ED=8C=8C=EB=9D=BC=EB=AF=B8=ED=84=B0'?= =?UTF-8?q?=EB=A5=BC=20'=EB=A7=A4=EA=B0=9C=EB=B3=80=EC=88=98'=EB=A1=9C=20?= =?UTF-8?q?=ED=86=B5=EC=9D=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../static_quantization_tutorial.rst | 2 +- .../basics/optimization_tutorial.py | 2 +- beginner_source/fgsm_tutorial.py | 4 +- .../finetuning_torchvision_models_tutorial.py | 2 +- .../hyperparameter_tuning_tutorial.py | 10 ++-- beginner_source/introyt/introyt1_tutorial.py | 12 ++-- beginner_source/nlp/deep_learning_tutorial.py | 24 ++++---- intermediate_source/TP_tutorial.rst | 4 +- intermediate_source/ensembling.py | 2 +- intermediate_source/pipeline_tutorial.py | 4 +- intermediate_source/pruning_tutorial.py | 60 +++++++++---------- .../spatial_transformer_tutorial.py | 4 +- recipes_source/compiling_optimizer.rst | 4 +- recipes_source/recipes/amp_recipe.py | 6 +- recipes_source/recipes/tuning_guide.py | 6 +- .../recipes/zeroing_out_gradients.py | 4 +- 16 files changed, 75 insertions(+), 75 deletions(-) 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 565ae1e2f..65b95d60d 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 5293d7844..1be02f669 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 60c5fa141..68c2b600d 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 296649ec6..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 81418e10c..182cd1e80 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 876e8aafb..534afb394 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 332f67595..3d304e762 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 c4e2e29db..f04441d25 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는 마지막으로 도착하는 변화도를 기다리게 되며, @@ -494,7 +494,7 @@ def gelu(x): # ``find_unused_parameters=False`` 가 (기본 설정)인 ``DistributedDataParallel`` 은 # 역전파 중에 발견된 연산 순서를 기반으로 자동으로 버킷을 형성합니다. # ``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으로 만들 수 있습니다. From 389bb3abdd47009b1943f9f8270cb7a8074bede9 Mon Sep 17 00:00:00 2001 From: rltq Date: Wed, 6 May 2026 12:33:55 +0900 Subject: [PATCH 5/9] =?UTF-8?q?docs:=20=EB=B2=88=EC=97=AD=EC=96=B4=20?= =?UTF-8?q?=ED=86=B5=EC=9D=BC=20-=20'=EC=98=A4=EC=B0=A8=20=ED=96=89?= =?UTF-8?q?=EB=A0=AC'=EC=9D=84=20'=ED=98=BC=EB=8F=99=20=ED=96=89=EB=A0=AC'?= =?UTF-8?q?=EB=A1=9C=20=ED=86=B5=EC=9D=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- intermediate_source/tiatoolbox_tutorial.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/intermediate_source/tiatoolbox_tutorial.rst b/intermediate_source/tiatoolbox_tutorial.rst index b84463006..44285f14e 100644 --- a/intermediate_source/tiatoolbox_tutorial.rst +++ b/intermediate_source/tiatoolbox_tutorial.rst @@ -381,7 +381,7 @@ PatchPredictor 클래스는 PyTorch로 작성된 CNN 기반 분류기를 실행 ~~~~~~~~~~~~~~~~~~~~ 예측기(predictor) 객체를 생성한 후 ``patch`` 모드를 사용하여 ``predict`` 메소드를 호출합니다. -그런 다음, 분류 정확도와 오차 행렬(confusion matrix)을 계산합니다. +그런 다음, 분류 정확도와 혼동 행렬(confusion matrix)을 계산합니다. @@ -395,7 +395,7 @@ PatchPredictor 클래스는 PyTorch로 작성된 CNN 기반 분류기를 실행 acc = accuracy_score(label_list, output["predictions"]) logger.info("Classification accuracy: %f", acc) - # 패치 분류 결과를 위한 오차 행렬(confusion_matrix) 생성 및 시각화 + # 패치 분류 결과를 위한 혼동 행렬(confusion_matrix) 생성 및 시각화 conf = confusion_matrix(label_list, output["predictions"], normalize="true") df_cm = pd.DataFrame(conf, index=class_names, columns=class_names) df_cm From 937eacb125d83f75554796e104d8469df8068915 Mon Sep 17 00:00:00 2001 From: rltq Date: Wed, 6 May 2026 12:41:16 +0900 Subject: [PATCH 6/9] =?UTF-8?q?docs:=20=EB=B2=88=EC=97=AD=EC=96=B4=20?= =?UTF-8?q?=ED=86=B5=EC=9D=BC=20-=20'=EA=B8=B0=EC=9A=B8=EA=B8=B0'=EB=A5=BC?= =?UTF-8?q?=20'=EB=B3=80=ED=99=94=EB=8F=84'=EB=A1=9C=20=EB=B3=80=EA=B2=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- advanced_source/neural_style_tutorial.py | 10 +++--- advanced_source/numpy_extensions_tutorial.py | 4 +-- beginner_source/introyt/introyt1_tutorial.py | 12 +++---- .../nlp/sequence_models_tutorial.py | 2 +- .../nlp/word_embeddings_tutorial.py | 6 ++-- beginner_source/nn_tutorial.py | 34 +++++++++---------- beginner_source/transformer_tutorial.py | 2 +- .../autograd_saved_tensors_hooks_tutorial.py | 2 +- intermediate_source/forward_ad_usage.py | 10 +++--- .../optimizer_step_in_backward_tutorial.py | 4 +-- intermediate_source/pipeline_tutorial.py | 2 +- intermediate_source/tiatoolbox_tutorial.rst | 2 +- 12 files changed, 45 insertions(+), 45 deletions(-) diff --git a/advanced_source/neural_style_tutorial.py b/advanced_source/neural_style_tutorial.py index 548cdaa35..9c81c9cf2 100644 --- a/advanced_source/neural_style_tutorial.py +++ b/advanced_source/neural_style_tutorial.py @@ -151,7 +151,7 @@ def imshow(tensor, title=None): # # Content 거리를 계산하기 위해 사용되는 합성곱 계층 바로 뒤에 Content 손실 모듈을 추가합니다. # 이렇게 하면 입력 이미지가 입력될 때마다 Content 손실이 원하는 계층에서 -# 계산되고 autograd 을 통해 모든 기울기가 계산됩니다. +# 계산되고 autograd 을 통해 모든 변화도가 계산됩니다. # 이제 Content 손실 계층을 만들기 위해 Content 손실을 계산한 다음 계층의 입력을 반환하는 # ``forward`` 메소드를 정의해야합니다. # 계산된 손실은 모듈의 매개 변수로써 저장됩니다. @@ -161,7 +161,7 @@ class ContentLoss(nn.Module): def __init__(self, target,): super(ContentLoss, self).__init__() - # 기울기를 동적으로 계산하는데 사용되는 tree로부터 타깃 Content를 `분리(detach)` 합니다. + # 변화도를 동적으로 계산하는데 사용되는 tree로부터 타깃 Content를 `분리(detach)` 합니다. # 이것은 변수가 아니라 명시된 값입니다. # 그렇지 않으면 criterion의 forward 메소드에서 오류가 발생합니다. self.target = target.detach() @@ -174,7 +174,7 @@ def forward(self, input): # .. Note:: # **중요 세부 사항**: 모듈의 이름은 ``ContentLoss`` 지만, 실제 PyTorch의 손실 함수는 아닙니다. # 만약 Content 손실을 PyTorch의 손실 함수로 정의하려면 Pytorch의 autograd 함수를 생성하여 -# ``backward`` 메소드에서 수동으로 기울기를 다시 계산 및 구현 해야 합니다. +# ``backward`` 메소드에서 수동으로 변화도를 다시 계산 및 구현 해야 합니다. ###################################################################### # 스타일 손실(Style Loss) @@ -372,7 +372,7 @@ def get_style_model_and_losses(cnn, normalization_mean, normalization_std, # def get_input_optimizer(input_img): - # 입력이 기울기가 필요한 매개 변수임을 표시하는 줄 + # 입력이 변화도가 필요한 매개 변수임을 표시하는 줄 optimizer = optim.LBFGS([input_img]) return optimizer @@ -380,7 +380,7 @@ def get_input_optimizer(input_img): ###################################################################### # 마지막으로 뉴럴 변환(neural transfer)을 수행하는 함수를 정의해야 합니다. # 네트워크의 각 반복 동안, 업데이트된 입력이 주어지고 새로운 손실을 계산합니다. -# 각 손실 모듈(Loss module)의 ``backward`` 메소드를 실행하여 기울기를 동적으로 계산합니다. +# 각 손실 모듈(Loss module)의 ``backward`` 메소드를 실행하여 변화도를 동적으로 계산합니다. # optimizer는 모듈을 재평가하고 손실을 반환하는 “closure” 함수가 필요합니다. # # 여전히 해결해야 할 마지막 제약이 있습니다. diff --git a/advanced_source/numpy_extensions_tutorial.py b/advanced_source/numpy_extensions_tutorial.py index f08bf6a09..68194e849 100644 --- a/advanced_source/numpy_extensions_tutorial.py +++ b/advanced_source/numpy_extensions_tutorial.py @@ -72,7 +72,7 @@ def incorrect_fft(input): # # 학습 가능한 가중치를 가는 필터(커널)를 갖는 상호 상관 계층을 구현해보겠습니다. # -# 역전파 단계(backward pass)에서는 입력에 대한 기울기(gradient)와 필터에 대한 기울기를 계산합니다. +# 역전파 단계(backward pass)에서는 입력에 대한 변화도(gradient)와 필터에 대한 변화도를 계산합니다. from numpy import flip import numpy as np @@ -126,7 +126,7 @@ def forward(self, input): print("Gradient for the input map: ", input.grad) ############################################################### -# **기울기(gradient) 확인:** +# **변화도(gradient) 확인:** from torch.autograd.gradcheck import gradcheck diff --git a/beginner_source/introyt/introyt1_tutorial.py b/beginner_source/introyt/introyt1_tutorial.py index 0e846ceb7..56005b54f 100644 --- a/beginner_source/introyt/introyt1_tutorial.py +++ b/beginner_source/introyt/introyt1_tutorial.py @@ -286,7 +286,7 @@ def num_flat_features(self, x): # PyTorch tensor 형태로 변환합니다. # - ``transforms.Normalize()`` 는 tensor의 평균이 0이고 표준 편차가 1.0이 # 되도록 tensor의 값을 조정합니다. -# 대부분의 활성화 함수는 x = 0 부근에서 강한 기울기 값을 가지고 있어 데이터를 +# 대부분의 활성화 함수는 x = 0 부근에서 강한 변화도 값을 가지고 있어 데이터를 # 중앙으로 집중화하여 학습 속도를 높일 수 있습니다. # # 변환(transform)에 전달되는 값들은 각각 데이터셋에 있는 이미지들의 RGB 채널별 @@ -516,7 +516,7 @@ def forward(self, x): # 데이터를 통해 이미지와 정답값을 받습니다. inputs, labels = data - # 초기 기울기 매개변수를 0으로 설정합니다 + # 초기 변화도 매개변수를 0으로 설정합니다 optimizer.zero_grad() # forward + backward + optimize @@ -541,14 +541,14 @@ def forward(self, x): # **iterates over the training data** (4번째 라인)의 내부 루프가 있어 # 변환된 입력 이미지의 batch와 올바른 레이블을 제공합니다. # -# **기울기 값 초기화** (9번째 라인) 은 중요한 단계입니다. 기울기는 batch에 -# 걸쳐 누적됩니다. 모든 batch에 대해 기울기 값을 재설정하지 않으면 기울기 -# 값이 계속 누적되어 잘못된 기울기 값을 제공하여 학습이 불가능합니다. +# **변화도 값 초기화** (9번째 라인) 은 중요한 단계입니다. 변화도는 batch에 +# 걸쳐 누적됩니다. 모든 batch에 대해 변화도 값을 재설정하지 않으면 변화도 +# 값이 계속 누적되어 잘못된 변화도 값을 제공하여 학습이 불가능합니다. # # 12번째 라인에서는 batch 데이터를 **모델에게 예측을 요청** 합니다. # 다음 13번째라인에서 모델의 결과 값과 정답 값 차이인 손실값을 계산합니다. # -# 14번째 라인에서는 ``backward()`` 를 통해 모델의 학습 기울기를 계산합니다. +# 14번째 라인에서는 ``backward()`` 를 통해 모델의 학습 변화도를 계산합니다. # # 15번째 라인에서는 학습 단계의 최적화를 수행하는데 ``backward()`` # 를 통해 손실 값을 줄일 수 있는 방향으로 학습 가중치들을 조정합니다. diff --git a/beginner_source/nlp/sequence_models_tutorial.py b/beginner_source/nlp/sequence_models_tutorial.py index 6c968210a..f012f8733 100644 --- a/beginner_source/nlp/sequence_models_tutorial.py +++ b/beginner_source/nlp/sequence_models_tutorial.py @@ -205,7 +205,7 @@ def forward(self, sentence): # 3단계, 순전파 단계(forward pass)를 실행합니다. tag_scores = model(sentence_in) - # 4단계, 손실과 기울기를 계산하고, optimizer.step()을 호출하여 + # 4단계, 손실과 변화도를 계산하고, optimizer.step()을 호출하여 # 매개변수를 업데이트합니다. loss = loss_function(tag_scores, targets) loss.backward() diff --git a/beginner_source/nlp/word_embeddings_tutorial.py b/beginner_source/nlp/word_embeddings_tutorial.py index 2488ee2c5..33ea540a8 100644 --- a/beginner_source/nlp/word_embeddings_tutorial.py +++ b/beginner_source/nlp/word_embeddings_tutorial.py @@ -228,8 +228,8 @@ def forward(self, inputs): # 바꾸고 파이토치 텐서로 감싸줍시다.) context_idxs = torch.tensor([word_to_ix[w] for w in context], dtype=torch.long) - # 두번째. 토치는 기울기가 *누적* 됩니다. 새 인스턴스를 넣어주기 전에 - # 기울기를 초기화합니다. + # 두번째. 토치는 변화도가 *누적* 됩니다. 새 인스턴스를 넣어주기 전에 + # 변화도를 초기화합니다. model.zero_grad() # 세번째. 순전파를 통해 다음에 올 단어에 대한 로그 확률을 구합니다. @@ -238,7 +238,7 @@ def forward(self, inputs): # 네번째. 손실함수를 계산합니다. (파이토치에서는 목표 단어를 텐서로 감싸줘야 합니다.) loss = loss_function(log_probs, torch.tensor([word_to_ix[target]], dtype=torch.long)) - # 다섯번째. 역전파를 통해 기울기를 업데이트 해줍니다. + # 다섯번째. 역전파를 통해 변화도를 업데이트 해줍니다. loss.backward() optimizer.step() diff --git a/beginner_source/nn_tutorial.py b/beginner_source/nn_tutorial.py index c87d6a9c8..e8f0f7781 100644 --- a/beginner_source/nn_tutorial.py +++ b/beginner_source/nn_tutorial.py @@ -107,12 +107,12 @@ # PyTorch는 랜덤 또는 0으로만 이루어진 텐서를 생성하는 메소드를 제공하고, # 우리는 간단한 선형 모델의 가중치(weights)와 절편(bias)을 생성하기 위해서 이것을 사용할 것입니다. # 이들은 일반적인 텐서에 매우 특별한 한 가지가 추가된 것입니다: 우리는 PyTorch에게 이들이 -# 기울기(gradient)가 필요하다고 알려줍니다. +# 변화도(gradient)가 필요하다고 알려줍니다. # 이를 통해 PyTorch는 텐서에 행해지는 모든 연산을 기록하게 하고, -# 따라서 *자동적으로* 역전파(back-propagation) 동안에 기울기를 계산할 수 있습니다! +# 따라서 *자동적으로* 역전파(back-propagation) 동안에 변화도를 계산할 수 있습니다! # # 가중치에 대해서는 ``requires_grad`` 를 초기화(initialization) **다음에** 설정합니다, -# 왜냐하면 우리는 해당 단계가 기울기에 포함되는 것을 원치 않기 때문입니다. +# 왜냐하면 우리는 해당 단계가 변화도에 포함되는 것을 원치 않기 때문입니다. # (PyTorch에서 ``_`` 다음에 오는 메소드 이름은 연산이 인플레이스(in-place)로 수행되는 것을 의미합니다.) # # .. note:: `Xavier initialisation `_ @@ -125,7 +125,7 @@ bias = torch.zeros(10, requires_grad=True) ############################################################################### -# PyTorch의 기울기를 자동으로 계산 해주는 기능 덕분에, Python 표준 함수 +# PyTorch의 변화도를 자동으로 계산 해주는 기능 덕분에, Python 표준 함수 # (또는 호출 가능한 객체)를 모델로 사용할 수 있습니다! # 그러므로 간단한 선형 모델을 만들기 위해서 단순한 행렬 곱셈과 브로드캐스트(broadcast) # 덧셈을 사용하여 보겠습니다. 또한, 우리는 활성화 함수(activation function)가 필요하므로, @@ -155,7 +155,7 @@ def model(xb): ############################################################################### # 여러분이 보시듯이, ``preds`` 텐서(tensor)는 텐서 값 외에도, 또한 -# 기울기 함수(gradient function)를 담고 있습니다. +# 변화도 함수(gradient function)를 담고 있습니다. # 우리는 나중에 이것을 역전파(backpropagation)를 위해 사용할 것입니다. # 이제 손실함수(loss function)로 사용하기 위한 음의 로그 우도(negative log-likelihood)를 # 구현합시다. (다시 말하지만, 우리는 표준 Python을 사용할 수 있습니다.): @@ -195,17 +195,17 @@ def accuracy(out, yb): # - 데이터의 미니배치를 선택 (``bs`` 크기) # - 모델을 이용하여 예측 수행 # - 손실 계산 -# - ``loss.backward()`` 를 이용하여 모델의 기울기 업데이트, 이 경우에는, ``weights`` 와 ``bias``. +# - ``loss.backward()`` 를 이용하여 모델의 변화도 업데이트, 이 경우에는, ``weights`` 와 ``bias``. # -# 이제 우리는 이 기울기들을 이용하여 가중치와 절편을 업데이트 합니다. +# 이제 우리는 이 변화도들을 이용하여 가중치와 절편을 업데이트 합니다. # 우리는 이것을 ``torch.no_grad()`` 컨텍스트 매니저(context manager) 내에서 실행합니다, -# 왜냐하면 이러한 실행이 다음 기울기의 계산에 기록되지 않기를 원하기 때문입니다. -# PyTorch의 자동 기울기(Autograd)가 어떻게 연산을 기록하는지 +# 왜냐하면 이러한 실행이 다음 변화도의 계산에 기록되지 않기를 원하기 때문입니다. +# PyTorch의 자동 변화도(Autograd)가 어떻게 연산을 기록하는지 # `여기 `_\에서 더 알아볼 수 있습니다. # -# 그러고 나서 기울기를 0으로 설정합니다, 그럼으로써 다음 루프(loop)에 준비하게 됩니다. -# 그렇지 않으면, 우리의 기울기들은 일어난 모든 연산의 누적 집계를 기록하게 되어버립니다. -# (즉, ``loss.backward()`` 가 이미 저장된 것을 대체하기보단, 기존 값에 기울기를 *더하게* 됩니다). +# 그러고 나서 변화도를 0으로 설정합니다, 그럼으로써 다음 루프(loop)에 준비하게 됩니다. +# 그렇지 않으면, 우리의 변화도들은 일어난 모든 연산의 누적 집계를 기록하게 되어버립니다. +# (즉, ``loss.backward()`` 가 이미 저장된 것을 대체하기보단, 기존 값에 변화도를 *더하게* 됩니다). # # .. tip:: 여러분들은 PyTorch 코드에 대하여 표준 python 디버거(debugger)를 사용할 수 있으므로, # 매 단계마다 다양한 변수 값을 점검할 수 있습니다. @@ -320,7 +320,7 @@ def forward(self, xb): ############################################################################### # 이전에는 훈련 루프를 위해 이름 별로 각 매개변수(parameter)의 값을 업데이트하고 다음과 같이 -# 각 매개 변수에 대한 기울기들을 개별적으로 수동으로 0으로 제거해야 했습니다: +# 각 매개 변수에 대한 변화도들을 개별적으로 수동으로 0으로 제거해야 했습니다: # # .. code-block:: python # @@ -423,8 +423,8 @@ def forward(self, xb): # opt.step() # opt.zero_grad() # -# (``optim.zero_grad()`` 는 기울기를 0으로 재설정 해줍니다. 다음 미니 배치에 대한 -# 기울기를 계산하기 전에 호출해야 합니다.) +# (``optim.zero_grad()`` 는 변화도를 0으로 재설정 해줍니다. 다음 미니 배치에 대한 +# 변화도를 계산하기 전에 호출해야 합니다.) from torch import optim @@ -572,7 +572,7 @@ def get_model(): # # 검증 데이터셋에 대한 배치 크기는 학습 데이터셋 배치 크기의 2배를 사용할 것입니다. # 이는 검증 데이터셋에 대해서는 역전파(backpropagation)가 필요하지 않으므로 메모리를 -# 덜 사용하기 때문입니다 (기울기를 저장할 필요가 없음). +# 덜 사용하기 때문입니다 (변화도를 저장할 필요가 없음). # 더 큰 배치 크기를 사용하여 손실을 더 빨리 계산하기 위해 이렇게 합니다. train_ds = TensorDataset(x_train, y_train) @@ -867,7 +867,7 @@ def preprocess(x, y): # # + ``Module``: 함수처럼 동작하지만, 또한 상태(state) (예를 들어, 신경망의 계층 가중치)를 # 포함할 수 있는 호출 가능한 오브젝트를 생성합니다. -# 이는 포함된 ``Parameter`` (들)가 어떤 것인지 알고, 모든 기울기를 0으로 설정하고 가중치 +# 이는 포함된 ``Parameter`` (들)가 어떤 것인지 알고, 모든 변화도를 0으로 설정하고 가중치 # 업데이트 등을 위해 반복할 수 있습니다. # + ``Parameter``: ``Module`` 에 역전파 동안 업데이트가 필요한 가중치가 있음을 알려주는 # 텐서용 래퍼입니다. `requires_grad` 속성이 설정된 텐서만 업데이트 됩니다. diff --git a/beginner_source/transformer_tutorial.py b/beginner_source/transformer_tutorial.py index 2244fbbdd..84a61bd50 100644 --- a/beginner_source/transformer_tutorial.py +++ b/beginner_source/transformer_tutorial.py @@ -272,7 +272,7 @@ def get_batch(source: Tensor, i: int) -> Tuple[Tensor, Tensor]: # `SGD `__ (확률적 경사 하강법) 옵티마이저(optimizer)와 # 함께 사용하였습니다. 학습률(learning rate)는 5.0으로 초기화하였으며 `StepLR `__ # 스케쥴을 따릅니다. 학습하는 동안, `nn.utils.clip_grad_norm\_ `__ -# 을 사용하여 기울기(gradient)가 폭발(exploding)하지 않도록 합니다. +# 을 사용하여 변화도(gradient)가 폭발(exploding)하지 않도록 합니다. # import copy diff --git a/intermediate_source/autograd_saved_tensors_hooks_tutorial.py b/intermediate_source/autograd_saved_tensors_hooks_tutorial.py index 43bf5ee5e..02d651580 100644 --- a/intermediate_source/autograd_saved_tensors_hooks_tutorial.py +++ b/intermediate_source/autograd_saved_tensors_hooks_tutorial.py @@ -6,7 +6,7 @@ ###################################################################### -# 파이토치는 일반적으로 역전파를 통해 기울기를 계산합니다. +# 파이토치는 일반적으로 역전파를 통해 변화도를 계산합니다. # 그러나 특정 작업에서는 역전파를 수행하기 위한 중간결과를 저장해야 합니다. # 이번 튜토리얼에서는 이러한 tensor를 저장/검색하는 방법과 # 패킹/언패킹 절차를 제어하는 hooks을 정의하는 방법을 안내합니다. diff --git a/intermediate_source/forward_ad_usage.py b/intermediate_source/forward_ad_usage.py index 9ca4d8a1f..6ed1285c2 100644 --- a/intermediate_source/forward_ad_usage.py +++ b/intermediate_source/forward_ad_usage.py @@ -13,7 +13,7 @@ 기본 사용법 -------------------------------------------------------------------- -역전파 모드 자동 미분(Reverse-mode Automatic Differentiation)과 달리, 순전파 모드 자동 미분은 순전파(forward pass)를 진행하며 기울기(gradient)를 즉시(계산을 미루지 않고) 계산합니다. 순전파 모드 자동 미분으로 방향성 도함수를 계산하려면, 먼저 입력을 방향성 도함수의 방향을 나타내는 다른 tensor(야코비안-벡터 곱의 `v`에 해당)와 연결한 뒤 이전과 같이 순전파를 수행하면 됩니다. 'primal'이라고 부르는 입력이 'tangent'라고 부르는 '방향' tensor와 연결될 때, 결과로 나오는 새로운 tensor 객체는 이중수(dual numbers) [0] 와의 관련성 때문에 '이중 tensor(dual tensor)'라고 불립니다. +역전파 모드 자동 미분(Reverse-mode Automatic Differentiation)과 달리, 순전파 모드 자동 미분은 순전파(forward pass)를 진행하며 변화도(gradient)를 즉시(계산을 미루지 않고) 계산합니다. 순전파 모드 자동 미분으로 방향성 도함수를 계산하려면, 먼저 입력을 방향성 도함수의 방향을 나타내는 다른 tensor(야코비안-벡터 곱의 `v`에 해당)와 연결한 뒤 이전과 같이 순전파를 수행하면 됩니다. 'primal'이라고 부르는 입력이 'tangent'라고 부르는 '방향' tensor와 연결될 때, 결과로 나오는 새로운 tensor 객체는 이중수(dual numbers) [0] 와의 관련성 때문에 '이중 tensor(dual tensor)'라고 불립니다. 순전파가 수행될 때, 입력 tensor 중 하나라도 이중 tensor이면 함수의 '민감도(sensitivity)'를 전파하기 위해 추가적인 연산이 수행됩니다. @@ -121,7 +121,7 @@ class Fn(torch.autograd.Function): @staticmethod def forward(ctx, foo): result = torch.exp(foo) - # ``ctx`` 에 저장된 tensor는 이후의 순전파 기울기 + # ``ctx`` 에 저장된 tensor는 이후의 순전파 변화도 # 계산에 사용할 수 있습니다. ctx.result = result return result @@ -144,10 +144,10 @@ def jvp(ctx, gI): dual_output = fn(dual_input) jvp = fwAD.unpack_dual(dual_output).tangent -# 사용자 정의 autograd 함수가 기울기를 올바르게 계산하는지 확인하려면 +# 사용자 정의 autograd 함수가 변화도를 올바르게 계산하는지 확인하려면 # ``autograd.gradcheck`` 를 사용하는 것이 중요합니다. 기본적으로 -# ``gradcheck`` 는 역전파 모드(reverse-mode) 자동 미분 기울기만 확인합니다. -# ``check_forward_ad=True`` 를 지정하여 순전파 기울기도 확인하도록 할 수 있습니다. +# ``gradcheck`` 는 역전파 모드(reverse-mode) 자동 미분 변화도만 확인합니다. +# ``check_forward_ad=True`` 를 지정하여 순전파 변화도도 확인하도록 할 수 있습니다. # 만약 함수에 대한 역전파를 구현하지 않았다면, ``check_backward_ad=False``, # ``check_undefined_grad=False``, ``check_batched_grad=False`` 를 지정하여 # ``gradcheck`` 가 역전파 모드 자동 미분이 필요한 테스트를 건너뛰도록 할 수 있습니다. diff --git a/intermediate_source/optimizer_step_in_backward_tutorial.py b/intermediate_source/optimizer_step_in_backward_tutorial.py index ec2217222..c0a5f1dba 100644 --- a/intermediate_source/optimizer_step_in_backward_tutorial.py +++ b/intermediate_source/optimizer_step_in_backward_tutorial.py @@ -151,7 +151,7 @@ def train(model, optimizer): # ``Tensor.register_post_accumulate_grad_hook(hook)`` API와 우리가 사용할 방법 # """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" # 이 방법은 ``backward()`` 동안 변화도를 저장하지 않아도 된다는 점에 의존합니다. -# 대신, 기울기가 누적되면 즉시 해당 매개변수에 대해 옵티마이저를 적용하고, 해당 +# 대신, 변화도가 누적되면 즉시 해당 매개변수에 대해 옵티마이저를 적용하고, 해당 # 변화도를 완전히 제거합니다! 이렇게 하면 옵티마이저 단계를 위해 큰 변화도 버퍼를 # 유지할 필요가 없어집니다. # @@ -249,7 +249,7 @@ def train(model): # 변화도가 계산되자마자 매우 빠르게 해제되었는데, 이는 가능한 한 옵티마이저 단계를 # 앞당겼기 때문입니다. 야호! 참고로, 나머지 ~1.2GB 의 메모리 절약은 옵티마이저를 # 매개변수별 옵티마이저로 나누면서 중간 단계의 메모리 사용량이 줄어든 덕분입니다. -# 하지만 이것은 기울기 메모리 절약보다는 `덜 중요한` 부분인데, 왜냐하면 중간 단계의 +# 하지만 이것은 변화도 메모리 절약보다는 `덜 중요한` 부분인데, 왜냐하면 중간 단계의 # 메모리 절약은 이 기술 없이도 ``foreach=False`` 옵션을 수정해 주는 것만으로 # 달성할 수 있기 때문입니다. # diff --git a/intermediate_source/pipeline_tutorial.py b/intermediate_source/pipeline_tutorial.py index 534afb394..9bbbbc77f 100644 --- a/intermediate_source/pipeline_tutorial.py +++ b/intermediate_source/pipeline_tutorial.py @@ -307,7 +307,7 @@ def get_total_params(module: torch.nn.Module): # 는 확률적 경사하강법(stochastic gradient descent method)을 구현합니다. 초기 # 학습률(learning rate)은 5.0로 설정됩니다. `StepLR `__ 는 # 에폭(epoch)에 따라서 학습률을 조절하는 데 사용됩니다. 학습하는 동안, -# 기울기 폭발(gradient exploding)을 방지하기 위해 모든 기울기를 함께 조정(scale)하는 함수 +# 변화도 폭발(gradient exploding)을 방지하기 위해 모든 변화도를 함께 조정(scale)하는 함수 # `nn.utils.clip_grad_norm\_ `__ # 을 이용합니다. # diff --git a/intermediate_source/tiatoolbox_tutorial.rst b/intermediate_source/tiatoolbox_tutorial.rst index 44285f14e..bddf407c7 100644 --- a/intermediate_source/tiatoolbox_tutorial.rst +++ b/intermediate_source/tiatoolbox_tutorial.rst @@ -823,7 +823,7 @@ TIAToolbox는 PyTorch의 `nn.Module Date: Wed, 6 May 2026 12:44:35 +0900 Subject: [PATCH 7/9] =?UTF-8?q?docs:=20=EB=B2=88=EC=97=AD=EC=96=B4=20?= =?UTF-8?q?=ED=86=B5=EC=9D=BC=20-=20'=ED=9B=88=EB=A0=A8'=EC=9D=84=20'?= =?UTF-8?q?=ED=95=99=EC=8A=B5'=EC=9C=BC=EB=A1=9C=20=EB=B3=80=EA=B2=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- advanced_source/neural_style_tutorial.py | 12 +++--- beginner_source/basics/autogradqs_tutorial.py | 2 +- beginner_source/dcgan_faces_tutorial.py | 8 ++-- beginner_source/fgsm_tutorial.py | 2 +- .../finetuning_torchvision_models_tutorial.py | 20 ++++----- .../hyperparameter_tuning_tutorial.py | 8 ++-- beginner_source/introyt/introyt1_tutorial.py | 2 +- .../introyt/tensorboardyt_tutorial.py | 18 ++++---- beginner_source/nlp/advanced_tutorial.py | 8 ++-- beginner_source/nlp/deep_learning_tutorial.py | 2 +- .../nlp/sequence_models_tutorial.py | 8 ++-- .../nlp/word_embeddings_tutorial.py | 2 +- beginner_source/nn_tutorial.py | 42 +++++++++---------- beginner_source/torchtext_translation.py | 4 +- beginner_source/transformer_tutorial.py | 2 +- .../autograd_saved_tensors_hooks_tutorial.py | 6 +-- .../char_rnn_classification_tutorial.py | 2 +- ...rced_alignment_with_torchaudio_tutorial.py | 2 +- intermediate_source/mario_rl_tutorial.py | 4 +- intermediate_source/pipeline_tutorial.py | 4 +- .../reinforcement_q_learning.py | 4 +- recipes_source/recipes/amp_recipe.py | 4 +- .../custom_dataset_transforms_loader.py | 2 +- .../recipes/defining_a_neural_network.py | 2 +- recipes_source/recipes/tuning_guide.py | 2 +- ...using_parameters_from_a_different_model.py | 2 +- .../recipes/zeroing_out_gradients.py | 2 +- 27 files changed, 88 insertions(+), 88 deletions(-) diff --git a/advanced_source/neural_style_tutorial.py b/advanced_source/neural_style_tutorial.py index 9c81c9cf2..cd187c36c 100644 --- a/advanced_source/neural_style_tutorial.py +++ b/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가 # `여기 `__ 에서 제안했던 것처럼, # L-BFGS 알고리즘을 사용하여 경사 하강법을 수행합니다. -# 네트워크 훈련과 다르게 Content / Style 손실을 최소화하기 위해 입력 이미지를 훈련하려고 합니다. +# 네트워크 학습과 다르게 Content / Style 손실을 최소화하기 위해 입력 이미지를 학습하려고 합니다. # 파이토치 L-BFGS optimizer ``optim.LBFGS`` 를 만들고 최적화 할 텐서로 이미지를 전달합니다. # diff --git a/beginner_source/basics/autogradqs_tutorial.py b/beginner_source/basics/autogradqs_tutorial.py index cf401203f..0d218f7d6 100644 --- a/beginner_source/basics/autogradqs_tutorial.py +++ b/beginner_source/basics/autogradqs_tutorial.py @@ -201,7 +201,7 @@ ###################################################################### # .. note:: 이전에는 매개변수 없이 ``backward()`` 함수를 호출했습니다. 이는 본질적으로 # ``backward(torch.tensor(1.0))`` 을 호출하는 것과 동일하며, -# 신경망 훈련 중의 손실과 같은 스칼라-값 함수의 변화도를 계산하는 유용한 방법입니다. +# 신경망 학습 중의 손실과 같은 스칼라-값 함수의 변화도를 계산하는 유용한 방법입니다. # ###################################################################### diff --git a/beginner_source/dcgan_faces_tutorial.py b/beginner_source/dcgan_faces_tutorial.py index 396e40ff4..541739a11 100644 --- a/beginner_source/dcgan_faces_tutorial.py +++ b/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 `__ 에서 미니 배치(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): # 무엇을 더 시도해볼 수 있을까요? # # - 결과물이 얼마나 더 좋아지는지 확인해보기 위해서 학습시간을 늘려볼 수 있습니다 -# - 다른 데이터셋을 이용해 훈련시켜보거나, 이미지의 사이즈를 다르게 해보거나, 아키텍쳐의 구성을 바꿔볼 수도 있습니다 +# - 다른 데이터셋을 이용해 학습시켜보거나, 이미지의 사이즈를 다르게 해보거나, 아키텍쳐의 구성을 바꿔볼 수도 있습니다 # - `여기 `__ 에서 더욱 멋진 GAN 프로젝트들을 찾을수도 있죠 # - `음악 `__ 을 작곡하는 GAN도 만들 수 있습니다 # diff --git a/beginner_source/fgsm_tutorial.py b/beginner_source/fgsm_tutorial.py index 1be02f669..36ba61be3 100644 --- a/beginner_source/fgsm_tutorial.py +++ b/beginner_source/fgsm_tutorial.py @@ -8,7 +8,7 @@ 이 글을 읽고 있다면, 여러분은 이미 머신러닝 모델이 얼마나 효과적인지 그 진가를 알고 있을 것입니다. 머신 러닝 연구는 ML(Machine Learning) 모델을 더욱 빠르고 정확하며 효율적이게 하는 방향으로 진행 되고 있습니다. -그러나 모델을 속이려하는 적에 대한 보안과 견고함은 모델을 설계하고 훈련할 때 종종 간과되는 부분입니다. +그러나 모델을 속이려하는 적에 대한 보안과 견고함은 모델을 설계하고 학습할 때 종종 간과되는 부분입니다. 이 튜토리얼은 ML 모델들의 보안 취약점에 대한 인식을 높이고, 요즘 화두가 되고있는 적대적 머신 러닝에 대한 통찰력을 제공할 것입니다. 이미지에 눈치챌 수 없는 작은 변화(perturbation)를 추가하면 모델 성능이 크게 달라질 수 있다는 사실에 놀랄 수 있습니다. diff --git a/beginner_source/finetuning_torchvision_models_tutorial.py b/beginner_source/finetuning_torchvision_models_tutorial.py index 68c2b600d..6611bf33b 100644 --- a/beginner_source/finetuning_torchvision_models_tutorial.py +++ b/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) 출력을 사용하고, 전체 모델 손실은 # `여기 `__ 에 설명된 대로 @@ -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의 특별한 경우입니다. diff --git a/beginner_source/hyperparameter_tuning_tutorial.py b/beginner_source/hyperparameter_tuning_tutorial.py index 56c352654..6a396486a 100644 --- a/beginner_source/hyperparameter_tuning_tutorial.py +++ b/beginner_source/hyperparameter_tuning_tutorial.py @@ -14,7 +14,7 @@ `Ray 의 분산 기계 학습 엔진 `_ 을 통해 학습을 지원합니다. 이 튜토리얼은 Ray Tune을 파이토치 학습 workflow에 통합하는 방법을 알려줍니다. -CIFAR10 이미지 분류기를 훈련하기 위해 `파이토치 문서에서 이 튜토리얼을 `_ 확장할 것입니다. +CIFAR10 이미지 분류기를 학습하기 위해 `파이토치 문서에서 이 튜토리얼을 `_ 확장할 것입니다. 아래와 같이 약간의 수정만 추가하면 됩니다. @@ -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)를 얻고 모든 것들을 출력하여 확인할 수 있습니다. # # 전체 주요 기능은 다음과 같습니다. diff --git a/beginner_source/introyt/introyt1_tutorial.py b/beginner_source/introyt/introyt1_tutorial.py index 56005b54f..4294b452c 100644 --- a/beginner_source/introyt/introyt1_tutorial.py +++ b/beginner_source/introyt/introyt1_tutorial.py @@ -573,7 +573,7 @@ def forward(self, x): # [2, 12000] loss: 1.267 # Finished Training # -# 손실 값은 단조롭게 감소하며, 이는 모델이 훈련 데이터셋에서 성능을 +# 손실 값은 단조롭게 감소하며, 이는 모델이 학습 데이터셋에서 성능을 # 계속 향상시키고 있음을 보여줍니다. # # 마지막 단계로 모델이 단순하게 학습 데이터셋을 “기억” 하는 것이 아니라 diff --git a/beginner_source/introyt/tensorboardyt_tutorial.py b/beginner_source/introyt/tensorboardyt_tutorial.py index c7f15c6c9..df40cfa44 100644 --- a/beginner_source/introyt/tensorboardyt_tutorial.py +++ b/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 `__)에서 열었다면, # 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) diff --git a/beginner_source/nlp/advanced_tutorial.py b/beginner_source/nlp/advanced_tutorial.py index b4cda9e34..8a300072d 100644 --- a/beginner_source/nlp/advanced_tutorial.py +++ b/beginner_source/nlp/advanced_tutorial.py @@ -278,7 +278,7 @@ def forward(self, sentence): # 이 함수와 위의 _forward_alg를 헷갈리 return score, tag_seq ##################################################################### -# 훈련 실행 +# 학습 실행 START_TAG = "" @@ -286,7 +286,7 @@ def forward(self, sentence): # 이 함수와 위의 _forward_alg를 헷갈리 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)) diff --git a/beginner_source/nlp/deep_learning_tutorial.py b/beginner_source/nlp/deep_learning_tutorial.py index 182cd1e80..f50254d00 100644 --- a/beginner_source/nlp/deep_learning_tutorial.py +++ b/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) diff --git a/beginner_source/nlp/sequence_models_tutorial.py b/beginner_source/nlp/sequence_models_tutorial.py index f012f8733..d794a419b 100644 --- a/beginner_source/nlp/sequence_models_tutorial.py +++ b/beginner_source/nlp/sequence_models_tutorial.py @@ -145,7 +145,7 @@ def prepare_sequence(seq, to_ix): tag_to_ix = {"DET": 0, "NN": 1, "V": 2} # 각 태그에 고유한 번호 할당 # 이것들은 일반적으로 32나 64차원에 가깝습니다. -# 훈련할 때 가중치가 어떻게 변하는지 확인할 수 있도록, 작게 유지하겠습니다. +# 학습할 때 가중치가 어떻게 변하는지 확인할 수 있도록, 작게 유지하겠습니다. EMBEDDING_DIM = 6 HIDDEN_DIM = 6 @@ -183,9 +183,9 @@ def forward(self, sentence): loss_function = nn.NLLLoss() optimizer = optim.SGD(model.parameters(), lr=0.1) -# 훈련 전의 점수를 확인하세요. +# 학습 전의 점수를 확인하세요. # 출력의 i,j요소는 단어 i에 대한 태그 j의 점수입니다. -# 여기서는 훈련을 할 필요가 없으므로, 코드는 torch.no_grad()로 래핑 되어 있습니다. +# 여기서는 학습을 할 필요가 없으므로, 코드는 torch.no_grad()로 래핑 되어 있습니다. with torch.no_grad(): inputs = prepare_sequence(training_data[0][0], word_to_ix) tag_scores = model(inputs) @@ -211,7 +211,7 @@ def forward(self, sentence): loss.backward() optimizer.step() -# 훈련 후의 점수를 확인해 보세요. +# 학습 후의 점수를 확인해 보세요. with torch.no_grad(): inputs = prepare_sequence(training_data[0][0], word_to_ix) tag_scores = model(inputs) diff --git a/beginner_source/nlp/word_embeddings_tutorial.py b/beginner_source/nlp/word_embeddings_tutorial.py index 33ea540a8..6ed50f4e4 100644 --- a/beginner_source/nlp/word_embeddings_tutorial.py +++ b/beginner_source/nlp/word_embeddings_tutorial.py @@ -258,7 +258,7 @@ def forward(self, inputs): # 이 모델은 문장 내에서 주변 단어, 즉 앞 몇 단어와 뒤 몇 단어를 보고 특정 # 단어를 예측하는데, 언어 모델링과는 달리 순차적이지도 않고 확률적이지도 않습니다. # 주로 CBOW는 복잡한 모델의 초기 입력값으로 쓰일 단어 임베딩을 빠르게 학습하는 -# 데에 쓰입니다. 이것을 *사전 훈련된(pre-trained) 임베딩* 이라고 부르죠. +# 데에 쓰입니다. 이것을 *사전 학습된(pre-trained) 임베딩* 이라고 부르죠. # 몇 퍼센트 정도의 성능 향상을 기대할 수 있는 기법입니다. # # CBOW 모델은 다음과 같습니다. 목표 단어 :math:`w_i` 와 그 양쪽에 :math:`N` 개의 diff --git a/beginner_source/nn_tutorial.py b/beginner_source/nn_tutorial.py index e8f0f7781..03dda0b79 100644 --- a/beginner_source/nn_tutorial.py +++ b/beginner_source/nn_tutorial.py @@ -190,7 +190,7 @@ def accuracy(out, yb): print(accuracy(preds, yb)) ############################################################################### -# 이제 우리는 훈련 루프(training loop)를 실행할 수 있습니다. 매 반복마다, 다음을 수행할 것입니다: +# 이제 우리는 학습 루프(training loop)를 실행할 수 있습니다. 매 반복마다, 다음을 수행할 것입니다: # # - 데이터의 미니배치를 선택 (``bs`` 크기) # - 모델을 이용하여 예측 수행 @@ -215,7 +215,7 @@ def accuracy(out, yb): from IPython.core.debugger import set_trace lr = 0.5 # 학습률(learning rate) -epochs = 2 # 훈련에 사용할 에폭(epoch) 수 +epochs = 2 # 학습에 사용할 에폭(epoch) 수 for epoch in range(epochs): for i in range((n - 1) // bs + 1): @@ -236,7 +236,7 @@ def accuracy(out, yb): ############################################################################### # 이제 다 됐습니다: 제일 간단한 신경망(neural network)의 모든 것을 밑바닥부터 생성하고 -# 훈련하였습니다! (이번에는 은닉층(hidden layer)이 없기 때문에, +# 학습하였습니다! (이번에는 은닉층(hidden layer)이 없기 때문에, # 로지스틱 회귀(logistic regression)입니다). # # 이제 손실과 정확도를 이전 값들과 비교하면서 확인해봅시다. @@ -282,7 +282,7 @@ def model(xb): ############################################################################### # ``nn.Module`` 을 이용하여 리팩토링 하기 # ----------------------------------------- -# 다음으로, 더 명확하고 간결한 훈련 루프를 위해 ``nn.Module`` 및 ``nn.Parameter`` 를 사용합니다. +# 다음으로, 더 명확하고 간결한 학습 루프를 위해 ``nn.Module`` 및 ``nn.Parameter`` 를 사용합니다. # 우리는 ``nn.Module`` (자체가 클래스이고 상태를 추적할 수 있는) 하위 클래스(subclass)를 만듭니다. # 이 경우에는, 포워드(forward) 단계에 대한 가중치, 절편, 그리고 메소드(method) 등을 유지하는 # 클래스를 만들고자 합니다. @@ -319,7 +319,7 @@ def forward(self, xb): print(loss_func(model(xb), yb)) ############################################################################### -# 이전에는 훈련 루프를 위해 이름 별로 각 매개변수(parameter)의 값을 업데이트하고 다음과 같이 +# 이전에는 학습 루프를 위해 이름 별로 각 매개변수(parameter)의 값을 업데이트하고 다음과 같이 # 각 매개 변수에 대한 변화도들을 개별적으로 수동으로 0으로 제거해야 했습니다: # # .. code-block:: python @@ -342,7 +342,7 @@ def forward(self, xb): # model.zero_grad() # # -# 이제 이것을 나중에 다시 실행할 수 있도록 ``fit`` 함수로 작은 훈련 루프를 감쌀 것입니다. +# 이제 이것을 나중에 다시 실행할 수 있도록 ``fit`` 함수로 작은 학습 루프를 감쌀 것입니다. def fit(): for epoch in range(epochs): @@ -468,7 +468,7 @@ def get_model(): # PyTorch 의 `TensorDataset `_ # 은 텐서를 감싸는(wrapping) Dataset 입니다. # 길이와 인덱싱 방식을 정의함으로써 텐서의 첫 번째 차원을 따라 반복, 인덱싱 및 슬라이스(slice)하는 방법도 제공합니다. -# 이렇게하면 훈련 할 때 동일한 라인에서 독립(independent) 변수와 종속(dependent) 변수에 쉽게 액세스 할 수 있습니다. +# 이렇게하면 학습 할 때 동일한 라인에서 독립(independent) 변수와 종속(dependent) 변수에 쉽게 액세스 할 수 있습니다. from torch.utils.data import TensorDataset @@ -553,19 +553,19 @@ def get_model(): print(loss_func(model(xb), yb)) ############################################################################### -# PyTorch의 nn.Module, nn.Parameter, Dataset 및 DataLoader 덕분에 이제 훈련 루프가 +# PyTorch의 nn.Module, nn.Parameter, Dataset 및 DataLoader 덕분에 이제 학습 루프가 # 훨씬 더 작아지고 이해하기 쉬워졌습니다. # 이제 실제로 효과적인 모델을 만드는 데 필요한 기본 기능을 추가해 보겠습니다. # # 검증(validation) 추가하기 # --------------------------- # -# 섹션 1에서, 우리는 훈련 데이터에 사용하기 위해 합리적인 훈련 루프를 설정하려고했습니다. +# 섹션 1에서, 우리는 학습 데이터에 사용하기 위해 합리적인 학습 루프를 설정하려고했습니다. # 실전에서, 여러분들은 과적합(overfitting)을 확인하기 위해서 **항상** # `검증 데이터셋(validation set) `_ 이 # 있어야 합니다. # -# 훈련 데이터를 섞는(shuffling) 것은 배치와 과적합 사이의 상관관계를 방지하기 위해 +# 학습 데이터를 섞는(shuffling) 것은 배치와 과적합 사이의 상관관계를 방지하기 위해 # `중요합니다. `_ # 반면에, 검증 손실(validation loss)은 검증 데이터셋을 섞든 안섞든 동일합니다. # 데이터를 섞는 것은 추가 시간이 걸리므로, 검증 데이터를 섞는 것은 의미가 없습니다. @@ -584,9 +584,9 @@ def get_model(): ############################################################################### # 각 에폭이 끝날 때 검증 손실을 계산하고 프린트 할 것입니다. # -# (훈련 전에 항상 ``model.train()`` 을 호출하고, 추론(inference) 전에 ``model.eval()`` +# (학습 전에 항상 ``model.train()`` 을 호출하고, 추론(inference) 전에 ``model.eval()`` # 을 호출합니다, 이는 ``nn.BatchNorm2d`` 및 ``nn.Dropout`` 과 같은 계층에서 -# 이러한 다른 단계(훈련, 추론) 에 대한 적절한 동작이 일어나게 하기 위함입니다.) +# 이러한 다른 단계(학습, 추론) 에 대한 적절한 동작이 일어나게 하기 위함입니다.) model, opt = get_model() @@ -611,10 +611,10 @@ def get_model(): # ---------------------------------- # # 이제 우리는 우리만의 작은 리팩토링을 수행할 것입니다. -# 훈련 데이터셋과 검증 데이터셋 모두에 대한 손실을 계산하는 유사한 프로세스를 두 번 거치므로, +# 학습 데이터셋과 검증 데이터셋 모두에 대한 손실을 계산하는 유사한 프로세스를 두 번 거치므로, # 이를 하나의 배치에 대한 손실을 계산하는 자체 함수 ``loss_batch`` 로 만들어보겠습니다. # -# 훈련 데이터셋에 대한 옵티마이저를 전달하고 이를 사용하여 역전파를 수행합니다. +# 학습 데이터셋에 대한 옵티마이저를 전달하고 이를 사용하여 역전파를 수행합니다. # 검증 데이터셋의 경우 옵티마이저를 전달하지 않으므로 메소드가 역전파를 수행하지 않습니다. @@ -629,7 +629,7 @@ def loss_batch(model, loss_func, xb, yb, opt=None): return loss.item(), len(xb) ############################################################################### -# ``fit`` 은 모델을 훈련하고 각 에폭에 대한 훈련 및 검증 손실을 계산하는 작업을 수행합니다. +# ``fit`` 은 모델을 학습하고 각 에폭에 대한 학습 및 검증 손실을 계산하는 작업을 수행합니다. import numpy as np @@ -659,15 +659,15 @@ def get_data(train_ds, valid_ds, bs): ) ############################################################################### -# 이제 dataloader를 가져오고 모델을 훈련하는 전체 프로세스를 3 줄의 코드로 실행할 수 있습니다: +# 이제 dataloader를 가져오고 모델을 학습하는 전체 프로세스를 3 줄의 코드로 실행할 수 있습니다: train_dl, valid_dl = get_data(train_ds, valid_ds, bs) model, opt = get_model() fit(epochs, model, loss_func, opt, train_dl, valid_dl) ############################################################################### -# 이러한 기본 3줄의 코드를 사용하여 다양한 모델을 훈련할 수 있습니다. -# 컨볼루션 신경망(CNN)을 훈련하는 데 사용할 수 있는지 살펴 보겠습니다! +# 이러한 기본 3줄의 코드를 사용하여 다양한 모델을 학습할 수 있습니다. +# 컨볼루션 신경망(CNN)을 학습하는 데 사용할 수 있는지 살펴 보겠습니다! # # CNN 으로 넘어가기 # -------------------- @@ -701,7 +701,7 @@ def forward(self, xb): ############################################################################### # `모멘텀(Momentum) `_ 은 -# 이전 업데이트도 고려하고 일반적으로 더 빠른 훈련으로 이어지는 확률적 경사하강법(stochastic gradient descent) +# 이전 업데이트도 고려하고 일반적으로 더 빠른 학습으로 이어지는 확률적 경사하강법(stochastic gradient descent) # 의 변형입니다. model = Mnist_CNN() @@ -850,11 +850,11 @@ def preprocess(x, y): # ----------------- # # 이제 PyTorch를 사용하여 다양한 유형의 모델을 학습하는 데 사용할 수 있는 일반 데이터 파이프 라인과 -# 훈련 루프가 있습니다. +# 학습 루프가 있습니다. # 이제 모델 학습이 얼마나 간단한지 확인하려면 `mnist_sample 노트북 `__ 을 살펴보세요. # # 물론 데이터 증강(data augmentation), 초매개변수 조정(hyperparameter tuning), -# 훈련과정 모니터링(monitoring training), 전이 학습(transfer learning) 등과 같이 +# 학습과정 모니터링(monitoring training), 전이 학습(transfer learning) 등과 같이 # 추가하고 싶은 항목들이 많이 있을 것입니다. # 이러한 기능들은 이 튜토리얼에 표시된 것과 동일한 설계 접근 방식을 사용하여 개발된 fastai 라이브러리에서 # 사용할 수 있으며, 모델을 더욱 발전시키려는 실무자에게 자연스러운 다음 단계를 제공합니다. diff --git a/beginner_source/torchtext_translation.py b/beginner_source/torchtext_translation.py index 89408483e..1434a4596 100644 --- a/beginner_source/torchtext_translation.py +++ b/beginner_source/torchtext_translation.py @@ -132,7 +132,7 @@ def generate_batch(data_batch): # ``nn.Module`` 과 ``Optimizer`` 정의하기 # ------------------------------------------ # 대부분은 ``torchtext`` 가 알아서 해줍니다 : 데이터셋이 만들어지고 반복자가 정의되면, 이 튜토리얼에서 -# 우리가 해야 할 일이라고는 그저 ``nn.Module`` 와 ``Optimizer`` 를 모델로서 정의하고 훈련시키는 것이 전부입니다. +# 우리가 해야 할 일이라고는 그저 ``nn.Module`` 와 ``Optimizer`` 를 모델로서 정의하고 학습시키는 것이 전부입니다. # # # 이 튜토리얼에서 사용할 모델은 `이곳 `__ 에서 설명하고 있는 구조를 따르고 있으며, @@ -387,7 +387,7 @@ def count_parameters(model: nn.Module): criterion = nn.CrossEntropyLoss(ignore_index=PAD_IDX) ###################################################################### -# 마지막으로 이 모델을 훈련하고 평가합니다 : +# 마지막으로 이 모델을 학습하고 평가합니다 : import math import time diff --git a/beginner_source/transformer_tutorial.py b/beginner_source/transformer_tutorial.py index 84a61bd50..bd214c89d 100644 --- a/beginner_source/transformer_tutorial.py +++ b/beginner_source/transformer_tutorial.py @@ -137,7 +137,7 @@ def forward(self, x: Tensor) -> Tensor: # %%bash # pip install torchdata # -# 어휘(vocab) 객체는 훈련 데이터셋(train dataset) 에 의하여 만들어지고, 토큰(token)을 텐서(tensor)로 수치화하는데 사용됩니다. +# 어휘(vocab) 객체는 학습 데이터셋(train dataset) 에 의하여 만들어지고, 토큰(token)을 텐서(tensor)로 수치화하는데 사용됩니다. # Wikitext-2에서 보기 드문 토큰(rare token)은 `` 로 표현됩니다. # # 주어진 1D 벡터의 시퀀스 데이터에서, ``batchify()`` 함수는 데이터를 ``batch_size`` 컬럼들로 정렬합니다. diff --git a/intermediate_source/autograd_saved_tensors_hooks_tutorial.py b/intermediate_source/autograd_saved_tensors_hooks_tutorial.py index 02d651580..954454ffe 100644 --- a/intermediate_source/autograd_saved_tensors_hooks_tutorial.py +++ b/intermediate_source/autograd_saved_tensors_hooks_tutorial.py @@ -32,7 +32,7 @@ ###################################################################### -# (일반적으로) 모델을 훈련하는데 평가보다 더 많은 메모리를 사용하는 이유는 무엇일까요? +# (일반적으로) 모델을 학습하는데 평가보다 더 많은 메모리를 사용하는 이유는 무엇일까요? # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -92,7 +92,7 @@ def f(x): ###################################################################### # 위의 예제에서 미분(grad)없이 실행하면 범위내의 ``x`` 와 ``y`` 는 유지되지만 # 그래프에서는 ``f(x)`` 와 ``f(f(x))`` 가 추가로 저장됩니다. -# 따라서 훈련 중 정방향 경로를 실행하면 평가중에 +# 따라서 학습 중 정방향 경로를 실행하면 평가중에 # (더 정확하게는 자동미분(auto grad)가 필요하지 않은 경우보다) # 메모리 사용량이 더 많아지게 됩니다. @@ -258,7 +258,7 @@ def unpack(packed): ###################################################################### # 매우 빈번하게, tensor 계산 그래프 GPU에 살아 있습니다. -# 대부분 경우에서 모델이 평가중에 정상적으로 수행되지만 훈련 중에 메모리가 부족하다면, +# 대부분 경우에서 모델이 평가중에 정상적으로 수행되지만 학습 중에 메모리가 부족하다면, # 계산 그래프에서 tensor에 대한 참조 유지가 # GPU 메모리를 부족하게 만드는 원인이 됩니다. # diff --git a/intermediate_source/char_rnn_classification_tutorial.py b/intermediate_source/char_rnn_classification_tutorial.py index 5d55c7cbf..efd359955 100644 --- a/intermediate_source/char_rnn_classification_tutorial.py +++ b/intermediate_source/char_rnn_classification_tutorial.py @@ -22,7 +22,7 @@ "은닉 상태(Hidden State)"를 출력하고, 다음 단계에 이전 단계의 은닉 상태를 전달합니다. 단어가 속한 클래스로 출력되도록 최종 예측으로 선택합니다. -구체적으로, 18개 언어로 된 수천 개의 성(姓)을 훈련시키고, +구체적으로, 18개 언어로 된 수천 개의 성(姓)을 학습시키고, 철자에 따라 이름이 어떤 언어인지 예측합니다. """ ###################################################################### diff --git a/intermediate_source/forced_alignment_with_torchaudio_tutorial.py b/intermediate_source/forced_alignment_with_torchaudio_tutorial.py index 6e4b0f63f..c7b6bb128 100644 --- a/intermediate_source/forced_alignment_with_torchaudio_tutorial.py +++ b/intermediate_source/forced_alignment_with_torchaudio_tutorial.py @@ -16,7 +16,7 @@ :py:func:`torchaudio.functional.forced_align` 의 사용법에 대해 보여주고 있습니다. 만약 본인만의 코퍼스에 대해 강제 정렬하려는 경우, :py:class:`torchaudio.pipelines.Wav2Vec2FABundle` 를 사용하는 것을 추천합니다. - 이는 강제 정렬을 위해 특별히 훈련된 사전 훈련 모델과 함께 :py:func:`~torchaudio.functional.forced_align` 및 여러 함수를 결합하여 사용할 수 있게 합니다. + 이는 강제 정렬을 위해 특별히 학습된 사전 학습 모델과 함께 :py:func:`~torchaudio.functional.forced_align` 및 여러 함수를 결합하여 사용할 수 있게 합니다. 사용법에 대한 자세한 내용은 다국어 데이터를 위한 강제 정렬을 설명하는 `Forced alignment for multilingual data `__ 를 참조하세요. """ diff --git a/intermediate_source/mario_rl_tutorial.py b/intermediate_source/mario_rl_tutorial.py index a7274dd06..5b5d411a3 100755 --- a/intermediate_source/mario_rl_tutorial.py +++ b/intermediate_source/mario_rl_tutorial.py @@ -782,6 +782,6 @@ def record(self, episode, epsilon, step): # 결론 # """"""""""""""" # -# 이 튜토리얼에서는 PyTorch를 사용하여 게임 플레이 AI를 훈련하는 방법을 살펴보았습니다. `OpenAI gym `__ -# 에 있는 어떤 게임이든 동일한 방법으로 AI를 훈련시키고 게임을 진행할 수 있습니다. 이 튜토리얼이 도움이 되었기를 바라며, +# 이 튜토리얼에서는 PyTorch를 사용하여 게임 플레이 AI를 학습하는 방법을 살펴보았습니다. `OpenAI gym `__ +# 에 있는 어떤 게임이든 동일한 방법으로 AI를 학습시키고 게임을 진행할 수 있습니다. 이 튜토리얼이 도움이 되었기를 바라며, # `Github 저장소 `__ 에서 편하게 저자들에게 연락을 하셔도 됩니다! diff --git a/intermediate_source/pipeline_tutorial.py b/intermediate_source/pipeline_tutorial.py index 9bbbbc77f..31a6bc4ce 100644 --- a/intermediate_source/pipeline_tutorial.py +++ b/intermediate_source/pipeline_tutorial.py @@ -122,7 +122,7 @@ def forward(self, x): # 학습 프로세스는 ``torchtext`` 의 Wikitext-2 데이터셋을 사용합니다. # torchtext 데이터셋에 접근하기 전에, https://github.com/pytorch/data 을 참고하여 torchdata를 설치하시기 바랍니다. # -# 단어 오브젝트는 훈련 데이터셋으로 만들어지고, 토큰을 텐서(tensor)로 수치화하는데 사용됩니다. +# 단어 오브젝트는 학습 데이터셋으로 만들어지고, 토큰을 텐서(tensor)로 수치화하는데 사용됩니다. # 시퀀스 데이터로부터 시작하여, ``batchify()`` 함수는 데이터셋을 열(column)들로 정리하고, # ``batch_size`` 사이즈의 배치들로 나눈 후에 남은 모든 토큰을 버립니다. # 예를 들어, 알파벳을 시퀀스(총 길이 26)로 생각하고 배치 사이즈를 4라고 한다면, @@ -319,7 +319,7 @@ def get_total_params(module: torch.nn.Module): import time def train(): - model.train() # 훈련 모드로 전환 + model.train() # 학습 모드로 전환 total_loss = 0. start_time = time.time() ntokens = len(vocab) diff --git a/intermediate_source/reinforcement_q_learning.py b/intermediate_source/reinforcement_q_learning.py index b4c3af465..d8a96e8af 100644 --- a/intermediate_source/reinforcement_q_learning.py +++ b/intermediate_source/reinforcement_q_learning.py @@ -34,7 +34,7 @@ 카트폴 태스크는 에이전트에 대한 입력이 환경 상태(위치, 속도 등)를 나타내는 4개의 실제 값이 되도록 설계되었습니다. 스케일링 없이 이 4개의 입력을 받아 각 동작에 대해 하나씩, 총 2개의 출력을 가진 완전히 연결된 작은 신경망에 통과시킵니다. -신경망은 주어진 입력에 대해, 각 동작에 대한 예상값을 예측하도록 훈련됩니다. +신경망은 주어진 입력에 대해, 각 동작에 대한 예상값을 예측하도록 학습됩니다. 가장 높은 예측값을 갖는 동작이 선택됩니다. @@ -244,7 +244,7 @@ def forward(self, x): # ``EPS_START`` 에서 시작해서 ``EPS_END`` 를 향해 지수적으로 감소할 것입니다. # ``EPS_DECAY`` 는 감쇠 속도를 제어합니다. # - ``plot_durations`` - 지난 100개 에피소드의 평균(공식 평가에서 사용 된 수치)에 따른 -# 에피소드의 지속을 도표로 그리기 위한 헬퍼. 도표는 기본 훈련 루프가 +# 에피소드의 지속을 도표로 그리기 위한 헬퍼. 도표는 기본 학습 루프가 # 포함된 셀 밑에 있으며, 매 에피소드마다 업데이트됩니다. # diff --git a/recipes_source/recipes/amp_recipe.py b/recipes_source/recipes/amp_recipe.py index 3d304e762..81ae92f5e 100644 --- a/recipes_source/recipes/amp_recipe.py +++ b/recipes_source/recipes/amp_recipe.py @@ -253,11 +253,11 @@ def make_model(in_size, out_size, num_layers): scaler.load_state_dict(checkpoint["scaler"]) ########################################################## -# 체크포인트가 Amp 없이 생성된 경우, Amp를 사용하여 훈련을 재개하고 싶다면, +# 체크포인트가 Amp 없이 생성된 경우, Amp를 사용하여 학습을 재개하고 싶다면, # 모델과 옵티마이저 상태를 평소처럼 체크포인트에서 로드합니다. 이 체크포인트에는 # 저장된 ``scaler`` 상태가 없으므로 새로운 ``GradScaler`` 인스턴스를 사용해야 합니다. # -# 반대로 체크포인트가 Amp로 생성된 경우, ``Amp`` 를 사용하지 않고 훈련을 재개하려면, +# 반대로 체크포인트가 Amp로 생성된 경우, ``Amp`` 를 사용하지 않고 학습을 재개하려면, # 모델과 옵티마이저 상태를 체크포인트에서 평소처럼 로드하고, 저장된 ``scaler`` 상태는 무시하면 됩니다. ########################################################## diff --git a/recipes_source/recipes/custom_dataset_transforms_loader.py b/recipes_source/recipes/custom_dataset_transforms_loader.py index e73039647..c9752a728 100644 --- a/recipes_source/recipes/custom_dataset_transforms_loader.py +++ b/recipes_source/recipes/custom_dataset_transforms_loader.py @@ -219,7 +219,7 @@ def __getitem__(self, idx): ###################################################################### # 우리는 지금까지 어느정도 사용자 정의 데이터셋을 만들어 보았는데 이제는 사용자 정의 변형을 만들 차례 입니다. # 컴퓨터 비전에서는 사용자 정의 변형은 알고리즘을 일반화시키고 정확도를 올리는데 도움을 줍니다. -# 변형들은 훈련시에 사용이 되며 주로 데이터 증강으로 참조되며 최근의 모델 개발에선 흔히 사용됩니다. +# 변형들은 학습시에 사용이 되며 주로 데이터 증강으로 참조되며 최근의 모델 개발에선 흔히 사용됩니다. # # 데이터셋을 다룰때 자주 일어나는 문제중 하나는 모든 샘플들이 같은 크기를 가지고 있지 않을 경우입니다. # 대부분의 신경망들은 미리 정해진 크기의 이미지들을 받아들입니다. diff --git a/recipes_source/recipes/defining_a_neural_network.py b/recipes_source/recipes/defining_a_neural_network.py index 36c711c0a..597c5e3c3 100644 --- a/recipes_source/recipes/defining_a_neural_network.py +++ b/recipes_source/recipes/defining_a_neural_network.py @@ -7,7 +7,7 @@ 소개 ------- -PyTorch는 ``torch.nn`` 을 포함하여 신경망을 만들고 훈련시키는 것을 도울 수 있도록 섬세하게 만들어진 모듈과 클래스들을 제공합니다. +PyTorch는 ``torch.nn`` 을 포함하여 신경망을 만들고 학습시키는 것을 도울 수 있도록 섬세하게 만들어진 모듈과 클래스들을 제공합니다. ``nn.Moduel`` 은 계층, 그리고 ``output`` 을 반환하는 ``forward(input)`` 메소드를 포함하고 있습니다. 이 레시피에서, `MNIST dataset `__ 을 사용하여 신경망을 정의하기 위해 ``torch.nn`` 을 사용할 예정입니다. diff --git a/recipes_source/recipes/tuning_guide.py b/recipes_source/recipes/tuning_guide.py index f04441d25..55ec58b8c 100644 --- a/recipes_source/recipes/tuning_guide.py +++ b/recipes_source/recipes/tuning_guide.py @@ -436,7 +436,7 @@ def gelu(x): # 일반적인 해결 방법은 미리 할당(preallocation)을 구현하는 것입니다. # 다음 단계로 구성됩니다: # -# #. 최대 시퀀스 길이(훈련 데이터 세트의 최대 길이 또는 사전 정의된 임계값에 해당)를 갖는 (일반적으로 +# #. 최대 시퀀스 길이(학습 데이터 세트의 최대 길이 또는 사전 정의된 임계값에 해당)를 갖는 (일반적으로 # 무작위) 입력 배치를 생성합니다. # #. 생성된 배치로 순방향 및 역방향 과정을 실행합니다. 옵티마이저나 학습률 스케줄러는 실행하지 않으며, # 이 단계는 이후 학습에서 재사용할 수 있는 최대 크기의 버퍼를 미리 할당합니다. diff --git a/recipes_source/recipes/warmstarting_model_using_parameters_from_a_different_model.py b/recipes_source/recipes/warmstarting_model_using_parameters_from_a_different_model.py index 2a561014e..da06574da 100644 --- a/recipes_source/recipes/warmstarting_model_using_parameters_from_a_different_model.py +++ b/recipes_source/recipes/warmstarting_model_using_parameters_from_a_different_model.py @@ -5,7 +5,7 @@ 모델을 부분적으로 불러오거나, 혹은 부분적인 모델을 불러오는 것은 학습 전이(Transfer learning)나 복잡한 모델을 새로 학습할 때 자주 접하는 시나리오입니다. 학습된 매개변수를 활용하면 학습 과정을 빠르게 -시작(warmstart)할 수 있으며, 그러면 모델을 처음부터 훈련시킬 때보다 훨씬 +시작(warmstart)할 수 있으며, 그러면 모델을 처음부터 학습시킬 때보다 훨씬 일찍 수렴하리라 기대할 수 있습니다. 이는 활용할 수 있는 매개변수가 얼마 안 될 때에도 마찬가지입니다. diff --git a/recipes_source/recipes/zeroing_out_gradients.py b/recipes_source/recipes/zeroing_out_gradients.py index cc5550484..18b7ac178 100644 --- a/recipes_source/recipes/zeroing_out_gradients.py +++ b/recipes_source/recipes/zeroing_out_gradients.py @@ -17,7 +17,7 @@ 텐서의 변화도를 0으로 만들어 주어야 하는 경우도 있습니다. 예를 들어 학습 과정 반복문을 시작할 때, 누적되는 변화도를 정확하게 추적하기 위해서는 변화도를 우선 0으로 만들어 주어야 합니다. 이 레시피에서는 PyTorch 라이브러리를 사용하여 변화도를 0으로 만드는 방법을 배워봅니다. -PyTorch에 내장된 ``CIFAR10`` 데이터셋에 대하여 신경망을 훈련시키는 과정을 통해 알아봅시다. +PyTorch에 내장된 ``CIFAR10`` 데이터셋에 대하여 신경망을 학습시키는 과정을 통해 알아봅시다. 설정 ----- From b2e25aadf53aaedf36128dede4e3af68e0172e2f Mon Sep 17 00:00:00 2001 From: rltq Date: Wed, 6 May 2026 12:47:52 +0900 Subject: [PATCH 8/9] =?UTF-8?q?docs:=20=EB=B2=88=EC=97=AD=EC=96=B4=20?= =?UTF-8?q?=ED=86=B5=EC=9D=BC=20-=20'=EB=A9=94=EC=84=9C=EB=93=9C'=EB=A5=BC?= =?UTF-8?q?=20'=EB=A9=94=EC=86=8C=EB=93=9C'=EB=A1=9C=20=ED=86=B5=EC=9D=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- advanced_source/semi_structured_sparse.py | 2 +- beginner_source/blitz/neural_networks_tutorial.py | 2 +- beginner_source/chatbot_tutorial.py | 6 +++--- beginner_source/introyt/introyt1_tutorial.py | 2 +- beginner_source/nlp/deep_learning_tutorial.py | 2 +- intermediate_source/pipeline_tutorial.py | 2 +- recipes_source/recipes/timer_quick_start.py | 4 ++-- 7 files changed, 10 insertions(+), 10 deletions(-) diff --git a/advanced_source/semi_structured_sparse.py b/advanced_source/semi_structured_sparse.py index 463c8e4af..2c00afa56 100644 --- a/advanced_source/semi_structured_sparse.py +++ b/advanced_source/semi_structured_sparse.py @@ -503,7 +503,7 @@ def measure_execution_time(model, batch_sizes, dataset): ###################################################################### # 그 다음, 단일 가지치기 단계를 수행합니다. 모든 가지치기 도구(pruner)는 가지치기 도구의 구현 -# 논리에 따라 마스크를 업데이트하는 ``update_mask()`` 메서드를 구현합니다. 이 단계 메서드는 +# 논리에 따라 마스크를 업데이트하는 ``update_mask()`` 메소드를 구현합니다. 이 단계 메소드는 # 희소성 설정(sparse config)에서 지정된 가중치에 대해 이 ``update_mask`` 함수를 호출합니다. # # 또한 모델을 평가하여 미세 조정/재학습 없이 가지치기(zero-shot) 또는 가지치기의 정확도 저하를 보여줄 것입니다. diff --git a/beginner_source/blitz/neural_networks_tutorial.py b/beginner_source/blitz/neural_networks_tutorial.py index 1ac765075..c828ddc59 100644 --- a/beginner_source/blitz/neural_networks_tutorial.py +++ b/beginner_source/blitz/neural_networks_tutorial.py @@ -8,7 +8,7 @@ 지금까지 ``autograd`` 를 살펴봤는데요, ``nn`` 은 모델을 정의하고 미분하는데 ``autograd`` 를 사용합니다. ``nn.Module`` 은 계층(layer)과 ``output`` 을 반환하는 ``forward(input)`` -메서드를 포함하고 있습니다. +메소드를 포함하고 있습니다. 숫자 이미지를 분류하는 신경망을 예제로 살펴보겠습니다: diff --git a/beginner_source/chatbot_tutorial.py b/beginner_source/chatbot_tutorial.py index bc205174e..cd81dac4c 100644 --- a/beginner_source/chatbot_tutorial.py +++ b/beginner_source/chatbot_tutorial.py @@ -261,9 +261,9 @@ def extractSentencePairs(conversations): # 이를 위해 우리는 ``Voc`` 라는 클래스를 만들어 단어에서 인덱스로의 # 매핑, 인덱스에서 단어로의 역 매핑, 각 단어의 등장 횟수, 전체 단어 수 # 등을 관리하려 합니다. 이 클래스는 어휘집에 새로운 단어를 추가하는 -# 메서드( ``addWord``), 문장에 등장하는 모든 단어를 추가하는 -# 메서드( ``addSentence``), 그리고 자주 등장하지 않는 단어를 정리하는 -# 메서드( ``trim``)를 제공합니다. 단어를 정리하는 내용에 대해서는 뒤에서 +# 메소드( ``addWord``), 문장에 등장하는 모든 단어를 추가하는 +# 메소드( ``addSentence``), 그리고 자주 등장하지 않는 단어를 정리하는 +# 메소드( ``trim``)를 제공합니다. 단어를 정리하는 내용에 대해서는 뒤에서 # 좀 더 자세히 살펴보겠습니다. # diff --git a/beginner_source/introyt/introyt1_tutorial.py b/beginner_source/introyt/introyt1_tutorial.py index 4294b452c..b82f66357 100644 --- a/beginner_source/introyt/introyt1_tutorial.py +++ b/beginner_source/introyt/introyt1_tutorial.py @@ -214,7 +214,7 @@ def num_flat_features(self, x): # - 모델은 ``forward()`` 함수를 가지고 있다. 여기서 실제 계산이 수행됩니다. # 입력은 네트워크 계층 및 다양한 기능들을 통과시켜 결과를 생성합니다. # - 그 외에는 다른 파이썬 클래스처럼 모델 클래스를 구성할 수 있습니다. -# Python 클래스, 모델의 계산을 지원하는 데 필요한 속성 및 메서드를 추가합니다. +# Python 클래스, 모델의 계산을 지원하는 데 필요한 속성 및 메소드를 추가합니다. # # 자 이제 만든 오브젝트를 인스턴스화하고 샘플 입력을 통해 실행합니다. # diff --git a/beginner_source/nlp/deep_learning_tutorial.py b/beginner_source/nlp/deep_learning_tutorial.py index f50254d00..7681f46d7 100644 --- a/beginner_source/nlp/deep_learning_tutorial.py +++ b/beginner_source/nlp/deep_learning_tutorial.py @@ -181,7 +181,7 @@ # 또한 손실 함수를 계산하는 방법, PyTorch에 내장된 음의 로그 우도를 사용하는 방법, # 역전파를 통해 매개 변수를 업데이트하는 방법을 볼 것입니다. # -# 모든 네트워크 구성 요소는 nn.Module에서 상속 받아 forward() 메서드를 재정의해야합니다. +# 모든 네트워크 구성 요소는 nn.Module에서 상속 받아 forward() 메소드를 재정의해야합니다. # 이것은 상용구에 관한 것입니다. nn.Module에서의 상속은 구성 요소에 기능을 제공합니다. # 예를 들어 그것은 학습 가능한 매개변수를 추적하도록 만들고, # ``.to(device)`` 로 CPU와 GPU 를 교환할수 있습니다. diff --git a/intermediate_source/pipeline_tutorial.py b/intermediate_source/pipeline_tutorial.py index 31a6bc4ce..4dfbe3798 100644 --- a/intermediate_source/pipeline_tutorial.py +++ b/intermediate_source/pipeline_tutorial.py @@ -331,7 +331,7 @@ def train(): data, targets = get_batch(train_data, i) optimizer.zero_grad() # Pipe는 단일 호스트 내에 있고 - # forward 메서드로 반환된 ``RRef`` 프로세스는 이 노드에 국한되어 있기 때문에 + # forward 메소드로 반환된 ``RRef`` 프로세스는 이 노드에 국한되어 있기 때문에 # ``RRef.local_value()`` 를 통해 간단히 찾을 수 있습니다. output = model(data).local_value() # 타겟을 파이프라인 출력이 있는 diff --git a/recipes_source/recipes/timer_quick_start.py b/recipes_source/recipes/timer_quick_start.py index 51e7cd3f3..b54b3dbf8 100644 --- a/recipes_source/recipes/timer_quick_start.py +++ b/recipes_source/recipes/timer_quick_start.py @@ -60,7 +60,7 @@ # 2. 실제 실행 시간(wall time): Timer.blocked_autorange(...) # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # -# 이 메서드(method)는 몇 번이나 반복할지 적절한 횟수를 고르거나, 쓰레드의 수를 +# 이 메소드(method)는 몇 번이나 반복할지 적절한 횟수를 고르거나, 쓰레드의 수를 # 변경(fix)하거나,결과를 편하게 표현하는 방법을 제공하는 등, 세부적인 사항들을 # 처리(handle)합니다. # @@ -167,7 +167,7 @@ # 일단 더 자세한 분석을 위해, 특정 호출(call)을 살펴보겠습니다. # ``CallgrindStats.stats()`` 은 이를 더 쉽게해주는 ``FunctionCounts`` 객체를 반환합니다. # 개념적으로, ``FunctionCounts`` 는 각 쌍(pair)이 `(명령어 호출 횟수, 파일 경로 및 함수 이름)` -# 인 형태로 구성된, 유용한 메서드(utility method)가 있는 쌍(pair)의 튜플(tuple)로 +# 인 형태로 구성된, 유용한 메소드(utility method)가 있는 쌍(pair)의 튜플(tuple)로 # 생각할 수 있습니다. # # 경로(path)에 대한 참고 사항: From 07d38823440f314411a6f2ba58541cf8f2e070d2 Mon Sep 17 00:00:00 2001 From: rltq Date: Wed, 6 May 2026 13:02:25 +0900 Subject: [PATCH 9/9] =?UTF-8?q?docs:=20=EB=B2=88=EC=97=AD=20=EA=B0=9C?= =?UTF-8?q?=EC=84=A0=20-=20pruning=20=EB=88=84=EB=9D=BD=20=EB=B3=B4?= =?UTF-8?q?=EC=99=84=ED=95=98=EC=97=AC=20=EC=9D=98=EB=AF=B8=20=EB=AA=85?= =?UTF-8?q?=ED=99=95=ED=99=94?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- advanced_source/semi_structured_sparse.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/advanced_source/semi_structured_sparse.py b/advanced_source/semi_structured_sparse.py index 2c00afa56..56f7bd276 100644 --- a/advanced_source/semi_structured_sparse.py +++ b/advanced_source/semi_structured_sparse.py @@ -491,7 +491,7 @@ def measure_execution_time(model, batch_sizes, dataset): ###################################################################### -# 모델의 매개변수화는 첫 번째 단계는 모델의 가중치를 마스킹하기 위한 매개변수화를 삽입하는 것입니다. +# 모델의 가지치기를 위한 첫번째 단계는 모델의 가중치를 마스킹하기 위한 매개변수화를 삽입하는 것입니다. # 이는 준비 단계에서 수행됩니다. 이렇게 하면 ``.weight``에 접근할 때마다 대신 ``mask * weight``를 # 얻게 됩니다. #