Spark coalesce что это

По данным Learning Spark

Имейте в виду, что перераспределение ваших данных является довольно дорогой операцией. Spark также имеет оптимизированную версию repartition() call, coalesce() которая позволяет избежать перемещения данных, но только если вы уменьшаете количество разделов RDD.

Одно из различий, которое я получаю, заключается в том, что с repartition() количеством разделов можно увеличивать / уменьшать, но с coalesce() количеством разделов можно только уменьшаться.

Если разделы распределены по нескольким машинам и coalesce() запущены, как можно избежать перемещения данных?

Это позволяет избежать полного перемешивания. Если известно, что число уменьшается, то исполнитель может безопасно хранить данные о минимальном количестве разделов, перемещая данные только с дополнительных узлов на те узлы, которые мы сохранили.

Итак, это будет примерно так:

Затем coalesce до 2 разделов:

Обратите внимание, что Узел 1 и Узел 3 не требовали перемещения своих исходных данных.

Ответ Джастина потрясающий, и этот ответ углубляется.

repartition Алгоритм делает полный перетасовать и создает новые разделы с данными, распределенными равномерно. Давайте создадим DataFrame с номерами от 1 до 12.

numbersDf содержит 4 раздела на моей машине.

Вот как данные делятся на разделы:

Давайте сделаем полное перемешивание с repartition методом и получим эти данные на двух узлах.

Вот как numbersDfR данные разделены на моей машине:

repartition Метод делает новые разделы и равномерно распределяет данные в новых разделах (распределение данных больше даже для больших наборов данных).

Разница между coalesce и repartition

coalesce использует существующие разделы, чтобы минимизировать объем перемешиваемых данных. repartition создает новые разделы и делает полное перемешивание. coalesce приводит к разделам с различными объемами данных (иногда разделам, которые имеют очень разные размеры) и repartition приводит к разделам примерно одинакового размера.

Есть coalesce или repartition быстрее?

Прочтите этот пост в блоге, если вы хотите еще больше деталей.

Когда вы будете использовать коалесценцию и передел на практике

Источник

Согласно учебной Искре

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

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

Если разделы распределены по нескольким машинам и выполняется функция coalesce (), как она может избежать перемещения данных?

7 ответов:

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

Итак, это будет выглядеть примерно так:

Затем coalesce вплоть до 2 разделов:

Обратите внимание, что узлы 1 и 3 не требовали перемещения исходных данных.

Ответ Джастина потрясает, и этот ответ идет в более глубокое русло.

Алгоритм repartition делает полную перетасовку и создает новые разделы с данными, которые распределены равномерно. Давайте создадим фрейм данных с числами от 1 до 12.

numbersDf содержит 4 раздела на моей машине.

Вот как данные делятся на разделы:

Давайте сделаем полную перетасовку с помощью метода repartition и получим эти данные на двух узлы.

Вот как разделяются данные numbersDfR на моей машине:

Метод repartition создает новые разделы и равномерно распределяет данные в новых разделах (распределение данных более равномерное для больших наборов данных).

Разница между coalesce и repartition

coalesce использует существующие разделы, чтобы свести к минимуму объем перетасованных данных. repartition создает новые разделы и делает полную перетасовку. coalesce приводит к разделам с различные объемы данных (иногда разделы, которые имеют очень разные размеры) и repartition приводят к разделам примерно одинакового размера.

Это coalesce или repartition быстрее?

Один дополнительный момент, который следует отметить здесь, заключается в том, что в качестве основного принципа Spark RDD является неизменность. Перераспределение или слияние создаст новый RDD. Базовый RDD будет продолжать существовать со своим исходным числом разделов. В случае, если вариант использования требует сохранения RDD в кэше, то то же самое должно быть сделано для вновь созданного RDD.

Все ответы добавляют некоторые большие знания в этот очень часто задаваемый вопрос.

Итак, следуя традиции временной шкалы этого вопроса, вот мои 2 цента.

В моем приложении, когда количество файлов, которое мы оцениваем, меньше определенного порога, перераспределение работает быстрее.

Вот что я имею в виду

В приведенном выше фрагменте, если мои файлы были меньше чем 20, слияние занимало вечность, чтобы закончить, в то время как перераспределение было намного быстрее, и поэтому приведенный выше код.

Конечно, это число (20) будет зависеть от количества работников и объема данных. Надеюсь, это поможет.

Оба прекрасно работают

Но мы обычно идем к этим двум вещам, когда нам нужно увидеть выходные данные в одном кластере, мы идем с этим.

Но также вы должны убедиться, что данные, которые поступают в узлы слияния, должны иметь высокую конфигурацию, если вы имеете дело с огромными данными. Поскольку все данные будут загружены на эти узлы, может возникнуть исключение памяти. Хотя возмещение ущерба стоит дорого, я предпочитаю его использовать. Так как он перемешивает и распределяет данные поровну.

Будьте мудры, чтобы выбрать между слиянием и переделом.

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

Coalesce-рекомендуется использовать coalesce при уменьшении количества перегородок. Например, если у вас есть 3 раздела и вы хотите уменьшить его до 2 разделов, Coalesce переместит данные 3-го раздела В разделы 1 и 2. Разделы 1 и 2 останутся в одном контейнере.но перераспределение будет перемешивать данные во всех разделах, так что использование сети между исполнитель будет высоким, и это влияет на производительность.

Производительность мудрая коалесцирует производительность лучше, чем перераспределение, уменьшая количество разделов.

Источник

Согласно Learning Spark

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

Если разделы распределены между несколькими машинами и запущен процесс coalesce(), как он может избежать перемещения данных?

ОТВЕТЫ

Ответ 1

Это позволяет избежать полной перетасовки. Если известно, что число уменьшается, то исполнитель может безопасно хранить данные на минимальном количестве разделов, только перемещая данные с лишних узлов на узлы, которые мы сохранили.

Итак, это будет выглядеть примерно так:

Затем coalesce до двух разделов:

Обратите внимание, что Node 1 и Node 3 не требовали перемещения исходных данных.

Ответ 2

Ответ Джастина является удивительным, и этот ответ становится более глубоким.

Алгоритм repartition выполняет полную перетасовку и создает новые разделы с данными, которые распределяются равномерно. Позвольте создать DataFrame с номерами от 1 до 12.

numbersDf содержит 4 раздела на моей машине.

Вот как данные разделяются на разделы:

Позвольте выполнить полный переход с помощью метода repartition и получить эти данные на двух узлах.

Вот как данные numbersDfR разбиваются на мою машину:

Метод repartition создает новые разделы и равномерно распределяет данные в новых разделах (распределение данных более равномерно для больших наборов данных).

Разница между coalesce и repartition

coalesce использует существующие разделы, чтобы минимизировать количество перетасованных данных. repartition создает новые разделы и выполняет полную перетасовку. coalesce приводит к разделам с разным объемом данных (иногда разделов с разными размерами) и repartition приводит к примерно равным размерам разделов.

Является ли coalesce или repartition быстрее?

Прочитайте этот пост в блоге, если вы хотите получить более подробную информацию.

Ответ 3

Еще один момент, который следует отметить здесь, состоит в том, что, поскольку основным принципом Spark RDD является неизменяемость. Перераспределение или совместное создание нового RDD. Базовый RDD будет продолжать существовать с его первоначальным количеством разделов. В случае использования прецедента для сохранения RDD в кеше, то это же должно быть сделано для вновь созданного RDD.

Ответ 4

Все ответы добавляют некоторые большие знания в этот очень часто задаваемый вопрос.

Итак, по традиции этого вопроса, вот мои 2 цента.

Я обнаружил, что перераспределение быстрее, чем слияние, в очень конкретном случае.

В моем приложении, когда количество файлов, которые мы оцениваем, ниже определенного порога, перераспределение работает быстрее.

Вот что я имею в виду

В вышеприведенном фрагменте, если мои файлы были меньше 20, coalesce продолжал заканчиваться, а перераспределение было намного быстрее, и поэтому приведенный выше код.

Конечно, это число (20) будет зависеть от количества рабочих и количества данных.

Надеюсь, что это поможет.

Ответ 5

Ответ 6

Оба отлично работают

