Ce qui est Map/reduce?

De l'abrégé de Google MapReduce publications de la recherche page:

MapReduce est un modèle de programmation et
associé à une mise en œuvre pour
traitement et à la production de données de grande taille
les ensembles. Aux utilisateurs de spécifier une fonction de mappage
que les processus d'une paire clé/valeur à
générer un ensemble d'intermédiaires
des paires clé/valeur, et une fonction de réduction
qui fusionne toutes les valeurs intermédiaires
associée avec le même intermédiaire
clé.

L'avantage de MapReduce est que le traitement peut être effectué en parallèle sur plusieurs nœuds de traitement (plusieurs serveurs) c'est donc un système capable de s'adapter très bien.

Puisque c'est sur la base de la programmation fonctionnelle modèle, la map et reduce les étapes de chaque n'ont pas d'effets secondaires (l'état et les résultats de chaque paragraphe d'un map processus ne dépend pas d'une autre), de sorte que l'ensemble de données mappé et réduit peuvent être séparés sur plusieurs nœuds de traitement.

Joël Votre Langage De Programmation Le Faire? pièce traite de la façon dont la compréhension de la programmation fonctionnelle a été essentiel dans Google pour venir avec MapReduce, qui alimente son moteur de recherche. C'est une très bonne lecture, si vous n'êtes pas familier avec la programmation fonctionnelle et comment il permet évolutive code.

Voir aussi: Wikipédia: MapReduce

Liés à la question: Veuillez expliquer mapreduce simplement

Carte est une fonction qui applique une fonction à tous les éléments d'une liste, pour produire une liste avec toutes les valeurs de retour sur elle. (Une autre façon de dire "application de f à x" est "call f, passant de x". Alors parfois, il semble plus agréable de dire "appliquer" au lieu de "l'appel".)

C'est la façon dont la carte est probablement écrit en C# (on appelle Select et est dans la bibliothèque standard):

public static IEnumerable<R> Select<T, R>(this IEnumerable<T> list, Func<T, R> func)
{
    foreach (T item in list)
        yield return func(item);
}

Que vous êtes un Java mec, et Joel Spolsky aime raconter des INÉQUITABLES se trouve sur la façon misérable Java est (en fait, il n'est pas mentir, c'est merdique, mais je vais essayer de vous faire gagner plus), voici ma tentative très grossière à une version de Java (je n'ai pas de compilateur Java, et je me souviens vaguement de Java version 1.1!):

//represents a function that takes one arg and returns a result
public interface IFunctor
{
    object invoke(object arg);
}

public static object[] map(object[] list, IFunctor func)
{
    object[] returnValues = new object[list.length];

    for (int n = 0; n < list.length; n++)
        returnValues[n] = func.invoke(list[n]);

    return returnValues;
}

Je suis sûr que cela peut être amélioré en un million de façons. Mais c'est l'idée de base.

Réduire est une fonction qui transforme tous les éléments d'une liste en une seule valeur. Pour ce faire, il doit être donné une autre fonction func qui transforme les deux éléments en une seule valeur. Il travail en donnant les deux premiers éléments de func. Le résultat de ce avec la troisième élément. Le résultat de ce que le quatrième élément, et ainsi de suite jusqu'à ce que tous les éléments ont disparu et nous sommes à gauche, avec une valeur.

En C# réduire est appelé Aggregate et est de nouveau dans la bibliothèque standard. Je vais passer directement à une version de Java:

//represents a function that takes two args and returns a result
public interface IBinaryFunctor
{
    object invoke(object arg1, object arg2);
}

public static object reduce(object[] list, IBinaryFunctor func)
{
    if (list.length == 0)
        return null; //or throw something?

    if (list.length == 1)
        return list[0]; //just return the only item

    object returnValue = func.invoke(list[0], list[1]);

    for (int n = 1; n < list.length; n++)
        returnValue = func.invoke(returnValue, list[n]);

    return returnValue;
}

Ces versions de Java besoin génériques en ajoutant à eux, mais je ne sais pas comment le faire en Java. Mais vous devriez être capable de les transmettre anonyme intérieure classes pour fournir des foncteurs:

string[] names = getLotsOfNames();

string commaSeparatedNames = (string)reduce(names, 
   new IBinaryFunctor {
       public object invoke(object arg1, object arg2)
           { return ((string)arg1) + ", " + ((string)arg2); }
   }

Espérons que les génériques serait de se débarrasser de la jette. Le typesafe équivalent en C# est:

string commaSeparatedNames = names.Aggregate((a, b) => a + ", " + b);

Pourquoi est-ce "cool"? Des moyens simples pour casser les plus gros calculs en petits morceaux, de sorte qu'ils peuvent être combinés de différentes manières, sont toujours fraîches. La façon dont Google s'applique cette idée est à la parallélisation, parce que les deux map et reduce peut être partagée sur plusieurs ordinateurs.

Mais l'essentiel n'est PAS que votre langue traiter fonctions en tant que valeurs. Tout langage OO peut le faire. Le besoin réel pour la parallélisation est que le petit func fonctions que vous passez à la carte et de réduire ne doit pas utiliser ou mettre à jour n'importe quel état. Ils doivent retourner une valeur qui dépend seulement de l'argument(s) passé pour eux. Sinon, les résultats seront complètement foiré quand vous essayez d'exécuter l'ensemble de la chose en parallèle.

MapReduce et/ou SQL:

http://www.data-miners.com/blog/2008/01/mapreduce-and-sql-aggregations.html

http://www.data-miners.com/blog/

critique de MapReduce

http://www.databasecolumn.com/2008/01/mapreduce-a-major-step-back.html

http://www.databasecolumn.com/2008/01/mapreduce-continued.html

MapReduce:

Pour exécuter quelque chose de grand, nous pouvons utiliser la puissance de calcul d'un autre ordinateur dans notre bureau. Partie la plus difficile est la tâche fractionnée entre plusieurs ordinateurs.Il est fait par MapReduce bibliothèque.

L'idée de base est que vous diviser le travail en deux parties: une Carte, et un à Réduire. La carte prend le problème, la divise en sous-parties, et envoie les sous-parties de machines différentes – de sorte que tous les morceaux s'exécuter en même temps. Réduire prend les résultats de la sous-parties, et de les combiner ensemble pour obtenir une réponse unique.

D'entrée est une liste d'enregistrements.Résultat de la carte, le calcul est une liste de paires clé/valeur. Réduire prend chaque ensemble de valeurs qui a la même clé, et les combine en une seule valeur.Vous ne pouvez pas savoir si le travail a été divisé en 100 pièces ou 2 pièces; le résultat final ressemble plutôt le résultat d'une seule carte.

Veuillez ressemble à un simple map et reduce programme:

Fonction Map est utilisé pour appliquer une fonction sur notre liste d'origine et une nouvelle liste est donc générée. La carte en fonction de() en Python une fonction et une liste en argument. Une nouvelle liste est renvoyée par l'application de la fonction à chaque élément de la liste.

li = [5, 7, 4, 9] 
final_list = list(map(lambda x: x*x , li)) 
print(final_list)  #[25, 49, 16, 81]

La réduire() fonction en Python une fonction et une liste en argument. La fonction est appelée avec un lambda de fonction et une liste et une nouvelle réduction de résultat est retourné. Elle effectue une opération répétitive sur les paires de la liste.

#reduce func to find product/sum of list
x=(1,2,3,4)
from functools import reduce
reduce(lambda a,b:a*b ,x) #24