Question

我听说过很多关于map / reduce的内容，特别是在Google大规模并行计算系统的背景下。究竟是什么？

Answer 1

来自Google MapReduce研究出版物页面的摘要：

MapReduce是一种编程模型一个相关的实现处理和生成大数据集。用户指定地图功能处理键/值对生成一组中间体键/值对和reduce函数合并所有中间值与相同的中间体相关联键。

MapReduce的优势在于可以在多个处理节点（多个服务器）上并行执行处理，因此它是一个可以很好地扩展的系统。

由于它来自functional programming模型，因此map和reduce步骤都没有任何副作用（{{1}的每个子部分的状态和结果} process不依赖于另一个），因此映射和缩减的数据集可以在多个处理节点上分开。

Joel的Can Your Programming Language Do This?文章讨论了如何理解函数式编程对谷歌提出如何为其搜索引擎提供动力的MapReduce至关重要。如果您不熟悉函数式编程以及它如何允许可伸缩代码，那么这是一个非常好的阅读。

另请参阅：Wikipedia: MapReduce

相关问题：Please explain mapreduce simply

Answer 2

MapReduce Explained

它解释得比我能做得更好。这有帮助吗？

Answer 3

Map是一个函数，它将另一个函数应用于列表中的所有项，以生成另一个列表，其中包含所有返回值。（另一种说法是“将f应用于x”是“调用f，传递给它x”。所以有时说“应用”而不是“调用”听起来更好。）

这就是地图可能用C＃编写的（它叫做Select并且在标准库中）：

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

因为你是一个Java家伙，Joel Spolsky喜欢告诉GROSSLY UNFAIR LIES关于Java是多么糟糕（实际上，他不是说谎，这很糟糕，但我想要赢得你），这是我的非常粗略尝试Java版本（我没有Java编译器，我依稀记得Java版本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;
}

我确信这可以通过百万种方式得到改善。但这是基本的想法。

Reduce是一个将列表中的所有项目都转换为单个值的函数。为此，需要为其提供另一个函数func，将两个项目转换为单个值。它可以通过将前两个项目提供给func来实现。然后是第三项的结果。然后是第四个项目的结果，依此类推，直到所有项目都消失了，我们留下了一个值。

在C＃中，reduce被称为Aggregate，并且再次出现在标准库中。我将直接跳到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;
}

这些Java版本需要添加泛型，但我不知道如何在Java中执行此操作。但是你应该能够传递匿名内部类来提供函子：

string[] names = getLotsOfNames();

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

希望仿制药可以摆脱演员阵容。 C＃中的类型安全等价物是：

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

为什么这个“酷”？将更大的计算分解成更小的部分的简单方法，因此它们可以以不同的方式重新组合在一起，总是很酷。 Google应用这种想法的方式是并行化，因为map和reduce都可以通过多台计算机共享。

但关键要求并不是您的语言可以将函数视为值。任何OO语言都可以做到这一点。并行化的实际要求是，传递给map和reduce的小func函数不得使用或更新任何状态。它们必须返回一个仅依赖于传递给它们的参数的值。否则，当您尝试并行运行整个过程时，结果将完全搞砸。

Answer 4

在对非常长的waffley或非常简短的博客文章感到非常沮丧之后，我最终发现了这个very good rigorous concise paper。

然后我继续前进，通过翻译成Scala使其更简洁，我提供了最简单的情况，用户只需指定应用程序的map和reduce部分。在Hadoop / Spark中，严格来说，采用了更复杂的编程模型，要求用户明确指定此处列出的另外4个函数：http://en.wikipedia.org/wiki/MapReduce#Dataflow

import scalaz.syntax.id._

trait MapReduceModel {
  type MultiSet[T] = Iterable[T]

  // `map` must be a pure function
  def mapPhase[K1, K2, V1, V2](map: ((K1, V1)) => MultiSet[(K2, V2)])
                              (data: MultiSet[(K1, V1)]): MultiSet[(K2, V2)] = 
    data.flatMap(map)

  def shufflePhase[K2, V2](mappedData: MultiSet[(K2, V2)]): Map[K2, MultiSet[V2]] =
    mappedData.groupBy(_._1).mapValues(_.map(_._2))

