Является ли вычисление `loss.backward` для нескольких потерь производительным в pytorch? - PullRequest
Новая
       17

Является ли вычисление `loss.backward` для нескольких потерь производительным в pytorch?

0 голосов
/ 24 сентября 2018

Я хотел бы рассчитать градиент моей модели для нескольких функций потерь.

Я хотел бы выяснить, является ли вычисление последовательных backwards вызовов с retain_graph=True дешевым или дорогим.

Теоретически я ожидал бы, что первый вызов должен быть медленнее, чем тот, который следует за первым, потому что вычислительный граф не нужно переоценивать, а нужно лишь сделать несколько умножений матриц.

На практикеМне было трудно сравнивать.

Мой код: 

# Code in file nn/two_layer_net_nn.py
import torch

D_in = 40
model = torch.load('model.pytorch')
device = torch.device('cpu')
def loss1(y_pred,x):
    return (y_pred*(0.5-x.clamp(0,1))).sum()

def loss2(y_pred,x):
    return (y_pred*(1-x.clamp(0,1))).sum()


# Predict random input    
x = torch.rand(1,D_in, device=device,requires_grad=True)
y_pred = model(x)

# Is this 
%%timeit
loss = loss1(y_pred,x)
loss.backward(retain_graph=True)

202 µs ± 4.34 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

# Slower than this?
%%timeit
loss = loss2(y_pred,x)
loss.backward(retain_graph=True)

216 µs ± 27.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)


# Are successive backwards calls cheap?
loss = lossX(y_pred,x)
loss.backward(retain_graph=True)

Я думаю, что %%timeit не работает, потому что он будет выполнять несколько итераций, а затем усреднять по нему.

Как я могу измерить, будут ли последовательные звонки на backward быстрыми?Что на самом деле означает retain_graph=True для производительности?

1 Ответ

0 голосов
/ 26 сентября 2018

Я думаю, что вы только спросили, если

  1. первый обратный проход медленнее, чем последующие?

Есть еще два вопроса, которые также могут быть объединены здесь:

эффективнее ли объединять потери требует ли для графика (если не его значений) больше памяти?

Прежде чем, однако, подчеркнем, что retain_graph на самом деле для: многократных проходов через ваш график, если в вычислительном отношении вы имеете несколько выходов в несколько раз.В качестве примера рассмотрим совместное многозадачное обучение (см. этот вопрос и ответы на него для обсуждения этого вопроса).

Вернуться к вопросам: В целом, я ожидал бы, что онне имеет значения, сохраняете ли вы график.В конце концов, это просто сохранение частичных вычислений в памяти для будущего использования, без «каких-либо действий» с ними.

Тем не менее, первый обратный проход займет больше времени, поскольку pytorch будет кэшировать некоторые вычисления, необходимые привычисление градиентов.

Итак, вот доказательство: 

import numpy as np
import torch
import torch.nn as nn
import time
import os
import psutil
D_in = 1024
model = nn.Sequential(nn.Linear(1024, 4096), nn.ReLU(), nn.Linear(4096, 4096), nn.ReLU(), nn.Linear(4096, 1024))
device = torch.device('cpu')
def loss1(y_pred,x):
    return (y_pred*(0.5-x.clamp(0,1))).sum()


def loss2(y_pred,x):
    return (y_pred*(1-x.clamp(0,1))).sum()


def timeit(func, repetitions):
    time_taken = []
    mem_used = []
    for _ in range(repetitions):
        time_start = time.time()
        mem_used.append(func())
        time_taken.append(time.time() - time_start)
    return np.round([np.mean(time_taken), np.min(time_taken), np.max(time_taken), \
           np.mean(mem_used), np.min(mem_used), np.max(mem_used)], 4).tolist()


# Predict random input
x = torch.rand(1,D_in, device=device,requires_grad=True)

def init():
    out = model(x)
    loss = loss1(out, x)
    loss.backward()

def func1():
    x = torch.rand(1, D_in, device=device, requires_grad=True)
    loss = loss1(model(x),x)
    loss.backward()
    loss = loss2(model(x),x)
    loss.backward()
    del x
    process = psutil.Process(os.getpid())
    return process.memory_info().rss

def func2():
    x = torch.rand(1, D_in, device=device, requires_grad=True)
    loss = loss1(model(x),x) + loss2(model(x),x)
    loss.backward()
    del x
    process = psutil.Process(os.getpid())
    return process.memory_info().rss


def func3():
    x = torch.rand(1, D_in, device=device, requires_grad=True)
    loss = loss1(model(x),x)
    loss.backward(retain_graph=True)
    loss = loss2(model(x),x)
    loss.backward(retain_graph=True)
    del x
    process = psutil.Process(os.getpid())
    return process.memory_info().rss


def func4():
    x = torch.rand(1, D_in, device=device, requires_grad=True)
    loss = loss1(model(x),x) + loss2(model(x),x)
    loss.backward(retain_graph=True)
    del x
    process = psutil.Process(os.getpid())
    return process.memory_info().rss

init()
print(timeit(func1, 100))
print(timeit(func2, 100))
print(timeit(func3, 100))
print(timeit(func4, 100))

Результаты (простите за мое ленивое форматирование): 

# time mean, time min, time max, memory mean, memory min, memory max
[0.1165, 0.1138, 0.1297, 383456419.84, 365731840.0, 384438272.0]
[0.127, 0.1233, 0.1376, 400914759.68, 399638528.0, 434044928.0]
[0.1167, 0.1136, 0.1272, 400424468.48, 399577088.0, 401223680.0]
[0.1263, 0.1226, 0.134, 400815964.16, 399556608.0, 434307072.0]

Однако, если вы пропустите первыйпроход назад (закомментируйте вызов функции init()), самый первый запуск назад в func1 будет дольше: 

# time mean, time min, time max, memory mean, memory min, memory max
[0.1208, 0.1136, **0.1579**, 350157455.36, 349331456.0, 350978048.0]
[0.1297, 0.1232, 0.1499, 393928540.16, 350052352.0, 401854464.0]
[0.1197, 0.1152, 0.1547, 350787338.24, 349982720.0, 351629312.0]
[0.1335, 0.1229, 0.1793, 382819123.2, 349929472.0, 401776640.0]
...