Производительность Python против MATLAB по алгоритму

У меня вопрос производительности по двум битам кода. Один реализован в python и один в MATLAB. Код вычисляет энтропию выборки временного ряда (что звучит сложно, но в основном представляет собой набор для циклов).

Я выполняю обе реализации на относительно больших временных рядах (~ 95k+) в зависимости от временных рядов. Выполнение MATLAB завершает расчет в течение ~ 45 секунд до 1 минуты. Питон в принципе никогда не заканчивается. Я бросил tqdm поверх питона для циклов, и верхний цикл двигался только примерно на 1.85s/it, что дает 50+ часы в качестве расчетного времени завершения (я разрешил ему работать для 15+ mins, и счетчик итераций был довольно последовательный).

Примеры входов и времени выполнения:

MATLAB (~ 52 с):

a = rand(1, 95000)
sampenc(a, 4, 0.1 * std(a))

Python (в настоящее время 5 минут с оценкой в 49 часов):

import numpy as np
a = np.random.rand(1, 95000)[0]
sample_entropy(a, 4, 0.1 * np.std(a))

Реализация Python:

# https://github.com/nikdon/pyEntropy
def sample_entropy(time_series, sample_length, tolerance=None):
    """Calculate and return Sample Entropy of the given time series.
    Distance between two vectors defined as Euclidean distance and can
    be changed in future releases
    Args:
        time_series: Vector or string of the sample data
        sample_length: Number of sequential points of the time series
        tolerance: Tolerance (default = 0.1...0.2 * std(time_series))
    Returns:
        Vector containing Sample Entropy (float)
    References:
        [1] http://en.wikipedia.org/wiki/Sample_Entropy
        [2] http://physionet.incor.usp.br/physiotools/sampen/
        [3] Madalena Costa, Ary Goldberger, CK Peng. Multiscale entropy analysis
            of biological signals
    """
    if tolerance is None:
        tolerance = 0.1 * np.std(time_series)

    n = len(time_series)
    prev = np.zeros(n)
    curr = np.zeros(n)
    A = np.zeros((sample_length, 1))  # number of matches for m = [1,...,template_length - 1]
    B = np.zeros((sample_length, 1))  # number of matches for m = [1,...,template_length]

    for i in range(n - 1):
        nj = n - i - 1
        ts1 = time_series[i]
        for jj in range(nj):
            j = jj + i + 1
            if abs(time_series[j] - ts1) < tolerance:  # distance between two vectors
                curr[jj] = prev[jj] + 1
                temp_ts_length = min(sample_length, curr[jj])
                for m in range(int(temp_ts_length)):
                    A[m] += 1
                    if j < n - 1:
                        B[m] += 1
            else:
                curr[jj] = 0
        for j in range(nj):
            prev[j] = curr[j]

    N = n * (n - 1) / 2
    B = np.vstack(([N], B[:sample_length - 1]))
    similarity_ratio = A / B
    se = - np.log(similarity_ratio)
    se = np.reshape(se, -1)
    return se

Реализация MATLAB:

function [e,A,B]=sampenc(y,M,r);
%function [e,A,B]=sampenc(y,M,r);
%
%Input
%
%y input data
%M maximum template length
%r matching tolerance
%
%Output
%
%e sample entropy estimates for m=0,1,...,M-1
%A number of matches for m=1,...,M
%B number of matches for m=0,...,M-1 excluding last point

n=length(y);
lastrun=zeros(1,n);
run=zeros(1,n);
A=zeros(M,1);
B=zeros(M,1);
p=zeros(M,1);
e=zeros(M,1);

for i=1:(n-1)
   nj=n-i;
   y1=y(i);
   for jj=1:nj
      j=jj+i;      
      if abs(y(j)-y1)<r
         run(jj)=lastrun(jj)+1;
         M1=min(M,run(jj));
         for m=1:M1           
            A(m)=A(m)+1;
            if j<n
               B(m)=B(m)+1;
            end            
         end
      else
         run(jj)=0;
      end      
   end
   for j=1:nj
      lastrun(j)=run(j);
   end
end
N=n*(n-1)/2;
B=[N;B(1:(M-1))];
p=A./B;
e=-log(p);

Я также пробовал несколько других реализаций python, и все они имеют одинаковый медленный результат: vectorized-sample-entropy

sampen

sampen2.py

Энтропия вершин Википедии

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

Насколько я могу судить, реализация обоих наборов кода одинакова. Я понятия не имею, почему реализации python настолько медленны. Я бы понял разницу в несколько секунд, но не такое большое несоответствие. Сообщите мне свои мысли о том, почему это так, или о том, как улучшить версии python.

BTW: Я использую Python 3.6.5 с numpy 1.14.5 и MATLAB R2018a.