Karte und reduzieren in .NET

Question

Welche Szenarien die Verwendung des rechtfertigen würden " Map und Reduce " Algorithmus?

Gibt es eine .NET-Implementierung dieses Algorithmus?

Answer 1

Linq Äquivalente Map und Reduce: Wenn Sie Glück haben, zu haben Linq dann brauchen Sie nicht Ihre eigene Karte zu schreiben und Funktionen zu reduzieren. C # 3.5 und Linq bereits hat es allerdings unter verschiedenen Namen.

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

Die Klassen von Problemen, die für eine mapreduce Stil Lösung gut geeignet sind, sind Probleme der Aggregation. Von Daten aus einem Datensatz zu extrahieren. In C #, ein Vorteil von LINQ to Programm in diesem Stil nehmen könnte.

Aus dem folgenden Artikel: http://codecube.net/2009/02/mapreduce-in- c-using-Linq /

  

die GroupBy-Methode wird als die Karte wirkt, während die Select-Methode die Aufgabe der Verringerung der Zwischenergebnisse in die endgültige Liste der Ergebnisse der Fall ist.

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

Für den verteilten Teil, könnten Sie DryadLINQ check out: http: / /research.microsoft.com/en-us/projects/dryadlinq/default.aspx

Answer 3

Da kann ich nie vergessen, dass LINQ nennt es Where, Select und Aggregate statt Filter, Map und Reduce so dass ich ein paar Erweiterungsmethoden erstellt wurden, können Sie verwenden:

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

Hier sind die 3 Methoden (von 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);
}

Einige Details von https://github.com/cs-util -com / Cscore # IEnumerable-Erweiterungen :

Answer 4

Wenn Sie versuchen, Ihre eigene Version von Google schreiben dann das könnte es rechtfertigen .. !!!

Im Ernst, wenn Sie ein Problem haben, das Sie in mehrere kleinere Probleme zersetzen kann dann eine Map-Reduce-Lösung funktionieren würde. Das Google-Dokument auf MapReduce eine Reihe von guten Beispielen, darunter, wie Tausende von verarbeiten Web-Seiten, zählen Wörter im Dokument etc etc.