Parallele Programmierung in Python (verschachtelte Schleife)

Question

Ich habe den folgenden Code und da es sehr langsam ist für größere l Ich frage mich, ob es eine einfache Möglichkeit gibt, diese Schleife zu parallelisieren. Ich habe auch versucht, es selbst zu paralellieren, aber weil ich es nie gemacht habe, kann ich es nicht schaffen. Ich würde mich freuen, wenn Sie mir helfen können, aus

print('Create 2.0L%.3frec%.3f.npy' % (l, r)) 
for x1 in range(a**l): 
    for x2 in range(a**l): 
     for x3 in range(a**l): 
      f11 = 0 
      if numpy.ndarray.sum(numpy.absolute(numpy.subtract(ws[x1:x1+1], ws[x2:x2+1]))) == 0: 
       f11 += 1 
      if numpy.ndarray.sum(numpy.absolute(numpy.subtract(ws[x1:x1+1], ws[x3:x3+1]))) == 0: 
       f11 += 1 
      re[x1][x2][x3] = 1.0*r/(a**l-2)*(numpy.product(numpy.absolute(numpy.subtract((2*ws[x1:x1+1]+ws[x2:x2+1]+ws[x3:x3+1]), 2)))-f11) 

      cv1 = numpy.ndarray.sum(numpy.absolute(numpy.subtract(ws[x1:x1+1], ws[x2:x2+1]))) 
      cv2 = numpy.ndarray.sum(numpy.absolute(numpy.subtract(ws[x1:x1+1], ws[x3:x3+1]))) 
      c2 = 0 
      if cv1 == 0: 
       c2 += 1 
      if cv2 == 0: 
       c2 += 1 
      c2 *= 1.0*(1-r)/2 
      re[x1][x2][x3] += c2 
numpy.save('2.0L%.3frec%.3f' % (l, r), re) 
print('Saved 2.0L%.3frec%.3f.npy' % (l, r)) 

So, da alle Einträge der Re unabhängig von den anderen, es sollte ein Weg sein. Ich glaube, ich habe geholfen, wenn ich eine Lösung wissen, wie ein Python-Programm parllize wie:

for x1 in range(a): 
    for x2 in range(a): 
     for x3 in range(a): 
      re[x1][x2][x3] = 5*3 

Answer 1

Ich verstehe nicht ganz, was Sie zu berechnen versuchen, aber ich werde es einen Schuss. Für Ihre letzte Frage, können Sie dies wie folgt:

re = np.empty([a]*3) 
x = np.indices([a]*3) 
re[x] = 5*3 

Sie Ihren Code vektorisiert können wie folgt:

x = np.indices([a**l]*3) 
cv1 = (ws[x[0]] == ws[x[1]]).astype(float) 
cv2 = (ws[x[0]] == ws[x[2]]).astype(float) 
f11 = cv1 + cv2 
re = 1.0*r/(a**l-2)*(np.absolute(2*ws[x[0]]+ws[x[1]]+ws[x[2]]-2)-f11)  
re += f11*1.0*(1-r)/2 

(I überflüssig Summen und Produkte, und verwendet den Operator == entfernt zu überprüfen für gleiche Werte, und verwendet, dass c2 und f11 die gleiche Sache sind). In der Theorie sollte dies dasselbe wie Ihr Code tun.