Эффективно вычисляете автокорреляции и взаимные корреляции из многомерных временных рядов с помощью Python? ⇐ Python

[Anonymous]

У меня есть массив координат формы X.shape = (100000, 1000) и массив свойств формы P.shape = (100000, 1000). Я хочу вычислить зависящую от расстояния автокорреляционную функцию свойства P, которую я объясню ниже.

Сначала я напоминаю, что «голая» автокорреляция P будет выглядеть так: Autocorrelation = [np.mean(P[tau:]*P[:-tau], axis=(0 , 1)) для тау в диапазоне(P.shape[0])].

Для автокорреляции, зависящей от расстояния, мне нужно найти все точки, чьи сдвинутые координаты tau находятся в пределах заданного расстояния d. То есть я ищу все индексы i и j вдоль axis=1, для которых np.abs(X[time, i ]-X[time+tau, j]) == d, и я сохраняю время вдоль axis=0 каждый раз, когда нахожу такие пары, а затем строю средние значения для каждого >tau и d.

Для данного tau я написал функцию, показанную ниже

импортировать numpy как np из joblib импорт Параллельно, с задержкой X = np.ones([100000, 1000]) P = np.ones([100000, 1000]) защита Myfunc(тау): АвтокорреляцияP = [] для t в диапазоне (X.shape[0]-tau): d = np.round(np.sqrt((X[time][:, None]-X[time+tau])**2)) Пд = [] для меня в np.arange(1, 11): Индексы = np.where(d==i) Pd.append(np.mean(P[time, Indices[0]]*P[time+tau, Indices[1]])) АвтокорреляцияP.append(Pd) return np.mean(np.array(AutocorrelationP), ось=0) Я вызываю Parallel из Joblib, чтобы запустить эту функцию на 10 ядрах ЦП для разных значений tau. На данный момент сценарий работает нормально, и все процессоры загружены на 100% (зеленый цвет в htop).

Проблема в том, что накладные расходы на распараллеливание становятся большими, если я использую все 64 процессора на своем узле. Я ожидал, что параллельный вызов myFunc из Joblib 64 раза не потребует никаких дополнительных затрат, поскольку задачи независимы (за исключением того, что они считывают из одних и тех же переменных). Но кажется, что это верно только в том случае, если я запускаю до 10 заданий параллельно, а начиная с 10 я вижу примерно линейное увеличение времени выполнения в зависимости от количества заданий.

Я выполнил расчет «время выполнения и количество заданий» для разных размеров P и X, чтобы понять проблему, и увидел, что такое поведение наблюдается только в том случае, если < code>X.shape[1] имеет большой размер, а накладные расходы исчезают, если X.shape[1] составляет примерно 100. В крайнем случае X.shape[1 ]=5000 во время выполнения все процессоры становятся красными. Итак, из этих тестов я понимаю, что основная проблема — это память. X.shape[0] имеет менее значительный, но все же заметный эффект. Можете ли вы указать причину этой проблемы?

Мое решение

Чтобы избежать проблем с памятью, я стараюсь избегать построения матриц расстояний из numpy-вещания и вместо этого стараюсь полагаться на явные циклы Python, украшенные numba. Вот моя реализация:

из numba import jit @jit(nopython=True) защита myFunc(тау): PAutocorrelation = np.zeros(11) для t в диапазоне (X.shape[0]-tau): для я в диапазоне (X.shape[1]): для j в диапазоне (X.shape[1]): PAutocorrelation[int(np.rint(np.abs(X[t, i]-X[t+tau,j])))] += P[t, i]*P[t+tau, j] вернуть PАвтокорреляция На самом деле этот подход кажется лучшим с точки зрения накладных расходов на распараллеливание, проверенных на меньших массивах. Но если я использую размеры массива, упомянутые выше, ядро ​​умирает. Поэтому я думаю, что этот подход с числами также страдает от проблем с памятью, хотя здесь не вычисляются дополнительные большие матрицы. Можете ли вы объяснить, почему?

Наконец, вот немного улучшенная и более быстрая альтернатива, основанная на numpy, но она страдает той же проблемой, что и первый подход
из fast_histogram импортировать histogram1d защита myFunc(тау): PАвтокорреляция = [] для t в диапазоне (100): PAutocorrelation.append( \ histogram1d(np.abs(x[time][:, None]-X[time+tau]).flatten(), \ ячейки=10, диапазон=[0., 10], \ Weights=(P[time][:,None]*P[time+tau]).flatten())] ) вернуть PАвтокорреляция