Но мы идем в общем за эти две вещи, когда нам нужно видеть вывод в одном кластере, идем с этим.

Ответ 7

Ко всем отличным ответам я хотел бы добавить, что повторное разбиение является одним из лучших вариантов использования распараллеливания данных, а объединение дает дешевый вариант сокращения раздела и очень полезно при записи данных в HDFS или какой-либо другой приемник, чтобы воспользоваться преимуществами большой пишет. Я нашел это полезным при записи данных в формате паркета, чтобы получить полное преимущество.

Ответ 8

«coalesce» будет работать с существующими разделами и перетасовывать их подмножество. Он не может исправить перекос данных так же, как «перераспределение». так что даже если это дешевле, это может быть не то, что вам нужно.

Ответ 9

Таким образом, coalesce и repartition могут быть использованы для увеличения числа разделов

С shuffle = true вы можете объединить большее количество разделов. Это полезно, если у вас есть небольшое количество разделов, скажем, 100, потенциально с несколькими разделами, которые являются необычно большими.

Еще одно важное замечание, которое необходимо подчеркнуть, заключается в том, что если вы резко уменьшите количество разделов, вам следует рассмотреть возможность использования смешанной версии coalesce (то же самое, что и repartition в этом случае). Это позволит выполнять ваши вычисления параллельно на родительских разделах (несколько задач).

Однако, если вы делаете резкое объединение, например, с numPartitions = 1, это может привести к тому, что ваши вычисления будут выполняться на меньшем количестве узлов, чем вам нравится (например, один узел в случае numPartitions = 1). Чтобы избежать этого, вы можете передать shuffle = true. Это добавит случайный шаг, но означает, что текущие разделы восходящего потока будут выполняться параллельно (независимо от текущего разделения).

Пожалуйста, также обратитесь к соответствующему ответу здесь

Ответ 10

Но также вы должны убедиться, что данные, которые поступают на объединенные узлы, должны быть хорошо сконфигурированы, если вы имеете дело с огромными данными. Поскольку все данные будут загружены в эти узлы, может возникнуть исключение памяти. Хотя возмещение затратно, я предпочитаю им пользоваться. Так как он перемешивает и распределяет данные одинаково.

Будь мудрым, чтобы выбрать между объединением и переделом.

Ответ 11

Для кого-то, у кого были проблемы с генерацией одного CSV файла из PySpark (AWS EMR) в качестве вывода и сохранением его на s3, помогло перераспределение. Причина в том, что объединение не может сделать полную перестановку, но перераспределение может. По сути, вы можете увеличить или уменьшить количество разделов, используя перераспределение, но можете только уменьшить количество разделов (но не 1), используя объединение. Вот код для тех, кто пытается записать CSV из AWS EMR в s3:

Ответ 12

Например. наш начальный фрейм данных разделен на 200 разделов.

df.repartition(500): данные будут перетасовываться с 200 разделов на новые 500 разделов

Объединить: перемешать данные в число разделов

Источник

Русские Блоги

Операторы Spark Coalesce и Repartition управляют разделами

Метод повторного разбиения заключается в вызове метода coalesce, и перемешивание истинно
Таким образом, по умолчанию coalesce не генерирует перемешивание.

Введение в раздел

Если в конфигурационном файле spark-default.conf нет конфигурации, значение выбирается в соответствии со следующими правилами:
1. Локальный режим (исполнитель не будет запущен, процесс SparkSubmit будет генерировать указанное количество потоков для одновременной работы):

3. Другие режимы (здесь в основном относится к режиму пряжи, конечно, автономный тоже)

Метод coalesce уменьшает количество разделов в DataFrame. Вот как объединить данные в двух разделах:

Мы можем проверить, создал ли coalesce новый DataFrame только с одним разделом:

Используйте coalesce для увеличения раздела, но это не действует:

Метод repartition можно использовать для увеличения или уменьшения количества разделов в DataFrame.
Увеличить или уменьшить раздел

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

Разница между слиянием и переделом

При повторном разделении данные полностью переупорядочиваются и создаются разделы данных одинакового размера. coalesce объединяет существующие разделы, чтобы избежать полного перемешивания.

Переразбивка по столбцу

