Multiplicación de arrays con 1 paso MapReduce

MapReduce es una técnica en la que un gran programa se subdivide en pequeñas tareas y se ejecuta en paralelo para acelerar el cálculo, ahorrar tiempo y se utiliza principalmente en sistemas distribuidos. Tiene 2 partes importantes: 

• Mapeador: toma la entrada de datos sin procesar y los organiza en pares de valores clave. Por ejemplo, en un diccionario, busca la palabra «Datos» y su significado asociado es «hechos y estadísticas recopilados para referencia o análisis». Aquí, la clave son los datos y el valor asociado son los hechos y las estadísticas recopilados para referencia o análisis.
• Reductor: Es responsable de procesar los datos en paralelo y producir el resultado final.

Consideremos el ejemplo de multiplicación de arrays para visualizar MapReduce. Considere la siguiente array: 

Aquí, la array A es una array de 2 × 2, lo que significa que el número de filas (i) = 2 y el número de columnas (j) = 2. La array B también es una array de 2 × 2 donde el número de filas (j) = 2 y el número de columnas (k) = 2. Cada celda de la array está etiquetada como Aij y Bij. Ex. el elemento 3 en la array A se llama A21, es decir, la primera columna de la segunda fila. Ahora, la multiplicación de arrays de un paso tiene 1 mapeador y 1 reductor. La fórmula es: 

Mapeador para Matrix A (k, v)=((i, k), (A, j, Aij)) para todo k 
Mapper para Matrix B (k, v)=((i, k), (B, j, Bjk)) para todos yo 

Por lo tanto, calculando el mapeador para Matrix A: 

# k, i, j computes the number of times it occurs.
# Here all are 2, therefore when k=1, i can have 
# 2 values 1 & 2, each case can have 2 further
# values of j=1 and j=2. Substituting all values 
# in formula

k=1  i=1  j=1   ((1, 1), (A, 1, 1)) 
          j=2   ((1, 1), (A, 2, 2))   
     i=2  j=1   ((2, 1), (A, 1, 3))
          j=2   ((2, 1), (A, 2, 4)) 

k=2  i=1  j=1   ((1, 2), (A, 1, 1))
          j=2   ((1, 2), (A, 2, 2))   
     i=2  j=1   ((2, 2), (A, 1, 3))
          j=2   ((2, 2), (A, 2, 4)) 

Cálculo del mapeador para Matrix B 

i=1  j=1  k=1   ((1, 1), (B, 1, 5)) 
          k=2   ((1, 2), (B, 1, 6))   
     j=2  k=1   ((1, 1), (B, 2, 7))
          j=2   ((1, 2), (B, 2, 8)) 

i=2  j=1  k=1   ((2, 1), (B, 1, 5))
          k=2   ((2, 2), (B, 1, 6))   
     j=2  k=1   ((2, 1), (B, 2, 7))
          k=2   ((2, 2), (B, 2, 8)) 

La fórmula del Reductor es: 

Reductor(k, v)=(i, k)=>Hacer Alist y Blist ordenados 
(i, k) => Sumatoria (Aij * Bjk)) para j 
Salida =>((i, k), sum) 

Por lo tanto, calculando el reductor: 

# We can observe from Mapper computation 
# that 4 pairs are common (1, 1), (1, 2),
# (2, 1) and (2, 2)
# Make a list separate for Matrix A & 
# B with adjoining values taken from 
# Mapper step above:

(1, 1) =>Alist ={(A, 1, 1), (A, 2, 2)}
        Blist ={(B, 1, 5), (B, 2, 7)}
        Now Aij x Bjk: [(1*5) + (2*7)] =19 -------(i)

(1, 2) =>Alist ={(A, 1, 1), (A, 2, 2)}
        Blist ={(B, 1, 6), (B, 2, 8)}
        Now Aij x Bjk: [(1*6) + (2*8)] =22 -------(ii)

(2, 1) =>Alist ={(A, 1, 3), (A, 2, 4)}
        Blist ={(B, 1, 5), (B, 2, 7)}
        Now Aij x Bjk: [(3*5) + (4*7)] =43 -------(iii)

(2, 2) =>Alist ={(A, 1, 3), (A, 2, 4)}
        Blist ={(B, 1, 6), (B, 2, 8)}
        Now Aij x Bjk: [(3*6) + (4*8)] =50 -------(iv)

From (i), (ii), (iii) and (iv) we conclude that
((1, 1), 19)
((1, 2), 22)
((2, 1), 43)
((2, 2), 50)

Por lo tanto la Array Final es: