Accélérez double boucle en Python

Question

Yat-il un moyen d'accélérer une double boucle qui met à jour ses valeurs de l'itération précédente?

Dans le code:

def calc(N, m): 
    x = 1.0 
    y = 2.0 
    container = np.zeros((N, 2)) 
    for i in range(N): 
     for j in range(m): 
     x=np.random.gamma(3,1.0/(y*y+4)) 
     y=np.random.normal(1.0/(x+1),1.0/sqrt(x+1)) 
     container[i, 0] = x 
     container[i, 1] = y 
    return container 

calc(10, 5) 

Comme vous pouvez le voir, la boucle intérieure est mise à jour des variables x et y tandis que la boucle externe commence par une valeur différente de x à chaque fois. Je ne pense pas que cela soit vectorisable mais peut-être y a-t-il d'autres améliorations possibles.

Merci!

Answer 1

Je ne pense pas que ça va ajouter à une vitesse importante, mais vous pouvez économiser des appels de fonction si vous générez tous vos gamma et des valeurs aléatoires normalement distribué à la fois.

fonctions gamma ont une scaling property, de sorte que si on trace une valeur x d'une distribution gamma (k, 1), puis c*x aura une valeur tirée d'une distribution gamma (k, c). De même, la distribution normale, vous pouvez prendre une valeur y tirée d'une normale (0, 1) la distribution et le convertir en une valeur tirée d'une distribution normale (m, s) faisant x*s + m. Ainsi, vous pouvez réécrire votre fonction comme suit:

def calc(N, m): 
    x = 1.0 
    y = 2.0 
    container = np.zeros((N, 2)) 
    nm = N*m 
    gamma_vals = np.random.gamma(3, 1, size=(nm,)) 
    norm_vals = np.random.normal(0, 1, size=(nm,)) 
    for i in xrange(N): 
     for j in xrange(m): 
      ij = i*j 
      x = gamma_vals[ij]/(y*y+4) 
      y = norm_vals[ij]/np.sqrt(x+1) + 1/(x+1) 
     container[i, 0] = x 
     container[i, 1] = y 
    return container 

Si les paramètres réels de vos distributions avaient une expression plus simple, vous pouvez effectivement être en mesure d'utiliser une forme élaborée de np.cumprod ou similaires, et vous épargner les boucles. Je ne suis pas en mesure de trouver un moyen de le faire ...

Answer 2

ce travail?

for i in xrange(N): 
    # xrange is an iterator, range makes a new list. 
    # You save linear space and `malloc`ing time by doing this 

    x += m*y # a simple algebra hack. Compute this line of the loop just once instead of `m` times 
    y -= m*x 
    y *= -1 # another simple algebra hack. Compute this line of the loop just once instead of `m` times 
    container[i,0] = x 
    container[i,1] = y 
return container