08 - Hadoop. Алгоритмы на графах в MapReduce

MapReduce в Hadoop
Графы

Граф как структура данных
G = (V,E)
– V представляет собой множество вершин (nodes)
– E представляет собой множество ребер
(edges/links)
– Ребра и вершины могут содержать
дополнительную информацию

V = {1, 2, 3, 4, 5, 6}
E = {[1,2], [1,4], [1,6], [3,1], … }
W1,2 = 3, W1,4 = 2, W1,6 = 7, W3,1 = 8, …
2
1
4
5
3
6
3
2
7
8
4
1
2
1
5 1

Неориентированный Ориентированный

Несвязный Полный

Графы на практике

Структура компьютеров и серверов сети

Задачи и проблемы на графах

Поиск кратчайшего пути
• Роутинг траффика
• Навигация маршрута

Поиск минимального остовного дерева
(Minimum Spanning Tree)
• Телекоммуникационные компании

Поиск максимального потока (Max Flow)
• Структура компьютеров и серверов Интернет

Алгоритмы
ссылочного
ранжирования
• PageRank
• HITS

Леонард Эйлер
Проблема семи мостов Кёнигсберга

• Вычисления на каждой вершине
• Обход графа

Ключевые вопросы:
– Как представить граф в MapReduce?
– Как обходить граф в MapReduce?

Матрица смежности
Граф представляется как матрица M размером n x n
– n = |V|
– Mij = 1 означает наличие ребра между i и j
1 2 3 4
1 0 1 0 1
2 1 0 1 1
3 1 0 0 0
4 1 0 1 0
1
2
3
4

Матрица смежности
Плюсы
– Удобство математических вычислений
– Перемещение по строкам и колонкам
соответствует переходу по входящим и
исходящим ссылкам
Минусы
– Матрица разреженная, множество лишних
нулей
– Расходуется много лишнего места
1 2 3 4
1 0 1 0 1
2 1 0 1 1
3 1 0 0 0
4 1 0 1 0

Списки смежности
Берем матрицу смежности и убираем все нули
1 2 3 4
1 0 1 0 1
2 1 0 1 1
3 1 0 0 0
4 1 0 1 0
1: 2, 4
2: 1, 3, 4
3: 1
4: 1, 3

Списки смежности
• Плюсы
– Намного более компактная реализация
– Легко найти все исходящие ссылки для
вершины
• Минусы
– Намного сложнее подсчитать входящие ссылки

Поиск кратчайшего пути в графе

Алгоритм Дейкстры
0




10
5
2 3
2
1
9
7
4 6

0
10
5


10
5
2 3
2
1
9
7
4 6

0
8
5
14
7
10
5
2 3
2
1
9
7
4 6

0
8
5
13
7
10
5
2 3
2
1
9
7
4 6

0
8
5
9
7
10
5
2 3
2
1
9
7
4 6

Алгоритм Дейкстры
Dijkstra(V, s, w)
for all vertex v ∈ V do
d[v] ← ∞
d[s] ← 0
Q ← {V }
while Q != ∅ do
u ←ExtractMin(Q)
for all vertex v ∈ u.AdjacencyList do
if d[v] > d[u] + w(u, v) then
d[v] ← d[u] + w(u, v)

Поиск кратчайшего пути
• Пусть веса ребер равны 1
• Решение по индукции:
– DISTANCETO(s) = 0
– DISTANCETO(s->p) = 1
– DISTANCETO(n) = 1 + min(DISTANCETO(m), m  M)
s
m3
m2
m1
n
…
…
…
d1
d2
d3

Параллельный поиск в ширину (BFS)
n0
n3
n2
n1 n7
n6
n5
n4
n9
n8

Breadth First Search: представление данных
– Key: вершина n
– Value: d (расстояние от начала), adjacency list (вершины,
доступные из n)
– Инициализация: для всех вершин, кроме начальной, d = 
1 –> [0, {2, 3, 4}]
2 -> [, {5, 6} ]
3 -> [, {} ]
4 -> [, {7, 8} ]
5 -> [, {9, 10} ]
…

Breadth First Search: Mapper
mapper(key, value):
emit(key, value)
m  value.adjacency_list: emit (m, value.d + 1)

Breadth First Search: Mapper
1 –> [0, {2, 3, 4}]
1 –> [0, {2, 3, 4}]
2 -> [1, {} ]
3 -> [1, {} ]
4 -> [1, {} ]
2 -> [, {5, 6} ]
2 –> [, {5, 6}]
5 -> [, {} ]
6 -> [, {} ]
Mapper 1
Mapper 2