  // `reduce` must be a monoid
  def reducePhase[K2, V2, V3](reduce: ((K2, MultiSet[V2])) => MultiSet[(K2, V3)])
                             (shuffledData: Map[K2, MultiSet[V2]]): MultiSet[V3] =
    shuffledData.flatMap(reduce).map(_._2)

  def mapReduce[K1, K2, V1, V2, V3](data: MultiSet[(K1, V1)])
                                   (map: ((K1, V1)) => MultiSet[(K2, V2)])
                                   (reduce: ((K2, MultiSet[V2])) => MultiSet[(K2, V3)]): MultiSet[V3] =
    mapPhase(map)(data) |> shufflePhase |> reducePhase(reduce)
}

// Kinda how MapReduce works in Hadoop and Spark except `.par` would ensure 1 element gets a process/thread on a cluster
// Furthermore, the splitting here won't enforce any kind of balance and is quite unnecessary anyway as one would expect
// it to already be splitted on HDFS - i.e. the filename would constitute K1
// The shuffle phase will also be parallelized, and use the same partition as the map phase.  
abstract class ParMapReduce(mapParNum: Int, reduceParNum: Int) extends MapReduceModel {
  def split[T](splitNum: Int)(data: MultiSet[T]): Set[MultiSet[T]]

  override def mapPhase[K1, K2, V1, V2](map: ((K1, V1)) => MultiSet[(K2, V2)])
                                       (data: MultiSet[(K1, V1)]): MultiSet[(K2, V2)] = {
    val groupedByKey = data.groupBy(_._1).map(_._2)
    groupedByKey.flatMap(split(mapParNum / groupedByKey.size + 1))
    .par.flatMap(_.map(map)).flatten.toList
  }

  override def reducePhase[K2, V2, V3](reduce: ((K2, MultiSet[V2])) => MultiSet[(K2, V3)])
                             (shuffledData: Map[K2, MultiSet[V2]]): MultiSet[V3] =
    shuffledData.map(g => split(reduceParNum / shuffledData.size + 1)(g._2).map((g._1, _)))
    .par.flatMap(_.map(reduce))
    .flatten.map(_._2).toList
}

Answer 5

MapReduce和/或SQL：

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

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

批评MapReduce

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

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

Answer 6

Map是一种可应用于数组的本机JS方法。它会创建一个新数组，因为某些函数映射到原始数组中的每个元素。因此，如果您映射了一个函数（element）{return element * 2;}，它将返回一个新数组，其中每个元素都加倍。原始数组将不加修改。

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map

Reduce是一种原生的JS方法，也可以应用于数组。它将函数应用于数组，并具有称为累加器的初始输出值。它循环遍历数组中的每个元素，应用一个函数，并将它们减少为单个值（从累加器开始）。它很有用，因为你可以拥有你想要的任何输出，你只需要从那种类型的累加器开始。因此，如果我想将某些内容减少为对象，我将从累加器{}开始。

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce?v=a

Answer 7

MapReduce：

要运行更大的设备，我们可以使用办公室中不同计算机的计算能力。困难的部分是在不同计算机之间分配任务，这是通过MapReduce库完成的。

基本思想是将作业分为两部分：映射和简化。 Map基本上解决了这个问题，将其拆分为多个子部分，然后将这些子部分发送到不同的计算机上-因此所有部分都在同一时间运行。 Reduce将从子部分中获得结果，并将其组合在一起以获得单个答案。

输入是记录列表。映射计算的结果是键/值对列表。 Reduce会使用具有相同键的每组值，并将它们组合为一个值。您无法确定作业是分成100个还是2个；最终结果看起来很像一张地图的结果。

请查看简单的地图并简化程序：

Map函数用于在我们的原始列表上应用某些功能，因此会生成一个新列表。 Python中的map（）函数接受一个函数和一个列表作为参数。通过将函数应用于列表的每个项目，将返回一个新列表。

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

Python中的reduce（）函数接受一个函数和一个列表作为参数。该函数使用lambda函数和一个列表调用，并返回一个新的简化结果。这会对列表对执行重复操作。

#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

什么是Map / Reduce？

7 个答案: