Распараллеливание «Уменьшить» в «MapReduce»

Да, если оператор ассоциативен. Например, можно параллелизировать подведение итогов списка чисел:

step 1: 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8
step 2:   3   +   7   +   11  +   15
step 3:       10      +       26
step 4:               36

Это работает, потому что (a+b) +c = + (b+c), т.е. порядок, в котором выполняются дополнения, не имеет значения.

Проверьте фазу объединения в Hadoop

http://wiki.apache.org/hadoop/HadoopMapReduce

Не уверенный, о какой платформе/языке Вы думаете, но можно параллелизировать, уменьшают операторы как это:

// Original
result = null;
foreach(item in map) {
    result += item;
}

// Parallel
resultArray = array();
mapParts = map.split(numThreads);
foreach(thread) {
    result = null;
    foreach(item in mapParts[thread]) {
        result += item;
    }
    resultArray += result;    // Lock this!
}
waitForThreads();
reduce(resultArray);

Как Вы видите, параллельная реализация является легко рекурсивной. Вы разделяете карту, воздействуете на каждую часть в ее собственном потоке, затем выполняете, другой уменьшает, после того как те потоки сделаны для объединения частей.

(Это - программное обоснование позади ответа Piotr Lesnick.)

Это зависит от Вашего Уменьшать шаг. В реализации Hadoop-стиля MapReduce Ваш Reducer становится позвонившим однажды на ключ со всеми строками, относящимися к тому ключу.

Так, например, Ваш Картопостроитель мог бы брать в большом количестве незаказанных журналов веб-сервера, добавляя некоторые метаданные (например, геокодируя), и испуская [ключ, запись] пары с идентификатором cookie как ключ. Ваш Редуктор затем назвали бы однажды на идентификатор cookie и будут питать все данные для того cookie и мог вычислить совокупную информацию, такую как частота посещения или средние страницы, просмотренные на посещение. Или Вы могли включить данные геокода и собрать совокупную статистику на основе географии.

Даже если Вы не делаете совокупного анализа на ключ - действительно даже при вычислениях чего-то по полному набору - могло бы быть возможно повредить вычисление в блоки, каждый из которых мог питаться к Редуктору.

Эй!! Я единственный, кто думает, что время документировать код до вы начинаете набивать ключи?

Если ваши ведущие разработчики не понимают концепцию дизайна до кода (и обзора дизайна), то у вас есть некоторые серьезные проблемы, и применение пластинки типа того, что младший пишет то, что он думает код, после того, как он написан, не поможет.

Есть ли у вас процессы? SQA?

Вместо непосредственного включения данных в запрос SQL следует использовать кавычки DB-API:

sql = """INSERT INTO temporary_load
    (domain_name, session_count, search_count, click_count,
    revenue, revenue_per_min, cost_per_click, traffic_date)
    VALUES (%s, %d, %d, %d, %d, %d, %d, %s)"""
args = (cell[0],
        int(cell[1]),
        int(cell[2].replace (",","")),
        int(cell[3].replace(",","")),
        float(cell[4].replace("$","")),
        float(cell[5].replace("$","")),
        float(cell[6].replace("$","")),
        parsed_date)
cur.execute(sql, args)

Это позволяет модулю DB-API правильно цитировать значения и решать целый ряд проблем, которые могут возникнуть при выполнении запроса вручную (и обычно неправильно).

Технически уменьшение не является таким же, как складка (складка слева), которая также может быть описана как накопление.

Пример, приведенный Джулсом, очень хорошо иллюстрирует операцию уменьшения:

step 1: 1 + 2 + 3 + 4 
step 2:   3   +   7   
step 3:       10      

Обратите внимание, что на каждом шаге результатом является массив, включая конечный результат, который является массивом одного предмета.

Сворачивание слева похоже на следующее:

step 0: a = 0
step 1: a = a + 1 
step 2: a = a + 2 
step 3: a = a + 3
step 4: a = a + 4
step 5: a

Теперь очевидно, что они оба дают одни и те же результаты, но сворачивание имеет хорошо определенный результат, когда дается неассоциативный оператор (например, вычитание), тогда как оператор уменьшения - нет.