Existe-t-il un moyen de refactoriser le code julia ci-dessous afin d'éviter la boucle/malloc?

Question

m,n =size(l.x) 
for batch=1:m 
    l.ly = l.y[batch,:] 
    l.jacobian .= -l.ly .* l.ly' 
    l.jacobian[diagind(l.jacobian)] .= l.ly.*(1.0.-l.ly) 
    # # n x 1 = n x n * n x 1 
    l.dldx[batch,:] = l.jacobian * DLDY[batch,:] 
end 
return l.dldx 

l.x est une matrice m par n. l.y est une autre matrice de la même taille que l.x. Mon but est de créer une autre matrice m par n, l.dldx, dans laquelle chaque ligne est le résultat de l'opération à l'intérieur de la boucle for. Quelqu'un peut-il repérer une optimisation supplémentaire pour ce bloc de code? Le code ci-dessus fait partie de https://github.com/stevenygd/NN.jl.

Answer 1

Les éléments suivants doivent mettre en œuvre le même calcul et est plus efficace:

l.dldx = l.y .* (DLDY .- sum(l.y .* DLDY , 2)) 

Il pourrait y avoir une légère amélioration disponible par le refactoring sum dans une boucle. Comme la question n'a pas de code exécutable, ou un cas de test, il est difficile de donner des repères définis, donc un retour d'information serait le bienvenu.

MISE À JOUR

Voici le code ci-dessus avec des boucles explicites:

function calc_dldx(y,DLDY) 
    tmp = zeros(eltype(y),size(y,1)) 
    dldx = similar(y) 
    @inbounds for j=1:size(y,2) 
     for i=1:size(y,1) 
      tmp[i] += y[i,j]*DLDY[i,j] 
     end 
    end 
    @inbounds for j=1:size(y,2) 
     for i=1:size(y,1) 
      dldx[i,j] = y[i,j]*(DLDY[i,j]-tmp[i]) 
     end 
    end 
    return dldx 
end 

La version longue devrait courir encore plus vite. Un bon moyen de mesurer les performances du code consiste à utiliser le package BenchmarkTools.