Breadth First Search: Reducer
• Sort/Shuffle
– Сгруппировать расстояния по достижимым вершинам
• Reducer:
– Выбрать путь с минимальным расстоянием для каждой
достижимой вершины
– Сохранить структуру графа

Breadth First Search: Reducer
2 –> {[1, {} ], [, {5, 6}]}
2 –> [1, {5, 6} ]
Reduce In:
Reduce Out:

class Mapper
method Map(nid n, node N)
d ← N.Distance
Emit(nid n,N) // Pass along graph structure
for all nodeid m ∈ N.AdjacencyList do
Emit(nid m, d + 1) // Emit distances to
reachable nodes
BFS: псевдокод

class Reducer
method Reduce(nid m, [d1, d2, . . .])
dmin ← ∞
M ← ∅
for all d ∈ counts [d1, d2, . . .] do
if IsNode(d) then
M ← d // Recover graph structure
else if d < dmin then
dmin ← d
M.Distance ← dmin // Update shortest distance
Emit(nid m, node M)
BFS: псевдокод

1 –> [0, {2, 3, 4}]
2 -> [, {5, 6} ]
3 -> [, {} ]
4 -> [, {7, 8} ]
5 -> [, {9, 10} ]
…
1 –> [0, {2, 3, 4}]
2 -> [1, {5, 6} ]
3 -> [1, {} ]
4 -> [1, {7, 8} ]
5 -> [, {9, 10} ]
…
1 –> [0, {2, 3, 4}]
2 -> [1, {5, 6} ]
3 -> [1, {} ]
4 -> [1, {7, 8} ]
5 -> [2, {9, 10} ]
…
1 –> [0, {2, 3, 4}]
2 -> [1, {5, 6} ]
3 -> [1, {} ]
4 -> [1, {7, 8} ]
5 -> [2, {9, 10} ]
…
Input Iteration 1
Iteration 2Result
…

Breadth First Search: Итерации
• Каждая итерация задачи MapReduce смещает границу
продвижения по графу (frontier) на один “hop”
– Последующие операции включают все больше и больше
посещенных вершин, т.к. граница (frontier) расширяется
– Множество итераций требуется для обхода всего графа
• Сохранение структуры графа
– Проблема: что делать со списком смежных вершин
(adjacency list)?
– Решение: Mapper также пишет (n, adjacency list)

BFS: критерий завершения
• Как много итераций нужно для завершения
параллельного BFS?
• Когда первый раз посетили искомую вершину,
значит найден самый короткий путь
• Равно диаметру графа
• Практическая реализация
– Внешняя программа-драйвер для проверки оставшихся вершин с
дистанцией 
– Можно использовать счетчики из Hadoop MapReduce

BFS vs Дейкстра
• Алгоритм Дейкстры более эффективен
– На каждом шаге используются вершины только из пути с
минимальным весом
– Нужна дополнительная структура данных (priority queue)
• MapReduce обходит все пути графа параллельно
– Много лишней работы (brute-force подход)
– Полезная часть выполняется только на текущей границе
обхода

BFS: Weighted Edges
• Добавим положительный вес каждому ребру
• Простая доработка: добавим вес w для каждого
ребра в список смежных вершин
– В mapper, emit (m, d + wp) вместо (m, d + 1) для каждой
вершины m

BFS Weighted: критерий завершения
• Как много итераций нужно для завершения
параллельного BFS (взвешенный граф)?
• Когда первый раз посетили искомую вершину,
значит найден самый короткий путь
• И это неверно!

BFS Weighted: сложности
s
p
q
r
search frontier
10
n1
n2
n3
n4
n5
n6 n7
n8
n9
1
1
1
1
1
1
1
1

BFS Weighted: критерий завершения
• В худшем случае: N – 1
• В реальном мире ~= диаметру графа
• Практическая реализация
– Итерации завершаются, когда минимальный путь у
каждой вершины больше не меняется
– Для этого можно также использовать счетчики в
MapReduce

PageRank
• Определяет важность страницы
• Характеризует кол-во времени, которое
пользователь провел на данной странице
• Модель блуждающего веб-серфера
– Пользователь начинает серфинг на случайной веб-странице
– Пользователь произвольно кликает по ссылкам, тем самым
перемещаясь от страницы к странице

Вычисление PageRank
• Свойства PageRank’а
– Может быть рассчитан итеративно
– Локальный эффект на каждой итерации
• Набросок алгоритма
– Начать с некоторыми заданными значения PRi
– Каждая страница распределяет PRi “кредит” всем страниц,
на которые с нее есть ссылки
– Каждая страница добавляет весь полученный “кредит” от
страниц, которые на нее ссылаются, для подсчета PRi+1
– Продолжить итерации пока значения не сойдутся

