PyTorch 웹 사이트에서 더 이상 찾지 못한 원래 코드.

gradients = torch.FloatTensor([0.1, 1.0, 0.0001])
y.backward(gradients)
print(x.grad)

위 코드의 문제는 그라디언트를 계산할 기능이 없습니다. 이것은 우리가 얼마나 많은 매개 변수 (함수가 취하는 인자)와 매개 변수의 차원을 모른다는 것을 의미합니다.

이것을 완전히 이해하기 위해 원본에 가까운 예제를 만들었습니다.

예 1 :

a = torch.tensor([1.0, 2.0, 3.0], requires_grad = True)
b = torch.tensor([3.0, 4.0, 5.0], requires_grad = True)
c = torch.tensor([6.0, 7.0, 8.0], requires_grad = True)

y=3*a + 2*b*b + torch.log(c)
gradients = torch.FloatTensor([0.1, 1.0, 0.0001])
y.backward(gradients,retain_graph=True)

print(a.grad) # tensor([3.0000e-01, 3.0000e+00, 3.0000e-04])
print(b.grad) # tensor([1.2000e+00, 1.6000e+01, 2.0000e-03])
print(c.grad) # tensor([1.6667e-02, 1.4286e-01, 1.2500e-05])

나는 우리의 함수를 다음 y=3*a + 2*b*b + torch.log(c)과 같이 가정 했고 매개 변수는 내부에 3 개의 요소가있는 텐서입니다.

gradients = torch.FloatTensor([0.1, 1.0, 0.0001])이것이 누산기 라고 생각할 수 있습니다 .

PyTorch autograd 시스템 계산은 Jacobian 곱과 동일합니다.

우리가 한 것처럼 함수가있는 경우 :

y=3*a + 2*b*b + torch.log(c)

Jacobian은 [3, 4*b, 1/c]. 그러나이 Jacobian 은 PyTorch가 특정 지점에서 그라디언트를 계산하는 방식이 아닙니다.

PyTorch는 순방향 패스 및 역방향 모드 자동 미분 (AD)을 함께 사용합니다.

관련된 상징적 수학과 수치 적 미분이 없습니다.

수치 차별화 계산하는 것입니다 δy/δb위해, b=1그리고 b=1+εε 작은입니다.

에서 그라디언트를 사용하지 않는 경우 y.backward():

예 2

a = torch.tensor(0.1, requires_grad = True)
b = torch.tensor(1.0, requires_grad = True)
c = torch.tensor(0.1, requires_grad = True)
y=3*a + 2*b*b + torch.log(c)

y.backward()

print(a.grad) # tensor(3.)
print(b.grad) # tensor(4.)
print(c.grad) # tensor(10.)

당신은 간단하게 당신이 당신의 설정 방법에 따라, 지점에서 결과를 얻을 것이다 a, b, c처음 텐서를.

당신이 당신의 초기화 방법 조심 a, b, c:

예 3 :

a = torch.empty(1, requires_grad = True, pin_memory=True)
b = torch.empty(1, requires_grad = True, pin_memory=True)
c = torch.empty(1, requires_grad = True, pin_memory=True)

y=3*a + 2*b*b + torch.log(c)

gradients = torch.FloatTensor([0.1, 1.0, 0.0001])
y.backward(gradients)

print(a.grad) # tensor([3.3003])
print(b.grad) # tensor([0.])
print(c.grad) # tensor([inf])

사용 torch.empty()하고 사용 하지 않으면 pin_memory=True매번 다른 결과가 나타날 수 있습니다.

또한 음표 그래디언트는 누산기와 같으므로 필요할 때 0으로 만듭니다.

예 4 :

a = torch.tensor(1.0, requires_grad = True)
b = torch.tensor(1.0, requires_grad = True)
c = torch.tensor(1.0, requires_grad = True)
y=3*a + 2*b*b + torch.log(c)

y.backward(retain_graph=True)
y.backward()

print(a.grad) # tensor(6.)
print(b.grad) # tensor(8.)
print(c.grad) # tensor(2.)

마지막으로 PyTorch가 사용하는 용어에 대한 몇 가지 팁 :

PyTorch 는 순방향 패스에서 기울기를 계산할 때 동적 계산 그래프를 생성합니다 . 이것은 나무처럼 보입니다.

따라서이 나무 의 잎 이 입력 텐서 이고 루트 가 출력 텐서 라는 소리를 자주 듣게 될 것 입니다.

그라디언트는 루트에서 잎까지 그래프를 추적하고 체인 규칙을 사용하는 방식으로 모든 그라디언트를 곱하여 계산됩니다 . 이 곱셈은 역방향 패스에서 발생합니다.

답변

from torch.autograd import Variable
import torch
x = Variable(torch.FloatTensor([[1, 2, 3, 4]]), requires_grad=True)
z = 2*x
loss = z.sum(dim=1)

# do backward for first element of z
z.backward(torch.FloatTensor([[1, 0, 0, 0]]), retain_graph=True)
print(x.grad.data)
x.grad.data.zero_() #remove gradient in x.grad, or it will be accumulated

# do backward for second element of z
z.backward(torch.FloatTensor([[0, 1, 0, 0]]), retain_graph=True)
print(x.grad.data)
x.grad.data.zero_()

# do backward for all elements of z, with weight equal to the derivative of
# loss w.r.t z_1, z_2, z_3 and z_4
z.backward(torch.FloatTensor([[1, 1, 1, 1]]), retain_graph=True)
print(x.grad.data)
x.grad.data.zero_()

# or we can directly backprop using loss
loss.backward() # equivalent to loss.backward(torch.FloatTensor([1.0]))
print(x.grad.data)    

d(loss)/dx = d(loss)/dz_1 * dz_1/dx + d(loss)/dz_2 * dz_2/dx + d(loss)/dz_3 * dz_3/dx + d(loss)/dz_4 * dz_4/dx

dz/dx = dz/dy1 * dy1/dx + dz/dy2 * dy2/dx + dz/dy3 * dy3/dx

[dz/dy1, dz/dy2, dz/dy3]