Obliczambackpropagation algorytm rzadkiego autoenkodera. Zaimplementowałem to w Pythonienumpy i wmatlab. Kod jest prawie taki sam, ale wydajność jest bardzo różna. Czas potrzebny matlabowi na wykonanie zadania wynosi 0,2552454 sekundy, a liczba 0,973672151566 jest prawie cztery razy większa. Zadzwonię do tego kodu kilka razy później w ramach problemu minimalizacji, więc ta różnica prowadzi do kilku minut opóźnienia między implementacjami. Czy to normalne zachowanie? Jak mogę poprawić wydajność w numpy?

Numpy Implementation:

Sparse.rho jest parametrem dostrajania, sparse.nodes to liczba węzłów w ukrytej warstwie (25), sparse.input (64) liczba węzłów w warstwie wejściowej, theta1 i theta2 to macierze wagi dla pierwszego i druga warstwa odpowiednio o wymiarach 25x64 i 64x25, m jest równa 10000, rhoest ma wymiar (25,), x ma wymiar 10000x64, a3 10000x64 i a2 10000x25.

UPDATE: Wprowadziłem zmiany w kodzie po niektórych pomysłach odpowiedzi. Wydajność jest teraz różna: 0,65 vs matlab: 0,25.

partial_j1 = np.zeros(sparse.theta1.shape)
partial_j2 = np.zeros(sparse.theta2.shape)
partial_b1 = np.zeros(sparse.b1.shape)
partial_b2 = np.zeros(sparse.b2.shape)
t = time.time()

delta3t = (-(x-a3)*a3*(1-a3)).T

for i in range(m):

    delta3 = delta3t[:,i:(i+1)]
    sum1 =  np.dot(sparse.theta2.T,delta3)
    delta2 = ( sum1 + sum2 ) * a2[i:(i+1),:].T* (1 - a2[i:(i+1),:].T)
    partial_j1 += np.dot(delta2, a1[i:(i+1),:])
    partial_j2 += np.dot(delta3, a2[i:(i+1),:])
    partial_b1 += delta2
    partial_b2 += delta3

print "Backprop time:", time.time() -t

Implementacja Matlab:

tic
for i = 1:m

    delta3 = -(data(i,:)-a3(i,:)).*a3(i,:).*(1 - a3(i,:));
    delta3 = delta3.';
    sum1 =  W2.'*delta3;
    sum2 = beta*(-sparsityParam./rhoest + (1 - sparsityParam) ./ (1.0 - rhoest) );
    delta2 = ( sum1 + sum2 ) .* a2(i,:).' .* (1 - a2(i,:).');
    W1grad = W1grad + delta2* a1(i,:);
    W2grad = W2grad + delta3* a2(i,:);
    b1grad = b1grad + delta2;
    b2grad = b2grad + delta3;
end
toc