From a1570f2989e703d9cc0aa780731df01eecae2ca9 Mon Sep 17 00:00:00 2001 From: 2kkeullim Date: Sun, 21 Aug 2022 21:55:47 +0900 Subject: [PATCH 1/3] =?UTF-8?q?beginner=5Fsource/nlp/pytorch=5Ftutorial.py?= =?UTF-8?q?=20=EB=B2=88=EC=97=AD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit beginner_source/nlp/pytorch_tutorial.py 번역 --- beginner_source/nlp/pytorch_tutorial.py | 230 ++++++++++++------------ 1 file changed, 115 insertions(+), 115 deletions(-) diff --git a/beginner_source/nlp/pytorch_tutorial.py b/beginner_source/nlp/pytorch_tutorial.py index 4dd966bc8..ead9d245b 100644 --- a/beginner_source/nlp/pytorch_tutorial.py +++ b/beginner_source/nlp/pytorch_tutorial.py @@ -1,15 +1,16 @@ # -*- coding: utf-8 -*- r""" -Introduction to PyTorch +PyTorch 소개 *********************** +**번역**: `반보영 `_ -Introduction to Torch's tensor library +Torch의 tensor 라이브러리 소개 ====================================== -All of deep learning is computations on tensors, which are -generalizations of a matrix that can be indexed in more than 2 -dimensions. We will see exactly what this means in-depth later. First, -let's look what we can do with tensors. +딥러닝은 모두 tensor에 대한 연산으로, +2차원 이상에서 인덱싱할 수 있는 행렬의 일반화입니다. +이것이 정확히 무엇을 의미하는지는 나중에 자세히 알아보겠습니다. +먼저 tensor로 무엇을 할 수 있는지 알아보겠습니다. """ # Author: Robert Guthrie @@ -19,24 +20,24 @@ ###################################################################### -# Creating Tensors +# Tensor 생성하기 # ~~~~~~~~~~~~~~~~ # -# Tensors can be created from Python lists with the torch.tensor() -# function. +# torch.tensor() 함수를 사용하여 Python 리스트로부터 +# tensor를 생성할 수 있습니다. # -# torch.tensor(data) creates a torch.Tensor object with the given data. +# torch.tensor(data)를 통해 주어진 데이터로부터 torch.Tensor object를 생성합니다. V_data = [1., 2., 3.] V = torch.tensor(V_data) print(V) -# Creates a matrix +# 행렬을 생성합니다 M_data = [[1., 2., 3.], [4., 5., 6]] M = torch.tensor(M_data) print(M) -# Create a 3D tensor of size 2x2x2. +# 2x2x2 크기의 3D tensor를 생성합니다. T_data = [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]]] T = torch.tensor(T_data) @@ -44,42 +45,42 @@ ###################################################################### -# What is a 3D tensor anyway? Think about it like this. If you have a -# vector, indexing into the vector gives you a scalar. If you have a -# matrix, indexing into the matrix gives you a vector. If you have a 3D -# tensor, then indexing into the tensor gives you a matrix! +# 그건 그렇고 3D tensor는 무엇일까요? 이렇게 생각해 보세요. +# 벡터의 경우, 인덱싱하면 스칼라가 출력됩니다. +# 행렬의 경우, 인덱싱하면 벡터가 출력됩니다. +# 3D tensor의 경우, 인덱싱하면 행렬이 출력됩니다! # -# A note on terminology: -# when I say "tensor" in this tutorial, it refers -# to any torch.Tensor object. Matrices and vectors are special cases of -# torch.Tensors, where their dimension is 2 and 1 respectively. When I am -# talking about 3D tensors, I will explicitly use the term "3D tensor". +# 용어 노트: +# 이 튜토리얼에서 "tensor" 라는 용어는 torch.Tensor object를 +# 나타냅니다. 행렬과 벡터는 torch.Tensor의 차원이 2, 1인 +# 특별한 경우입니다. 3D tensor에 대한 +# 용어를 표현할 때는 명백하게 "3D tensor" 라는 용어를 사용할 것입니다. # -# Index into V and get a scalar (0 dimensional tensor) +# V에서 인덱싱하여 스칼라 얻기 (0 차원 tensor) print(V[0]) -# Get a Python number from it +# 벡터로부터 Python 넘버 얻기 print(V[0].item()) -# Index into M and get a vector +# M에서 인덱싱하여 벡터 얻기 print(M[0]) -# Index into T and get a matrix +# T에서 인덱싱하여 행렬 얻기 print(T[0]) ###################################################################### -# You can also create tensors of other data types. To create a tensor of integer types, try -# torch.tensor([[1, 2], [3, 4]]) (where all elements in the list are integers). -# You can also specify a data type by passing in ``dtype=torch.data_type``. -# Check the documentation for more data types, but -# Float and Long will be the most common. +# 다른 데이터 타입의 tensor를 생성할 수도 있습니다. integer 타입의 tensor는 +# torch.tensor([[1, 2], [3, 4]])으로 만들 수 있습니다. (이 때, 리스트의 모든 원소는 integer) +# 또한 ``dtype=torch.data_type`` 을 이용해 데이터 타입을 지정할 수도 있습니다. +# 추가적인 데이터 타입에 대해서는 문서로 확인할 수 있으며, +# Float과 Long이 가장 일반적입니다. # ###################################################################### -# You can create a tensor with random data and the supplied dimensionality -# with torch.randn() +# torch.randn() 으로 제공한 차원을 사용해 +# 랜덤 데이터로 tensor를 만들 수 있습니다. # x = torch.randn((3, 4, 5)) @@ -87,10 +88,10 @@ ###################################################################### -# Operations with Tensors +# Tensor 를 사용한 연산 # ~~~~~~~~~~~~~~~~~~~~~~~ # -# You can operate on tensors in the ways you would expect. +# tensor는 당신이 원하는 방식으로 연산할 수 있습니다. x = torch.tensor([1., 2., 3.]) y = torch.tensor([4., 5., 6.]) @@ -99,103 +100,102 @@ ###################################################################### -# See `the documentation `__ for a -# complete list of the massive number of operations available to you. They -# expand beyond just mathematical operations. +# `문서 `__ 에서 +# 사용할 수 있는 엄청난 수의 연산들의 전체 목록을 볼 수 있습니다. +# 그것들은 단순한 수학적인 연산을 뛰어넘습니다. # -# One helpful operation that we will make use of later is concatenation. +# 나중에 사용할 유용한 연산 중 하나는 결합(concatenation)입니다. # -# By default, it concatenates along the first axis (concatenates rows) +# 기본적으로 첫 번째 축을 따라 결합됩니다 (행(row) 결합) x_1 = torch.randn(2, 5) y_1 = torch.randn(3, 5) z_1 = torch.cat([x_1, y_1]) print(z_1) -# Concatenate columns: +# 열(column) 결합 x_2 = torch.randn(2, 3) y_2 = torch.randn(2, 5) -# second arg specifies which axis to concat along +# 두 번째 인자는 연결할 축을 지정합니다 z_2 = torch.cat([x_2, y_2], 1) print(z_2) -# If your tensors are not compatible, torch will complain. Uncomment to see the error +# tensor가 호환되지 않으면 torch가 불평할겁니다. 밑의 명령어를 주석 해제하여 에러를 출력해보세요 # torch.cat([x_1, x_2]) - ###################################################################### -# Reshaping Tensors +# Tensor 구조 바꾸기 # ~~~~~~~~~~~~~~~~~ # -# Use the .view() method to reshape a tensor. This method receives heavy -# use, because many neural network components expect their inputs to have -# a certain shape. Often you will need to reshape before passing your data -# to the component. +# .view() 메소드를 사용해 tensor의 구조를 바꿔봅시다. 많은 신경망 컴포넌트들은 +# 특정한 구조의 입력을 원하기에, 이 메소드는 아주 많이 사용됩니다. +# 종종 데이터를 컴포넌트로 전달하기 전 구조를 바꿔야 하는 경우가 +# 있습니다. # x = torch.randn(2, 3, 4) print(x) -print(x.view(2, 12)) # Reshape to 2 rows, 12 columns -# Same as above. If one of the dimensions is -1, its size can be inferred +print(x.view(2, 12)) # 2열 12행으로 구조 바꾸기 +# 위와 같습니다. 차원 중 하나가 -1인 경우 그 크기를 유추할 수 있습니다 print(x.view(2, -1)) ###################################################################### -# Computation Graphs and Automatic Differentiation +# 계산 그래프(Computation Graph) 와 자동미분(Automatic Differentiation) # ================================================ # -# The concept of a computation graph is essential to efficient deep -# learning programming, because it allows you to not have to write the -# back propagation gradients yourself. A computation graph is simply a -# specification of how your data is combined to give you the output. Since -# the graph totally specifies what parameters were involved with which -# operations, it contains enough information to compute derivatives. This -# probably sounds vague, so let's see what is going on using the -# fundamental flag ``requires_grad``. +# 계산 그래프의 개념은 직접 역전파 변화도(gradient)를 쓰지 않아도 되도록 하여 +# 효율적인 딥러닝 프로그래밍에 필수적입니다. +# 계산 그래프는 간단히 말하자면 출력을 내기 위해 +# 어떻게 데이터를 결합했는지에 대한 설명서입니다. +# 그래프는 어떤 매개변수가 어떤 연산에 관여하는지를 모두 말해주므로 +# 도함수를 계산하기에 충분한 정보를 가집니다. +# 이 말이 모호할 수 있으니, 핵심 플래그인 +# ``requires_grad`` 를 사용하여 무슨 일이 일어나는지 알아봅시다. # -# First, think from a programmers perspective. What is stored in the -# torch.Tensor objects we were creating above? Obviously the data and the -# shape, and maybe a few other things. But when we added two tensors -# together, we got an output tensor. All this output tensor knows is its -# data and shape. It has no idea that it was the sum of two other tensors -# (it could have been read in from a file, it could be the result of some -# other operation, etc.) +# 먼저 프로그래머의 관점에서 생각해봅시다. 위에서 우리가 만든 +# torch.Tensor 오브젝트에는 무엇이 저장되어 있을까요? 분명히 데이터와 +# 구조, 그리고 몇 가지 다른 것들이 있을 겁니다. 하지만 2개의 tensor를 +# 함께 추가하면 하나의 결과 tensor를 얻게 되는데, 결과 tensor가 아는 것은 +# 자신의 데이터와 구조뿐입니다. 다른 두 tensor의 합이라는 것을 전혀 알지 못합니다 +# (파일에서 읽었을 수도 있고, +# 다른 연산의 결과일 수도 있음) # -# If ``requires_grad=True``, the Tensor object keeps track of how it was -# created. Let's see it in action. +# ``requires_grad=True`` 인 경우, Tensor 객체는 자신이 어떻게 생성되었는지 +# 추적합니다. 한번 봅시다. # -# Tensor factory methods have a ``requires_grad`` flag +# Tensor factory 메소드는 ``requires_grad`` 플래그를 가지고 있습니다 x = torch.tensor([1., 2., 3], requires_grad=True) -# With requires_grad=True, you can still do all the operations you previously -# could +# requires_grad=True 를 사용해도 이전에 할 수 있었던 모든 연산을 +# 여전히 수행할 수 있습니다 y = torch.tensor([4., 5., 6], requires_grad=True) z = x + y print(z) -# BUT z knows something extra. +# 하지만, z는 뭔가를 더 알고 있습니다. print(z.grad_fn) ###################################################################### -# So Tensors know what created them. z knows that it wasn't read in from -# a file, it wasn't the result of a multiplication or exponential or -# whatever. And if you keep following z.grad_fn, you will find yourself at -# x and y. +# 즉 Tensor는 무엇이 그들을 만들었는지 압니다. z는 Tensor가 파일에서 +# 읽히지 않았다는 것을 알고 있으며, 곱셈이나 지수 같은 것의 결과도 아닙니다. +# 그리고 z.grad_fn 을 계속 따라가다 보면, +# x와 y를 찾을 수 있습니다. # -# But how does that help us compute a gradient? +# 그러면 이 정보가 어떻게 변화도를 계산하는데 도움을 줄까요? # -# Let's sum up all the entries in z +# z의 모든 항목을 하나로 더해봅시다. s = z.sum() print(s) print(s.grad_fn) ###################################################################### -# So now, what is the derivative of this sum with respect to the first -# component of x? In math, we want +# 그렇다면, x의 첫번째 컴포넌트에 대해 이 덧셈의 미분은 +# 무엇일까요? 수학적으로는, 우리가 원하는 것은 다음의 식입니다. # # .. math:: # @@ -203,75 +203,75 @@ # # # -# Well, s knows that it was created as a sum of the tensor z. z knows -# that it was the sum x + y. So +# 자, s는 자신이 tensor z의 합으로 만들어졌다는 것을 알고 있습니다. z는 +# 자신이 x + y의 합이라는 것을 알고 있습니다. 그래서 # # .. math:: s = \overbrace{x_0 + y_0}^\text{$z_0$} + \overbrace{x_1 + y_1}^\text{$z_1$} + \overbrace{x_2 + y_2}^\text{$z_2$} # -# And so s contains enough information to determine that the derivative -# we want is 1! +# 따라서, s는 도함수를 결정하기에 충분한 정보를 가지고 있습니다. +# 우리가 원하는 도함수의 값은 1 입니다! # -# Of course this glosses over the challenge of how to actually compute -# that derivative. The point here is that s is carrying along enough -# information that it is possible to compute it. In reality, the -# developers of Pytorch program the sum() and + operations to know how to -# compute their gradients, and run the back propagation algorithm. An -# in-depth discussion of that algorithm is beyond the scope of this -# tutorial. +# 물론 이것은 그 미분을 실제로 계산하는 방법에 대한 도전을 +# 숨깁니다. 여기서 요점은 s가 미분을 계산하기에 충분한 +# 정보를 가지고 다닌다는 겁니다. 실제로 +# Pytorch 개발자는 sum() 과 + 연산에서 +# 변화도를 계산하는 법을 프로그래밍하고, 역전파 알고리즘을 실행합니다. +# 이 알고리즘에 대한 깊이있는 설명은 이 튜토리얼의 범위를 +# 벗어납니다. # ###################################################################### -# Let's have Pytorch compute the gradient, and see that we were right: -# (note if you run this block multiple times, the gradient will increment. -# That is because Pytorch *accumulates* the gradient into the .grad -# property, since for many models this is very convenient.) +# Pytorch로 변화도를 계산하고, 맞았는지 확인해 봅시다. +# (이 블록을 여러번 실행하면 변화도가 증가할 것입니다. +# 그 이유는 Pytorch가 변화도를 .grad 속성에 *축적* 하기 때문이며, +# 이는 많은 모델에서 매우 편리하기 때문입니다.) # -# calling .backward() on any variable will run backprop, starting from it. +# 어떤 변수에서든지 .backward()를 호출하면 해당 변수에서 시작하는 역전파가 실행됩니다. s.backward() print(x.grad) ###################################################################### -# Understanding what is going on in the block below is crucial for being a -# successful programmer in deep learning. +# 딥러닝에서 성공한 프로그래머가 되기 위해서는 +# 아래 블록에서 무슨 일이 일어나고 있는지 이해하는 것이 필수적입니다. # x = torch.randn(2, 2) y = torch.randn(2, 2) -# By default, user created Tensors have ``requires_grad=False`` +# 사용자가 생성한 Tensor는 기본적으로 ``requires_grad=False`` 를 가집니다 print(x.requires_grad, y.requires_grad) z = x + y -# So you can't backprop through z +# 그래서 z를 통해 역전파를 할 수 없습니다 print(z.grad_fn) -# ``.requires_grad_( ... )`` changes an existing Tensor's ``requires_grad`` -# flag in-place. The input flag defaults to ``True`` if not given. +# ``.requires_grad_( ... )`` 는 기존 텐서의 ``requires_grad`` +# 플래그를 제자리에서(in-place) 바꿉니다. 입력 플래그가 지정되지 않은 경우 기본값은 ``True`` 입니다. x = x.requires_grad_() y = y.requires_grad_() -# z contains enough information to compute gradients, as we saw above +# z는 위에서 본 것처럼 변화도를 계산하기에 충분한 정보가 포함되어 있습니다 z = x + y print(z.grad_fn) -# If any input to an operation has ``requires_grad=True``, so will the output +# 연산에 대한 입력이 ``requires_grad=True`` 인 경우 출력도 마찬가지입니다 print(z.requires_grad) -# Now z has the computation history that relates itself to x and y -# Can we just take its values, and **detach** it from its history? +# 이제 z는 x와 y에 대한 계산 기록을 가지고 있습니다 +# z의 값만 가져가고, 기록에서 **분리** 할 수 있을까요? new_z = z.detach() -# ... does new_z have information to backprop to x and y? -# NO! +# ... new_z 가 x와 y로의 역전파를 위한 정보를 갖고 있을까요? +# 아닙니다! print(new_z.grad_fn) -# And how could it? ``z.detach()`` returns a tensor that shares the same storage -# as ``z``, but with the computation history forgotten. It doesn't know anything -# about how it was computed. -# In essence, we have broken the Tensor away from its past history +# 어떻게 그럴 수가 있을까요? ``z.detach()`` 는 ``z`` 와 동일한 저장공간을 사용하지만 +# 계산 기록은 없는 tensor를 반환합니다. 그 tensor는 자신이 어떻게 계산되었는지 +# 아무것도 알지 못합니다. +# 본질적으로는 Tensor를 과거 기록으로부터 떼어낸 겁니다 ############################################################### -# You can also stop autograd from tracking history on Tensors -# with ``.requires_grad=True`` by wrapping the code block in -# ``with torch.no_grad():`` +# 또한 코드 블록을 ``with torch.no_grad():`` 로 감싸 +# ``.requires_grad=True`` 인 텐서의 기록을 추적하지 못하게끔 +# autograd를 멈출 수 있습니다. print(x.requires_grad) print((x ** 2).requires_grad) From 74de6eca2558536da94436f8b57bc08372fd0ad2 Mon Sep 17 00:00:00 2001 From: 2kkeullim <63862534+2kkeullim@users.noreply.github.com> Date: Sat, 3 Sep 2022 11:56:58 +0900 Subject: [PATCH 2/3] =?UTF-8?q?=EC=9E=90=EB=8F=99=20=EB=AF=B8=EB=B6=84=20?= =?UTF-8?q?=EB=9D=84=EC=96=B4=EC=93=B0=EA=B8=B0=20=EB=B0=98=EC=98=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- beginner_source/nlp/pytorch_tutorial.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/beginner_source/nlp/pytorch_tutorial.py b/beginner_source/nlp/pytorch_tutorial.py index ead9d245b..e021f5fdf 100644 --- a/beginner_source/nlp/pytorch_tutorial.py +++ b/beginner_source/nlp/pytorch_tutorial.py @@ -141,7 +141,7 @@ ###################################################################### -# 계산 그래프(Computation Graph) 와 자동미분(Automatic Differentiation) +# 계산 그래프(Computation Graph) 와 자동 미분(Automatic Differentiation) # ================================================ # # 계산 그래프의 개념은 직접 역전파 변화도(gradient)를 쓰지 않아도 되도록 하여 From 6852b0c307fe72875ce513d90010f5d4a2a03269 Mon Sep 17 00:00:00 2001 From: 2kkeullim <63862534+2kkeullim@users.noreply.github.com> Date: Wed, 14 Sep 2022 23:26:46 +0900 Subject: [PATCH 3/3] =?UTF-8?q?=ED=94=BC=EB=93=9C=EB=B0=B1=20=EB=B0=98?= =?UTF-8?q?=EC=98=81=ED=95=B4=20=EC=88=98=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- beginner_source/nlp/pytorch_tutorial.py | 23 +++++++++++------------ 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/beginner_source/nlp/pytorch_tutorial.py b/beginner_source/nlp/pytorch_tutorial.py index e021f5fdf..11390a1eb 100644 --- a/beginner_source/nlp/pytorch_tutorial.py +++ b/beginner_source/nlp/pytorch_tutorial.py @@ -45,7 +45,7 @@ ###################################################################### -# 그건 그렇고 3D tensor는 무엇일까요? 이렇게 생각해 보세요. +# 도대체 3D tensor는 무엇일까요? 이렇게 생각해 보세요. # 벡터의 경우, 인덱싱하면 스칼라가 출력됩니다. # 행렬의 경우, 인덱싱하면 벡터가 출력됩니다. # 3D tensor의 경우, 인덱싱하면 행렬이 출력됩니다! @@ -59,8 +59,7 @@ # V에서 인덱싱하여 스칼라 얻기 (0 차원 tensor) print(V[0]) -# 벡터로부터 Python 넘버 얻기 -print(V[0].item()) +# 벡터로부터 Python 숫자 얻기 # M에서 인덱싱하여 벡터 얻기 print(M[0]) @@ -74,7 +73,7 @@ # torch.tensor([[1, 2], [3, 4]])으로 만들 수 있습니다. (이 때, 리스트의 모든 원소는 integer) # 또한 ``dtype=torch.data_type`` 을 이용해 데이터 타입을 지정할 수도 있습니다. # 추가적인 데이터 타입에 대해서는 문서로 확인할 수 있으며, -# Float과 Long이 가장 일반적입니다. +# Float와 Long이 가장 일반적입니다. # @@ -91,7 +90,7 @@ # Tensor 를 사용한 연산 # ~~~~~~~~~~~~~~~~~~~~~~~ # -# tensor는 당신이 원하는 방식으로 연산할 수 있습니다. +# tensor는 원하는 방식으로 연산할 수 있습니다. x = torch.tensor([1., 2., 3.]) y = torch.tensor([4., 5., 6.]) @@ -102,7 +101,7 @@ ###################################################################### # `문서 `__ 에서 # 사용할 수 있는 엄청난 수의 연산들의 전체 목록을 볼 수 있습니다. -# 그것들은 단순한 수학적인 연산을 뛰어넘습니다. +# 해당 연산 목록은 단순한 수학적인 연산을 뛰어넘습니다. # # 나중에 사용할 유용한 연산 중 하나는 결합(concatenation)입니다. # @@ -127,9 +126,9 @@ # Tensor 구조 바꾸기 # ~~~~~~~~~~~~~~~~~ # -# .view() 메소드를 사용해 tensor의 구조를 바꿔봅시다. 많은 신경망 컴포넌트들은 +# .view() 메소드를 사용해 tensor의 구조를 바꿔봅시다. 많은 신경망 구성 요소들은 # 특정한 구조의 입력을 원하기에, 이 메소드는 아주 많이 사용됩니다. -# 종종 데이터를 컴포넌트로 전달하기 전 구조를 바꿔야 하는 경우가 +# 종종 데이터를 구성 요소로 전달하기 전 구조를 바꿔야 하는 경우가 # 있습니다. # @@ -144,7 +143,7 @@ # 계산 그래프(Computation Graph) 와 자동 미분(Automatic Differentiation) # ================================================ # -# 계산 그래프의 개념은 직접 역전파 변화도(gradient)를 쓰지 않아도 되도록 하여 +# 계산 그래프의 개념은 직접 역전파 변화도(gradient)를 쓸 필요가 없게 해주며 # 효율적인 딥러닝 프로그래밍에 필수적입니다. # 계산 그래프는 간단히 말하자면 출력을 내기 위해 # 어떻게 데이터를 결합했는지에 대한 설명서입니다. @@ -155,7 +154,7 @@ # # 먼저 프로그래머의 관점에서 생각해봅시다. 위에서 우리가 만든 # torch.Tensor 오브젝트에는 무엇이 저장되어 있을까요? 분명히 데이터와 -# 구조, 그리고 몇 가지 다른 것들이 있을 겁니다. 하지만 2개의 tensor를 +# 구조, 몇 가지 다른 것들이 있을 겁니다. 하지만 2개의 tensor를 # 함께 추가하면 하나의 결과 tensor를 얻게 되는데, 결과 tensor가 아는 것은 # 자신의 데이터와 구조뿐입니다. 다른 두 tensor의 합이라는 것을 전혀 알지 못합니다 # (파일에서 읽었을 수도 있고, @@ -179,7 +178,7 @@ ###################################################################### -# 즉 Tensor는 무엇이 그들을 만들었는지 압니다. z는 Tensor가 파일에서 +# 즉 Tensor는 무엇으로 그들이 만들어졌는지 압니다. z는 Tensor가 파일에서 # 읽히지 않았다는 것을 알고 있으며, 곱셈이나 지수 같은 것의 결과도 아닙니다. # 그리고 z.grad_fn 을 계속 따라가다 보면, # x와 y를 찾을 수 있습니다. @@ -194,7 +193,7 @@ ###################################################################### -# 그렇다면, x의 첫번째 컴포넌트에 대해 이 덧셈의 미분은 +# 그렇다면, x의 첫번째 구성 요소에 대해 이 덧셈의 미분은 # 무엇일까요? 수학적으로는, 우리가 원하는 것은 다음의 식입니다. # # .. math::