Mapper et réduire en .NET

Question

Quels scénarios justifieraient l'utilisation de la " Mapper et réduire " algorithme?

Existe-t-il une implémentation .NET de cet algorithme?

Answer 1

Équivalents Linq de Map and Reduce: Si vous avez la chance d’avoir linq, vous n’avez pas besoin d’écrire votre propre carte et de réduire les fonctions. C # 3.5 et Linq l’a déjà, bien que sous différents noms.

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 -en-c /

Answer 2

Les classes de problèmes qui conviennent bien à une solution de style mapreduce sont des problèmes d’agrégation. Extraire des données d'un jeu de données. En C #, on pourrait tirer parti de LINQ pour programmer dans ce style.

Extrait de l'article suivant: http://codecube.net/2009/02/mapreduce-in- c-using-linq /

  

la méthode GroupBy agit en tant que carte, tandis que la méthode Select permet de réduire les résultats intermédiaires dans la liste finale des résultats.

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

Pour la partie distribuée, vous pouvez consulter DryadLINQ: http: / /research.microsoft.com/en-us/projects/dryadlinq/default.aspx

Answer 3

Comme je ne me souviens jamais que LINQ l’appelle Où , Sélectionnez et Aggregate au lieu de Filtre , < code> Map et Réduire , j'ai donc créé quelques méthodes d'extension que vous pouvez utiliser:

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

Voici les 3 méthodes (de https://github.com/cs-util-com/cscore/blob/master/CsCore/PlainNetClassLib/src/Plugins/CsCore/com/csutil/collections/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);
}

Quelques détails supplémentaires sur https://github.com/cs-util -com / cscore # ienumerable-extensions :

Answer 4

Si vous essayez d'écrire votre propre version de Google, cela pourrait le justifier .. !!!

Sérieusement, si vous rencontrez un problème que vous pouvez décomposer en plusieurs problèmes plus petits, une solution Map-Réduire fonctionnerait. Le document Google sur MapReduce contient plusieurs bons exemples, notamment le traitement de milliers de pages Web, nombre de mots dans le document, etc., etc.