spark coalesce что это
Русские Блоги
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 …
Каково главное преимущество использования Coalesce в Spark, кроме сокращения разделов [duplicate]
Причина, по которой это происходит, является тонкой.
Вот почему ваше решение, которое вы отправили в качестве ответа, работает правильно.
, поэтому, если вы напишете инструкцию как это, она будет работать без исключения:
5 ответов
Это позволяет избежать полной перетасовки. Если известно, что число уменьшается, то исполнитель может безопасно хранить данные на минимальном количестве разделов, только перемещая данные с лишних узлов на узлы, которые мы сохранили.
Итак, он будет выглядеть примерно так:
Затем coalesce до двух разделов:
Обратите внимание, что узлы 1 и Узел 3 не требовал перемещения исходных данных.
Оба работают отлично
Все ответы добавляются в этот очень часто задаваемый вопрос.
Так что, следуя традиции временного графика этого вопроса, вот мои 2 цента.
Я нашел перераспределение быстрее, чем слияние, в очень конкретном случае.
В моем приложении, когда количество файлов, которые мы оцениваем, ниже определенного порога, перераспределение работает быстрее.
Вот что я имею в виду
Конечно, это число (20) будет зависеть от числа рабочих и количества данных.
Надеюсь, что это поможет.
Ответ Джастина является удивительным, и этот ответ углубляется.
Алгоритм repartition выполняет полную перетасовку и создает новые разделы с распределенными данными. Давайте создадим DataFrame с номерами от 1 до 12.
numbersDf содержит 4 раздела на моей машине.
Вот как данные делятся на разделы:
Давайте сделаем полное перетасовку с помощью метода repartition и получим эти данные на двух узлах.
Вот как numbersDfR данные разделены на моей машине:
Метод repartition создает новые разделы и равномерно распределяет данные в новых разделах (распределение данных более равномерно для больших наборов данных).
. Разница между coalesce и repartition
coalesce использует существующие разделы, чтобы свести к минимуму количество перетасованных данных. repartition создает новые разделы и выполняет полную перетасовку. coalesce приводит к разделам с разным количеством данных (иногда разделов с разными размерами) и repartition приводит к примерно равным размерам разделов.
Согласно 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 разделов
Объединить: перемешать данные в число разделов
According to Learning Spark
Keep in mind that repartitioning your data is a fairly expensive operation. Spark also has an optimized version of repartition() called coalesce() that allows avoiding data movement, but only if you are decreasing the number of RDD partitions.
One difference I get is that with repartition() the number of partitions can be increased/decreased, but with coalesce() the number of partitions can only be decreased.
If the partitions are spread across multiple machines and coalesce() is run, how can it avoid data movement?
18 Answers 18
It avoids a full shuffle. If it’s known that the number is decreasing then the executor can safely keep data on the minimum number of partitions, only moving the data off the extra nodes, onto the nodes that we kept.
So, it would go something like this:
Then coalesce down to 2 partitions:
Notice that Node 1 and Node 3 did not require its original data to move.
Justin’s answer is awesome and this response goes into more depth.
The repartition algorithm does a full shuffle and creates new partitions with data that’s distributed evenly. Let’s create a DataFrame with the numbers from 1 to 12.
numbersDf contains 4 partitions on my machine.
Here is how the data is divided on the partitions:
Let’s do a full-shuffle with the repartition method and get this data on two nodes.
Here is how the numbersDfR data is partitioned on my machine:
The repartition method makes new partitions and evenly distributes the data in the new partitions (the data distribution is more even for larger data sets).
Difference between coalesce and repartition
coalesce uses existing partitions to minimize the amount of data that’s shuffled. repartition creates new partitions and does a full shuffle. coalesce results in partitions with different amounts of data (sometimes partitions that have much different sizes) and repartition results in roughly equal sized partitions.
Is coalesce or repartition faster?
N.B. I’ve curiously observed that repartition can increase the size of data on disk. Make sure to run tests when you’re using repartition / coalesce on large datasets.
Read this blog post if you’d like even more details.
When you’ll use coalesce & repartition in practice
по данным обучения Spark
имейте в виду, что перераспределение ваших данных является достаточно дорогостоящей операцией. Spark также имеет оптимизированную версию repartition (), называемую coalesce (), которая позволяет избежать перемещения данных, но только если вы уменьшаете количество разделов RDD.
одно отличие, которое я получаю, заключается в том, что с помощью repartition () количество разделов может быть увеличено/ уменьшено, но с coalesce () количество разделов может быть только уменьшившийся.
Если разделы распределены по нескольким машинам и выполняется coalesce (), как можно избежать перемещения данных?
7 ответов
настоящее полное перемешать. Если известно, что число уменьшается, исполнитель может безопасно хранить данные о минимальном количестве разделов, перемещая данные только с дополнительных узлов на узлы, которые мы сохранили.
Итак, это будет что-то вроде этого:
затем coalesce до 2 разделов:
обратите внимание, что узел 1 и узел 3 не требовали перемещения исходных данных.
ответ Джастина потрясающий, и этот ответ идет более глубоко.
на repartition алгоритм выполняет полную перетасовку и создает новые разделы с равномерно распределенными данными. Давайте создадим фрейм данных с числами от 1 до 12.
numbersDf содержит 4 раздела на моей машине.
вот как данные делятся на разделы:
давайте сделаем полную перетасовку с repartition метод и получите эти данные на двух узлах.
вот как numbersDfR данные разделены на моей машине:
на repartition метод создает новые разделы и равномерно распределяет данные в новых разделах (распределение данных больше даже для больших наборов данных).
разницу между coalesce и repartition
coalesce использует существующие разделы, чтобы минимизировать объем данных, которые тасуются. repartition создает новые разделы и делает полный shuffle. coalesce приводит к разделам с разными объемами данных (иногда разделы, которые имеют разные размеры) и repartition приводит к примерно равным по размеру разделам.
Is coalesce или repartition быстрее?
читать этот блог если вы хотите еще более детально.
еще один момент, который следует отметить здесь, заключается в том, что основным принципом Spark RDD является неизменность. Передел или объединение создаст новый RDD. Базовый RDD будет продолжать существовать с его исходным количеством разделов. В случае, если прецедент требует сохранения RDD в кэше, то то же самое должно быть сделано для вновь созданного RDD.
все ответы добавляют некоторые большие знания в этот очень часто задаваемый вопрос.
Итак, следуя традиции временной шкалы этого вопроса, вот мои 2 цента.
нашел передел будет быстрее срастаться в очень конкретном случае.
в моем приложении, когда количество файлов, которое мы оцениваем, ниже определенного порога, перераспределение работает быстрее.
вот что я имею в виду
в приведенном выше фрагменте, если мои файлы были меньше 20, coalesce принимал навсегда, чтобы закончить, в то время как переделка была намного быстрее, и поэтому приведенный выше код.
конечно, эта цифра (20) будет зависеть от количества работников и объема данных.
надеюсь, что это поможет.
но мы обычно идем на эти две вещи, когда нам нужно увидеть результат в одном кластере, мы идем с этим.
но также вы должны убедиться, что данные, которые приходят объединяются узлы должны быть высоко настроены, если вы имеете дело с огромными данными. Поскольку все данные будут загружены на эти узлы, может привести к исключению памяти. Хотя возмещение и дорого, я предпочитаю его использовать. Так как он перемешивает и распределяет данные поровну.
будьте мудры, чтобы выбрать между объединением и переделом.
repartition-рекомендуется использовать repartition при увеличении без разделов, поскольку это связано с перетасовкой всех данных.
coalesce-рекомендуется использовать coalesce при уменьшении нет разделов. Например, если у вас есть 3 раздела, и вы хотите уменьшить его до 2 разделов, Coalesce переместит данные 3-го раздела В разделы 1 и 2. Разделы 1 и 2 останутся в одном контейнере.но repartition перетасует данные во всех разделах, поэтому использование сети между исполнителем будет высокий, и это влияет на производительность.
производительность мудрая объединяет производительность лучше, чем передел, не уменьшая при этом никаких разделов.