По данным СПАРК обучения
имейте в виду, что перераспределение ваших данных является достаточно дорогостоящей операцией. Искра также есть оптимизированная версия передел() называется сливаются (), что позволяет избежать перемещения данных, но только если вы уменьшаете количество РДД перегородок.
Одно отличие я понимаю, что с передел() количество секций может быть увеличено/уменьшено, но с коалесцируют() количество секций может быть только уменьшено.
Если разделы распределены по нескольким компьютерам и коалесцируют() запускается, можно как то избежать перемещения данных?
Он избегает полный перемешать. Если это'ы известно, что количество уменьшается, то исполнитель может безопасно хранить данные на минимальное количество разделов, только перемещение данных от дополнительных узлах, на узлы, которые мы сохранили.
Таким образом, это будет что-то вроде этого:
Node 1 = 1,2,3
Node 2 = 4,5,6
Node 3 = 7,8,9
Node 4 = 10,11,12
Затем сливаются
вниз на 2 раздела:
Node 1 = 1,2,3 + (10,11,12)
Node 3 = 7,8,9 + (4,5,6)
Обратите внимание, что узел 1 и узел 3 не требуют исходных данных для перемещения.
Джастин'ы ответ и этот ответ переходит в более подробно.
В передел
алгоритм выполняет полный перемешать и создает новые разделы с данными, что'ы распределяется равномерно. Позвольте's создание таблицы данных с цифрами от 1 до 12.
val x = (1 to 12).toList
val numbersDf = x.toDF("number")
numbersDf
содержит 4 раздела на моей машине.
numbersDf.rdd.partitions.size // => 4
Вот как данные разделены на разделы:
Partition 00000: 1, 2, 3
Partition 00001: 4, 5, 6
Partition 00002: 7, 8, 9
Partition 00003: 10, 11, 12
Позвольте's сделаю полный перемешать с метод передел
и получить эти данные на два узла.
val numbersDfR = numbersDf.repartition(2)
Вот как numbersDfR
данные разделяются на моей машине:
Partition A: 1, 3, 4, 6, 7, 9, 10, 12
Partition B: 2, 5, 8, 11
В передел
метод делает новые разделы и равномерно распределяет данные в новые разделы (распределение данных, даже для больших наборов данных).
Разница между сливаются
и передел
сливаются
использует существующие разделы, чтобы минимизировать объем данных, что'ы перемешиваются. передел
создает новые разделы и выполняет полный перемешать. сливаются
результаты в группах с различными объемами данных (иногда разделы, которые имеют много разных размеров) и передел
результаты примерно равные по размеру части.
Это сливаются
или передел
быстрее?
сливаются
может работать быстрее, чем передел
, но неравные по размеру части, как правило, медленнее работать, чем равные по размеру части. Вы'Лл обычно нужно переразметить данных после фильтрации больших наборов данных. Я'ве нашли передел
, чтобы быть быстрее в целом, потому что Искра построена на равные по размеру части.
Читать эту post блог если вы'd, как еще более детально.
Еще один важный момент, чтобы отметить здесь заключается в том, что основной принцип Искра РДД-это непреложность. Передел или сливаются создаст новые РДД. Базы РДД будет продолжать существование с его первоначальным количеством секций. В случае использования требует для сохранения РДД в кэш, то же самое должно быть сделано для вновь созданных РДД.
scala> pairMrkt.repartition(10)
res16: org.apache.spark.rdd.RDD[(String, Array[String])] =MapPartitionsRDD[11] at repartition at <console>:26
scala> res16.partitions.length
res17: Int = 10
scala> pairMrkt.partitions.length
res20: Int = 2
Все ответы добавив несколько большие знания в этом очень часто задаваемый вопрос.
Так происходит по традиции этот вопрос'ы график, вот мои 2 цента.
Я нашел передел будет быстрее срастаться, в очень конкретном случае.
В моем приложении, когда количество файлов, которые мы оцениваем ниже, чем определенный порог, передел работает быстрее.
Вот что я имею в виду
if(numFiles > 20)
df.coalesce(numFiles).write.mode(SaveMode.Overwrite).parquet(dest)
else
df.repartition(numFiles).write.mode(SaveMode.Overwrite).parquet(dest)
В вышеприведенном фрагменте кода, если мои файлы были меньше, чем 20, сливаются принимает навсегда, чтобы завершить в то время как передел был намного быстрее, и поэтому приведенный выше код.
Конечно, эта цифра (20) будет зависеть от количества работников и объема данных.
Надеюсь, что помогает.
передел
- его рекомендуется использовать передел в то время как увеличение нет перегородок, потому что он предполагает шарканье все данные.
сливаются
- это рекомендуется использовать коалесцируют при сокращении нет перегородок. Например, если у вас есть 3 разделов, и вы хотите снизить его до 2 разделов, сливаться будет двигаться 3-й раздел данных для разделов 1 и 2. Раздел 1 и 2 остается в одном контейнере.но передел будет передавать данные во всех разделах, так что использование сети между исполнителем будет высокой, и это сказывается на производительности.
Производительность мудрый сливаются
лучше, чем передел
при сокращении нет перегородок.
Как следует из код и код Docs является то, что сливаются(н)
так же, как сливаются(Н перетасовать = ложь) и передел(н)так же, как сливаются(Н перетасовать правда=)
Таким образом, обе сливаются
и передел
может быть использован для увеличения количества разделов
С шафл = True, можно на самом деле сливаются в большем количестве разделов. Это полезно, если у вас есть небольшое количество разделов, скажем 100, потенциально с несколькими разделами аномально большие.
Еще одно важное примечание, чтобы подчеркнуть, что если Вы резко уменьшить число секций, вы должны рассмотреть возможность использования тасуется версия сливаются
(как передел
в таком случае). Это позволит вашим расчетам быть выполнены параллельно на родительских разделов (несколько задач).
однако, если вы're делая резкий сливаются, например, в numPartitions = 1, это может привести к ваши вычисления происходят на меньшее количество узлов, чем вам нравится (например, один узел и в случае numPartitions = 1). Чтобы избежать этого, вы можете пройти перетасовать = правда. Это позволит добавить шаркающий шаг, но средства текущие разделы выше по течению будет выполняться параллельно (на любой ток секционирования).
Пожалуйста, Также см. соответствующий ответ здесь
Все ответы, которые я хотел бы добавить, что передел-это один лучший вариант, чтобы воспользоваться преимуществами данных, распараллеливание и сливаются дает дешевый вариант, чтобы уменьшить раздел и очень полезен при записи данных в HDFS или некоторые другие раковины, чтобы воспользоваться большой пишет. Я нашел это полезно при записи данных в формате паркетный получить полное преимущество.
Я хотел бы добавить к Джастину и мощность'ы ответить -
и"передел " и; будет игнорировать существующие разделы и создать новые. Поэтому вы можете использовать его, чтобы исправить данные перекоса. Вы можете отметить ключи раздел, чтобы определить распределение. Перекос данных является одной из самых больших проблем в 'больших данных' проблемное пространство.
и"сливаются " и; будет работать как с существующими разделами и тасовать их подмножество. Это может'т исправить данные перекоса столько, как "передел" могут. так что даже если это дешевле, это Майн'т быть то, что вам нужно.
Для кого-то, кто имел проблемы генерации CSV-файл от PySpark (АРМ ПТО) в качестве выходного сигнала и сохранения его на S3, используя передел помогли. Причина в том, коалесцируют не сделать полную перемешать, но передел может. По сути, вы можете увеличить или уменьшить количество секций с помощью передел, но сможет только уменьшить количество секций (но не 1), используя сливаются. Вот код для тех, кто пытается писать в CSV из AWS ЭМИ на S3:
ДФ.передел(1).написать.формат('КШМ')\ .вариант("по пути" и "Ну С3А://мой.ведро.название/расположение", у)\ .сохранить(заголовок = 'правда')
Но также вы должны убедиться, что данные, которые приходят сливаются узлы должны были сильно настроены, если вы имеете дело с огромными данными. Так как все данные будут загружены в эти узлы, может привести к исключению нехватки памяти. Хотя репарации дорого, я предпочитаю использовать его. Так как он тасует и распределения данных.
Быть мудрым, чтобы выбрать между коалесцируют и передел.
В простой способ КОАЛЕСЦИРУЙТЕ :- только уменьшается без перегородок , без перетасовки данных это просто сжимать разделы
Передел:- для увеличения и уменьшения нет перегородок , но перетасовки происходит
Например:-
val rdd = sc.textFile("path",7)
rdd.repartition(10)
rdd.repartition(2)
Как работает
Но мы ходим в основном для этого две вещи, когда мы должны увидеть выход в один кластер,мы идем с этим.
Передел:- перемешивание данных в <у>новый</п> количество секций
Например. наш первоначальный фрейм данных разделен на секции 200.
ДФ.передел(500) : данные будут перетасованы от 200 секций в Новая 500 секций
Коалесцируйте: перемешать данные в Количество секций
ДФ.коалесцируют(5): данные будут перемешаны из оставшихся 15 секций