Mapa y reducción en .NET

Question

¿Qué escenarios justificarían el uso del " Mapa y reducción " algoritmo?

¿Existe una implementación .NET de este algoritmo?

Answer 1

Linq equivalentes de Map and Reduce: Si tiene la suerte de tener linq, entonces no necesita escribir su propio mapa y reducir las funciones. C # 3.5 y Linq ya lo tiene aunque con diferentes nombres.

Map = Select | Enumerable.Range(1, 10).Select(x => x + 2);
Reduce = Aggregate | Enumerable.Range(1, 10).Aggregate(0, (acc, x) => acc + x);
Filter = Where | Enumerable.Range(1, 10).Where(x => x % 2 == 0);

https://www.justinshield.com/2011/06/mapreduce -in-c /

Answer 2

Las clases de problemas que son adecuadas para una solución de estilo mapreduce son problemas de agregación. De extraer datos de un conjunto de datos. En C #, se podría aprovechar LINQ para programar en este estilo.

Del siguiente artículo: http://codecube.net/2009/02/mapreduce-in- c-using-linq /

  

el método GroupBy actúa como el mapa, mientras que el método Select hace el trabajo de reducir los resultados intermedios en la lista final de resultados.

var wordOccurrences = words
                .GroupBy(w => w)
                .Select(intermediate => new
                {
                    Word = intermediate.Key,
                    Frequency = intermediate.Sum(w => 1)
                })
                .Where(w => w.Frequency > 10)
                .OrderBy(w => w.Frequency);

Para la parte distribuida, puede consultar DryadLINQ: http: / /research.microsoft.com/en-us/projects/dryadlinq/default.aspx

Answer 3

Como nunca puedo recordar que LINQ lo llama Where , Select y Aggregate en lugar de Filter , < code> Map y Reduce , así que creé algunos métodos de extensión que puedes usar:

IEnumerable<string> myStrings = new List<string>() { "1", "2", "3", "4", "5" };
IEnumerable<int> convertedToInts = myStrings.Map(s => int.Parse(s));
IEnumerable<int> filteredInts = convertedToInts.Filter(i => i <= 3); // Keep 1,2,3
int sumOfAllInts = filteredInts.Reduce((sum, i) => sum + i); // Sum up all ints
Assert.Equal(6, sumOfAllInts); // 1+2+3 is 6

Aquí están los 3 métodos (de https://github.com/cs-util-com/cscore/blob/master/CsCore/PlainNetClassLib/src/Plugins/CsCore/com/csutil/collections/IEnumerableExtensions. cs ):

public static IEnumerable<R> Map<T, R>(this IEnumerable<T> self, Func<T, R> selector) {
    return self.Select(selector);
}

public static T Reduce<T>(this IEnumerable<T> self, Func<T, T, T> func) {
    return self.Aggregate(func);
}

public static IEnumerable<T> Filter<T>(this IEnumerable<T> self, Func<T, bool> predicate) {
    return self.Where(predicate);
}

Algunos detalles más de https://github.com/cs-util -com / cscore # ienumerable-extensiones :

Answer 4

Si intentabas escribir tu propia versión de Google, entonces eso podría justificarte ... !!!

En serio, si tienes un problema que puedes descomponer en varios problemas más pequeños, entonces una solución Map-Reduce funcionaría. El documento de Google en MapReduce tiene una serie de buenos ejemplos, que incluyen cómo procesar miles de páginas web, contar palabras en documentos, etc., etc.