Упрощения для PageRank
Рассмотрим простой случай
– Нет фактора случайного перехода (random jump)
– Нет “подвисших” вершин

n1 (0.2)
n4 (0.2)
n3 (0.2)
n5 (0.2)
n2 (0.2)
0.1
0.1
0.2 0.2
0.1
0.1
0.066 0.066
0.066
n1 (0.066)
n4 (0.3)
n3 (0.166)
n5 (0.3)
n2 (0.166)
Iteration 1

n1 (0.066)
n4 (0.3)
n3 (0.166)
n5 (0.3)
n2 (0.166)
0.033
0.033
0.3 0.166
0.083
0.083
0.1 0.1
0.1
n1 (0.1)
n4 (0.2)
n3 (0.183)
n5 (0.383)
n2 (0.133)
Iteration 2

n5 [n1, n2, n3]n1 [n2, n4] n2 [n3, n5] n3 [n4] n4 [n5]
n2 n4 n3 n5 n1 n2 n3n4 n5
n2 n4n3 n5n1 n2 n3 n4 n5
n5 [n1, n2, n3]n1 [n2, n4] n2 [n3, n5] n3 [n4] n4 [n5]
Map
Reduce

class Mapper
method Map(nid n, node N)
p ← N.PageRank/|N.AdjacencyList|
Emit(nid n,N)
for all nodeid m ∈ N.AdjacencyList do
Emit(nid m, p)
PageRank: Mapper

class Reducer
method Reduce(nid m, [p1, p2, . . .])
M ← ∅
for all p ∈ counts [p1, p2, . . .] do
if IsNode(p) then
M ← p
else
s ← s + p
M.PageRank ← s
Emit(nid m, node M)
PageRank: Reducer

Полный PageRank
• Обработка “подвешенных” вершин
• Случайный переход (random jump)

Сходимость PageRank
• Продолжать итерации пока значения
PageRank не перестанут изменяться
• Продолжать итерации пока отношения
PageRank не перестанут изменяться
• Фиксированное число итераций

Проблемы MapReduce на графах

• Многословность Java
• Время запуска таска в Hadoop
• Медленные или зависшие таски
• Бесполезность фазы shuffle для графов
• Проверки на каждой итерации
• Итеративные алгоритмы на MapReduce
неэффективны!
MapReduce на графах, проблемы

In-Mapper Combining
• Использование комбайнеров
– Агрегирует данные на
mapper
– Но, промежуточные данные
все равно обрабатываются
• In-mapper combining
– Агрегируем сообщения в
буффере
– Но, требуется управление
памятью
setup
map
cleanup
buffer
Emit all key-
value pairs
at once

Улучшение партиционирования
• По-умолчанию: hash partitioning
• Наблюдение: много графов имеют локальную
структуру
– Например, коммьюнити в соц.сетях
– Улучшение локальной агрегации
• Но, партиционирование довольно сложно!
– Иногда простые эвристики помогают
– Для веб-графа: использовать партиционирование на
основе домена от URL

Schimmy Design Pattern
• Обычно два набора данных:
– Messages (актуальные вычисления)
– Graph structure (структура обрабатываемого графа)
• Schimmy: выполнять shuffle только для messages
S TS1 T1 S2 T2 S3 T3

ReducerReducerReducer
S TS1 T1 S2 T2 S3 T3
intermediate data
(messages)
intermediate data
(messages)
intermediate data
(messages)
from HDFS
(graph structure)
from HDFS
(graph structure)
from HDFS
(graph structure)
Обе части (S и T) консистентно партиционированы и сортированы по join key

Эксперимент
• Cluster setup:
– 10 workers, each 2 cores (3.2 GHz Xeon), 4GB RAM, 367 GB disk
– Hadoop 0.20.0 on RHELS 5.3
• Dataset:
– Первый сегмент английского текста из коллекции ClueWeb09
– 50.2m web pages (1.53 TB uncompressed, 247 GB compressed)
– Extracted webgraph: 1.4 Млрд ссылок, 7.0 GB
– Dataset сортирован в порядке краулинга
• Setup:
– Измерялось время выполнения по каждой итерации (5 итераций)
– 100 партиций

+18%
-15%
-60%
-69%
1.4b
674m
86m

08 - Hadoop. Алгоритмы на графах в MapReduce

More Related Content

What's hot (20)

Similar to 08 - Hadoop. Алгоритмы на графах в MapReduce (20)

More from Roman Brovko (20)

08 - Hadoop. Алгоритмы на графах в MapReduce