Почему иногда мне нужно дважды вызывать compute () для отложенных функций dask?

Я думаю, что ключ кроется в более точном понимании того, что делает dask.delayed.

Учитывать

my_delayed_function = dask.delayed(my_function)

При использовании в качестве декоратора на my_function, dask.delayed возвращает функцию my_delayed_function, которая задерживает выполнение my_function. Когда my_delayed_function вызывается с аргументом

delayed_result = my_delayed_function(arg)

это возвращает объект, который содержит всю необходимую информацию о выполнении my_function с аргументом arg.

Звонок

result = delayed_result.compute()

запускает выполнение функции.

Теперь эффект от использования операторов, таких как +, для двух отложенных результатов заключается в том, что возвращается новый отложенный результат, который объединяет два выполнения, содержащиеся во входных данных. Вызов compute для этого объекта запускает этот пакет выполнений.

Все идет нормально. Теперь в вашем первом примере foo вызывает inc, который вызывает отложенную функцию, которая возвращает отложенный результат. Следовательно, вычисление foo делает именно это и возвращает этот отложенный результат. Вызов compute для этого отложенного результата (вашего «второго» вычисления) затем запускает его вычисление.

Во втором примере a и b - это отложенные результаты. Добавление двух отложенных результатов с использованием + возвращает отложенный результат объединения выполнения _21 _, _ 22_ и их сложения. Теперь, поскольку calc является отложенной функцией, она возвращает отложенный результат при получении отложенного результата. Поэтому снова его вычисление вернет отложенный объект.

В обоих случаях вы не совсем следовали передовым методам. Конкретно точка

Избегайте отложенного вызова в отложенных функциях

поскольку в вашем первом примере отложенный add вызывается в inc, который вызывается в foo. Поэтому вы звоните с задержкой в ​​течение foo с задержкой. Во втором примере отложенный calc работает с отложенным a и b, поэтому вы снова вызываете отложенный вызов в отложенной функции.

В вашем вопросе вы говорите

Но я считаю, что inc не является отложенной функцией и, следовательно, не противоречит правилу не вызывать отложенную функцию в другой отложенной функции?

Я подозреваю, что вы могли неправильно понять «отложенный вызов в отложенных функциях». Это относится ко всему, что происходит внутри функции, и поэтому является ее частью: inc включает вызов отложенного add, поэтому отложенный вызов вызывается в foo.

Дополнение после обновления вопроса: передача отложенных аргументов в отложенную функцию объединяет отложенное выполнение в новый отложенный результат. Это отличается от «отложенного вызова в рамках отложенной функции» и является частью предполагаемого варианта использования. На самом деле я также не нашел четкого объяснения этого в документации, но одна точка входа может быть this: unpack_collections используется для обработки отложенных аргументов. Даже если это должно оставаться в некоторой степени неясным, следование передовым практикам (интерпретируемым таким образом) должно обеспечить воспроизводимое поведение в отношении вывода compute().

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

Первый пример:

#@dask.delayed
def add(a, b):
    return  a + b

def inc(a):
    return add(a, 1)

@dask.delayed
def foo(x):
    return inc(x)

x = foo(3)
x.compute()

Второй пример:

class Add():
    def __init__(self, a, b):
        self.a = a
        self.b = b

    #@dask.delayed
    def calc(self):
        return self.a+self.b

a = dask.delayed(1)
b = dask.delayed(2)
add = Add(a, b)
add.calc().compute()