parallel processing - ¿Cómo ejecutar un método en paralelo usando Julia?

parallel-processing julia-lang

Question

Estaba leyendo los documentos de Parallel Computing de Julia, y como nunca había hecho una codificación paralela, me faltaba una introducción más amable. Entonces, pensé en un problema (probablemente) simple que no pude descifrar cómo codificar paralelamente el paradigma de Julia.

Digamos que tengo una matriz / dataframe df de algún experimento. Sus N filas son variables, y M columnas son muestras. Tengo un método pwCorr(..) que calcula la correlación por parejas de las filas. Si quisiera una matriz NxN de todas las correlaciones pairwise, probablemente ejecutaría un for-loop que iteraría para N*N/2 (triángulo superior o inferior de la matriz) y completaría los valores; sin embargo, esto parece una cosa perfecta para paralelizar ya que cada una de las llamadas pwCorr() son independientes de otras. (¿Estoy en lo cierto al pensar de esta manera sobre qué se puede paralelizar y qué no?)

Para hacer esto, siento que tendría que crear un DArray que se llena con un @parallel de @parallel for. Y si es así, no estoy seguro de cómo se puede lograr esto en Julia. Si ese no es el enfoque correcto, supongo que ni siquiera sé por dónde empezar.

Answer 1

Esto debería funcionar, primero necesita propagar la variable de nivel superior (datos) a todos los trabajadores:

 for pid in workers()
       remotecall(pid, x->(global data; data=x; nothing), data)
       end

luego realice el cálculo en bloques utilizando el constructor DArray con una elegante indexación:

corrs = DArray((20,20)) do I
         out=zeros(length(I[1]),length(I[2]))
         for i=I[1], j=I[2]
           if i<j 
             out[i-minimum(I[1])+1,j-minimum(I[2])+1]= 0.0
           else
             out[i-minimum(I[1])+1,j-minimum(I[2])+1] = cor(vec(data[i,:]), vec(data[j,:]))
           end
         end
         out 
       end

Con más detalle, el constructor DArray toma una función que toma una tupla de rangos de índice y devuelve un trozo de la matriz resultante que corresponde a esos rangos de índice. En el código anterior, I es la tupla de rangos donde I[1] es el primer rango. Puedes ver esto más claramente con:

julia> DArray((10,10)) do I
       println(I)
       return zeros(length(I[1]),length(I[2]))
       end
        From worker 2:  (1:10,1:5)
        From worker 3:  (1:10,6:10)

donde puedes verlo divide la matriz en dos pedazos en el segundo eje.

La parte más difícil del ejemplo fue la conversión de estos rangos de índices ''globales'' a rangos de índices locales al restar el elemento mínimo y luego agregar 1 de nuevo para la indexación basada en 1 de Julia. ¡Espero que ayude!