Mapa e Reduzir em .NET

Question

O que cenários justificaria o uso do " Map e Reduce " algoritmo?

Existe uma implementação .NET deste algoritmo?

Answer 1

Linq equivalentes de Map e Reduce: Se você é o suficiente sorte de ter LINQ, então você não precisa escrever seu próprio mapa e reduzir funções. C # 3.5 e Linq já tem ainda que sob diferentes nomes.

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

As classes de problema que são adequados para uma solução estilo mapreduce são problemas de agregação. De extrair dados de um conjunto de dados. Em C #, pode-se tirar proveito de LINQ para o programa neste estilo.

A partir do seguinte artigo: http://codecube.net/2009/02/mapreduce-in- c-usando-LINQ /

o método GroupBy está atuando como o mapa, enquanto o método Select faz o trabalho de reduzir os resultados intermediários para a lista final dos 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 a parcela distribuída, você poderia verificar DryadLINQ: http: / /research.microsoft.com/en-us/projects/dryadlinq/default.aspx

Answer 3

Uma vez que eu nunca consigo lembrar que as chamadas de LINQ que Where, Select e Aggregate vez de Filter, Map e Reduce então eu criei alguns métodos de extensão que você pode 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

Aqui estão os 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);
}

Alguns mais detalhes https://github.com/cs-util -com / cscore # IEnumerable-extensões :

Answer 4

Se você estava tentando escrever a sua própria versão do Google, em seguida, que pode justificar .. !!!

Falando sério, se você tem um problema que pode se decompor em vários problemas menores, em seguida, uma solução Map-Reduce iria funcionar. O documento Google em MapReduce tem um número de bons exemplos, incluindo a forma de processar milhares de páginas da web, as palavras contam no documento etc etc.