Mappa e riduci in .NET

Question

Quali scenari giustificherebbero l'uso del " Mappa e riduzione " algoritmo?

Esiste un'implementazione .NET di questo algoritmo?

Answer 1

Linq equivalenti di Mappa e Riduci: Se sei abbastanza fortunato da avere Linq, non devi scrivere la tua mappa e ridurre le funzioni. C # 3.5 e Linq lo hanno già seppur con nomi diversi.

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

Le classi di problemi che ben si adattano a una soluzione di stile mapreduce sono problemi di aggregazione. Di estrarre dati da un set di dati. In C #, si potrebbe sfruttare LINQ per programmare in questo stile.

Dal seguente articolo: http://codecube.net/2009/02/mapreduce-in- c-con-LINQ /

  

il metodo GroupBy funge da mappa, mentre il metodo Select svolge il compito di ridurre i risultati intermedi nell'elenco finale dei risultati.

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);

Per la parte distribuita, puoi consultare DryadLINQ: http: / /research.microsoft.com/en-us/projects/dryadlinq/default.aspx

Answer 3

Dato che non ricordo mai che LINQ lo chiama Where , Select e Aggregate invece di Filter , < codice> Mappa e Riduci , quindi ho creato alcuni metodi di estensione che puoi usare:

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

Ecco i 3 metodi (da 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);
}

Alcuni ulteriori dettagli da https://github.com/cs-util -com / cscore # ienumerable-extensions :

Answer 4

Se stavi cercando di scrivere la tua versione di Google, questo potrebbe giustificarlo .. !!!

Scherzi a parte, se hai un problema che puoi scomporre in diversi problemi minori, una soluzione Map-Reduce funzionerebbe. Il documento di Google su MapReduce contiene numerosi buoni esempi, incluso come elaborare migliaia di pagine web, contare le parole nel documento ecc. ecc.