Bons exemples de MapReduce
Je ne pouvais pas penser à de bons exemples autres que la tâche "Comment compter les mots dans un long texte avec MapReduce". J'ai trouvé que ce n'était pas le meilleur exemple pour donner aux autres une idée de la puissance de cet outil.
Je ne cherche pas d'extraits de code, mais juste des exemples "textuels".
La carte réduit est un cadre qui a été développé pour traiter efficacement des quantités énormes de données. Par exemple, si un jeu de données contient 1 million d'enregistrements et qu'il est stocké dans une représentation relationnelle, il est très coûteux de dériver des valeurs et d'effectuer toute sorte de transformations sur celles-ci.
Par exemple, en SQL, en fonction de la date de naissance, déterminer combien de personnes sont âgées de plus de 30 ans sur un million d’enregistrements prendrait un certain temps, et cela ne ferait que croître par ordre de magnitude lorsque la complexité de la requête augmentera. Map Reduce fournit une implémentation basée sur un cluster où les données sont traitées de manière distribuée.
Voici un article de Wikipédia expliquant en quoi consiste map-reduce est tout au sujet
Un autre bon exemple est Finding Friends via map, qui peut être un puissant exemple pour comprendre le concept et constituer un cas d'utilisation bien utilisé.
Personnellement, trouvé ce lien très utile pour comprendre le concept
Copie de l'explication fournie dans le blog (Dans le cas où le lien deviendrait périmé)
Trouver des amis
MapReduce est un framework développé à l'origine par Google qui permet une informatique distribuée à grande échelle et facile dans plusieurs domaines. Apache Hadoop est une implémentation open source.
Je passerai sur les détails, mais cela revient à définir deux fonctions: une fonction de carte et une fonction de réduction. La fonction map prend une valeur et génère des paires clé: valeur. Par exemple, si nous définissons une fonction map qui prend une chaîne et affiche la longueur du mot en tant que clé et le mot lui-même en tant que valeur, map (steve) renverra 5: steve et map (savannah) renverra 8: savannah . Vous avez peut-être remarqué que la fonction map est sans état et ne nécessite que la valeur d'entrée pour calculer sa valeur de sortie. Cela nous permet d’exécuter la fonction de carte en parallèle avec des valeurs et offre un avantage considérable. Avant de passer à la fonction de réduction, le cadre mapreduce regroupe toutes les valeurs par clé. Par conséquent, si les fonctions de carte génèrent les paires clé: valeur suivantes:
3 : the 3 : and 3 : you 4 : then 4 : what 4 : when 5 : steve 5 : where 8 : savannah 8 : researchIls sont regroupés comme suit:
3 : [the, and, you] 4 : [then, what, when] 5 : [steve, where] 8 : [savannah, research]Chacune de ces lignes serait ensuite transmise en tant qu'argument à la fonction de réduction, qui accepte une clé et une liste de valeurs. Dans ce cas, nous pourrions essayer de déterminer le nombre de mots de certaines longueurs. Notre fonction de réduction ne comptera donc que le nombre d'éléments de la liste et affichera la clé avec la taille de la liste, comme suit:
3 : 3 4 : 3 5 : 2 8 : 2Les réductions peuvent également être effectuées en parallèle, ce qui constitue à nouveau un avantage considérable. Nous pouvons ensuite regarder ces résultats finaux et voir qu'il n'y avait que deux mots de longueur 5 dans notre corpus, etc.
L'exemple le plus courant de mapreduce est de compter le nombre de fois où les mots sont présents dans un corpus. Supposons que vous ayez une copie d’Internet (j’ai la chance d’avoir travaillé dans une telle situation) et que vous vouliez une liste de chaque mot sur Internet, ainsi que le nombre de fois que cela se produisait.
La façon dont vous aborderiez cela consisterait à segmenter les documents que vous avez (divisez le document en mots) et à transmettre chaque mot à un mappeur. Le mappeur aurait alors recraché le mot avec la valeur
1. La phase de regroupement prendra toutes les clés (dans ce cas-ci des mots) et fera une liste de 1. La phase de réduction prend alors une clé (le mot) et une liste (une liste de 1 pour chaque fois que la clé est apparue sur Internet), et résume la liste. Le réducteur affiche ensuite le mot, ainsi que son compte. En fin de compte, vous aurez une liste de chaque mot sur Internet, ainsi que le nombre de fois où il est apparu.Facile, non? Si vous avez déjà entendu parler de mapreduce, le scénario ci-dessus n'est pas nouveau. C'est le "Hello, World" de mapreduce. Voici donc un cas d'utilisation dans le monde réel (Facebook peut ou non faire ce qui suit, ce n'est qu'un exemple):
Facebook a une liste d'amis (notez que les amis sont bidirectionnels sur Facebook. Si je suis votre ami, vous êtes à moi). Ils disposent également de beaucoup d'espace disque et répondent à des centaines de millions de requêtes chaque jour. Ils ont décidé de pré-calculer les calculs lorsqu'ils le pouvaient afin de réduire le temps de traitement des demandes. Une requête de traitement courante est la fonctionnalité "Vous et Joe avez 230 amis en commun". Lorsque vous visitez le profil de quelqu'un, vous voyez une liste d'amis que vous avez en commun. Cette liste ne change pas souvent, il serait donc inutile de la recalculer chaque fois que vous visiterez le profil (vous pouvez bien sûr utiliser une stratégie de mise en cache décente, mais je ne serais pas en mesure de continuer à écrire sur mapreduce pour résoudre ce problème). Nous allons utiliser mapreduce afin de pouvoir calculer les amis communs de tout le monde une fois par jour et stocker ces résultats. Plus tard, c'est juste une recherche rapide. Nous avons beaucoup de disques, c'est bon marché.
Supposons que les amis sont stockés en tant que personne -> [Liste d'amis], notre liste d'amis est alors:
A -> B C D B -> A C D E C -> A B D E D -> A B C E E -> B C DChaque ligne sera un argument pour un mappeur. Pour chaque ami de la liste d'amis, le mappeur générera une paire clé-valeur. La clé sera un ami avec la personne. La valeur sera la liste d'amis. La clé sera triée de manière à ce que les amis soient en ordre, ce qui fera que toutes les paires d'amis iront au même réducteur. C'est difficile à expliquer avec du texte, alors faisons-le et voyons si vous pouvez voir le motif. Une fois que tous les mappeurs ont été exécutés, vous obtenez une liste comme celle-ci:
For map(A -> B C D) : (A B) -> B C D (A C) -> B C D (A D) -> B C D For map(B -> A C D E) : (Note that A comes before B in the key) (A B) -> A C D E (B C) -> A C D E (B D) -> A C D E (B E) -> A C D E For map(C -> A B D E) : (A C) -> A B D E (B C) -> A B D E (C D) -> A B D E (C E) -> A B D E For map(D -> A B C E) : (A D) -> A B C E (B D) -> A B C E (C D) -> A B C E (D E) -> A B C E And finally for map(E -> B C D): (B E) -> B C D (C E) -> B C D (D E) -> B C D Before we send these key-value pairs to the reducers, we group them by their keys and get: (A B) -> (A C D E) (B C D) (A C) -> (A B D E) (B C D) (A D) -> (A B C E) (B C D) (B C) -> (A B D E) (A C D E) (B D) -> (A B C E) (A C D E) (B E) -> (A C D E) (B C D) (C D) -> (A B C E) (A B D E) (C E) -> (A B D E) (B C D) (D E) -> (A B C E) (B C D)Chaque ligne sera transmise en argument à un réducteur. La fonction de réduction intersectera simplement les listes de valeurs et produira la même clé avec le résultat de l'intersection. Par exemple, réduire ((A B) -> (A C D E) (B C D)) produira (A B): (C D) et signifie que les amis A et B ont C et D comme amis communs.
Le résultat après réduction est:
(A B) -> (C D) (A C) -> (B D) (A D) -> (B C) (B C) -> (A D E) (B D) -> (A C E) (B E) -> (C D) (C D) -> (A B E) (C E) -> (B D) (D E) -> (B C)Maintenant, lorsque D visite le profil de B, nous pouvons rapidement rechercher
(B D)et voir qu'ils ont trois amis en commun,(A C E).
n des meilleurs exemples d'implémentation de MapReduce similaire à Hadoop .
Gardez toutefois à l'esprit qu'ils se limitent aux implémentations de l'idée MapReduce basées sur les valeurs clés (elles limitent donc l'applicabilité).
Un ensemble d'opérations familières que vous pouvez effectuer dans MapReduce est l'ensemble d'opérations SQL normales: SELECT, SELECT WHERE, GROUP BY, etc.
Un autre bon exemple est la matrice multipliée, où vous passez une ligne de M et le vecteur entier x et vous calculez un élément de M * x.
De temps en temps, je présente des concepts de MR à des personnes. Je trouve les tâches de traitement familières aux utilisateurs, puis je les mappe au paradigme MR.
D'habitude je prends deux choses:
Groupe par/agrégations. Ici, l’avantage de la phase de brassage est évident. Une explication selon laquelle le brassage est également un tri distribué + une explication de l'algorithme de tri distribué est également utile.
Jointure de deux tables. Les personnes travaillant avec DB connaissent bien le concept et son problème d'évolutivité. Montrez comment cela peut être fait dans MR.