Pyspark: répartition vs partitionBy

Je suis en train de travailler à travers ces deux concepts dès maintenant et voudrais un peu de clarté. De travail par le biais de la ligne de commande, j'ai essayé d'identifier les différences et quand un développeur utilise répartition vs partitionBy.

Voici un exemple de code:

rdd = sc.parallelize([('a', 1), ('a', 2), ('b', 1), ('b', 3), ('c',1), ('ef',5)])
rdd1 = rdd.repartition(4)
rdd2 = rdd.partitionBy(4)

rdd1.glom().collect()
[[('b', 1), ('ef', 5)], [], [], [('a', 1), ('a', 2), ('b', 3), ('c', 1)]]

rdd2.glom().collect()
[[('a', 1), ('a', 2)], [], [('c', 1)], [('b', 1), ('b', 3), ('ef', 5)]]

J'ai pris un coup d'oeil à la mise en œuvre des deux, et la seule différence que j'ai remarqué pour la plupart, est que partitionBy peut prendre une fonction de partitionnement, ou à l'aide de la portable_hash par défaut. Ainsi, dans partitionBy, tous les mêmes clés doivent être dans la même partition. Dans la répartition, je m'attends à ce que les valeurs soient réparties plus uniformément sur les partitions, mais ce n'est pas le cas.

Compte tenu de cela, pourquoi serait-on jamais utiliser de répartition? Je suppose que le seul moment où je pouvais le voir utilisé est si je ne travaille pas avec PairRDD, ou j'ai des données à grande inclinaison?

Il y a une chose que je suis absent, ou quelqu'un pourrait jeter de la lumière à partir d'un angle différent pour moi?

OriginalL'auteur Joe Widen | 2015-11-20

  1. 9

    repartition existe déjà dans Rdd, et ne gère pas le partitionnement par clé (ou par tout autre critère à l'exception de la Commande). Maintenant PairRDDs ajouter la notion de touches et par la suite ajouter une autre méthode qui permet de partition par cette touche.

    Donc oui, si vos données sont saisies, vous devez absolument partition par cette clé, qui dans de nombreux cas, est le point de l'utilisation d'un PairRDD en premier lieu (pour les jointures, reduceByKey, et ainsi de suite).

    Quelle est la raison que la répartition n'est pas de distribuer les éléments uniformément ish dans les partitions? Cela pourrait-il être un cas où je n'ai pas assez de données, et dont nous faisons l'expérience de petite taille de l'échantillon question?
    Bonne question, je suis en voir la même distribution lors de l'essayer (la Scala).
    Rien d'autre qu'une simple probabilité. repartition est fait à l'aide de la paire de RDD en interne par l'ajout de clé aléatoire à valeurs existantes afin de ne pas fournir des garanties solides sur la sortie de la distribution de données. BTW, Vous devriez probablement accepter la réponse.
    En fait tous de repartitionnement dans la Spark est gérée à l'aide de la paire de Rdd. Si nécessaire Étincelle ajoute juste factice des clés ou des valeurs factices pour le faire fonctionner.

    OriginalL'auteur Marius Soutier

  2. 9

    repartition() est utilisé pour spécifier le nombre de partitions de prendre en compte le nombre de cœurs et de la quantité de données que vous avez.

    partitionBy() est utilisé pour la fabrication de brassage des fonctions plus efficaces, comme la reduceByKey(), join(), cogroup() etc.. Il est bénéfique que dans les cas où un RDD est utilisé plusieurs fois, de sorte qu'il est généralement suivi par persist().

    Différences entre les deux en action:

    pairs = sc.parallelize([1, 2, 3, 4, 2, 4, 1, 5, 6, 7, 7, 5, 5, 6, 4]).map(lambda x: (x, x))

pairs.partitionBy(3).glom().collect()
[[(3, 3), (6, 6), (6, 6)],
 [(1, 1), (4, 4), (4, 4), (1, 1), (7, 7), (7, 7), (4, 4)],
 [(2, 2), (2, 2), (5, 5), (5, 5), (5, 5)]]

pairs.repartition(3).glom().collect()
[[(4, 4), (2, 2), (6, 6), (7, 7), (5, 5), (5, 5)],
 [(1, 1), (4, 4), (6, 6), (4, 4)],
 [(2, 2), (3, 3), (1, 1), (5, 5), (7, 7)]]

    OriginalL'auteur Hui Guo