При разбиении по столбцам Spark по умолчанию создает не менее 200 разделов. Просмотрите данные раздела, только два раздела содержат данные, и поле цвета данных в одном разделе согласовано. colorDf содержит разные разделы каждого цвета и оптимизирован для извлечения цветов. Разделение по столбцам аналогично индексированию столбцов в реляционной базе данных.

Рассмотрим раздел

1) N M и N похоже на M (если N равно 1000, а M равно 100), то несколько из N разделов могут быть объединены в новый раздел и, наконец, объединены в разделы M. Это Вы можете установить для shuff значение false, когда shuffl имеет значение false, и если M> N, coalesce недопустимо, процесс перемешивания не выполняется, и существует узкая зависимость между родительским RDD и дочерним RDD.

3) Если N> M и есть большая разница между ними, если в это время для shuffle установлено значение false, RDD родитель-потомок является узкой зависимостью, и они находятся на одной стадии, что может вызвать недостаточный параллелизм программы Spark, тем самым влияя на производительность. Если M равно 1, чтобы предыдущие операции coalesce имели лучший параллелизм, вы можете установить для shuffle значение true.

Вкратце: если shuff имеет значение false, если переданный параметр больше, чем количество существующих разделов, количество разделов RDD остается неизменным, то есть количество разделов RDDde не может быть увеличено без перемешивания.

Источник

Русские Блоги

Spark: метод coalesce () и метод repartition ()

1. Метод coalesce ()

Возврат нового RDD, упрощенного для разделов numPartitions. Это создаст узкую зависимость. Например: если вы преобразуете 1000 разделов в 100 разделов, в этом процессе не будет происходить перемешивание. Напротив, если 10 разделов будут преобразованы в 100 разделов, произойдет перемешивание. Если вы хотите уменьшить количество разделов, рассмотрите возможность объединения, чтобы избежать случайного перемешивания.

2. Метод repartition ()

Возвращает СДР с точно разделами numPartitions, что может увеличить или уменьшить параллелизм этого СДР. Внутренне используйте shuffle для перераспределения данных.

Предполагая, что RDD имеет N разделов, его необходимо разделить на M разделов:

(1) N M и N и M похожи (если N равно 1000, M равно 100): тогда вы можете объединить несколько из N разделов в новый раздел и, наконец, объединить в M разделов, Это узкая зависимость до и после, вы можете использовать coalesce (shuffle = false).

(3) Если N> M и разница между ними совершенно различна: если в это время для shuffle установлено значение false, родительский и дочерний RDD находятся в узкой зависимости и находятся на одной и той же стадии, что может привести к недостаточному параллелизму программы Spark, что влияет на производительность. Если M равно 1, чтобы операции перед объединением имели лучший параллелизм, вы можете установить для shuffle значение true.

Если входящий параметр больше, чем количество существующих разделов, а случайное использование равно false, количество разделов СДР остается неизменным, что означает, что количество разделов СДР не может быть увеличено без прохождения через случайное перемешивание.

3. Проблема слияния небольших разделов

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

Чтобы решить эту проблему, функция перераспределения (функция объединения или функция перераспределения) в RDD часто используется для выполнения сжатия данных, уменьшения количества разделов и объединения небольших разделов в большие, тем самым повышая эффективность.

О широкой зависимости (случайное перемешивание) и узкой зависимости (случайное перемешивание не происходит)

4. Разница между переделом и разделом

И repartition, и partitionBy используются для перераспределения данных. По умолчанию используется HashPartitioner. Разница в том, что partitionBy можно использовать только для PairRdd, но когда они оба используются для PairRdd, результаты отличаются:

Глядя на исходный код, partitionBy использует заданный ключ для выполнения HashPartitionner, а перераспределение использует случайно сгенерированное число в качестве ключа вместо использования исходного ключа.

Примечание. Для («a», 1), («a», 2), («b», 1), («b», 3), («c», 1), («e», 5) Для раздела значения ASCII-кода a (65), b, c и e используются, чтобы взять остаток от 4, остаток от a и e равен 1, остаток от b равен 2, остаток равен 3, а раздел 0 не имеет данных.

so，Choosing the right number of partitions is important …

Источник