Différence entre DataFrame, Dataset et RDD dans Spark
Je me demande simplement quelle est la différence entre RDD et DataFrame (Spark 2.0.0 DataFrame est un simple alias de type pour Dataset[Row]) dans Apache Spark?
Pouvez-vous convertir l'un à l'autre?
Une DataFrame est bien définie avec une recherche Google pour "définition de DataFrame":
Un cadre de données est une table, ou une structure de type tableau à deux dimensions, en lequel chaque colonne contient des mesures sur une variable et chaque ligne contient un cas.
Ainsi, une DataFrame contient des métadonnées supplémentaires en raison de son format tabulaire, ce qui permet à Spark d'exécuter certaines optimisations sur la requête finalisée.
Un RDD, par contre, est simplement unResilientDistributedDataset qui est davantage une boîte noire de données qui ne peuvent pas être optimisées cela peut être effectué contre elle, ne sont pas aussi contraint.
Cependant, vous pouvez passer d'un DataFrame à un RDD via sa méthode rdd et vous pouvez passer d'un RDD à un DataFrame (si le RDD est au format tabulaire) via la méthode toDF
En général il est recommandé d'utiliser une DataFrame si possible en raison de l'optimisation de la requête intégrée.
Tout (RDD, DataFrame et DataSet) dans une image
RDD
RDDest une collection d'éléments tolérants aux pannes pouvant être utilisés en parallèle.
Trame de données
DataFrameest un jeu de données organisé en colonnes nommées. Il est conceptuellement équivalent à une table dans une base de données relationnelle ou à une donnée frame en R/Python, mais avec des optimisations plus riches sous le capot.
Ensemble de données
Datasetest une collection distribuée de données. Dataset est une nouvelle interface ajoutée dans Spark 1.6 qui fournit les avantages des RDD (typage fort, capacité à utiliser de puissantes fonctions lambda) avec le avantages du moteur d’exécution optimisé de Spark SQL.Remarque:
Jeu de données de lignes (
Dataset[Row]) dans Scala/Java désignera souvent comme DataFrames.
Belle comparaison de tous avec un extrait de code
Q: Pouvez-vous convertir l’un en l’autre comme RDD to DataFrame ou inversement?
Oui, les deux sont possibles
1. RDD à DataFrame avec .toDF()
val rowsRdd: RDD[Row] = sc.parallelize(
Seq(
Row("first", 2.0, 7.0),
Row("second", 3.5, 2.5),
Row("third", 7.0, 5.9)
)
)
val df = spark.createDataFrame(rowsRdd).toDF("id", "val1", "val2")
df.show()
+------+----+----+
| id|val1|val2|
+------+----+----+
| first| 2.0| 7.0|
|second| 3.5| 2.5|
| third| 7.0| 5.9|
+------+----+----+
plusieurs façons: Convertir un objet RDD en Dataframe dans Spark
2. DataFrame/DataSet à RDD avec la méthode .rdd()
val rowsRdd: RDD[Row] = df.rdd() // DataFrame to RDD
Tout simplement RDD est le composant principal, mais DataFrame est une API introduite dans spark 1.30.
RDD
Collection de partitions de données appelée RDD. Ces RDD doivent suivre quelques propriétés telles que:
- Immuable,
- Tolérance de panne,
- Distribué,
- Plus.
Ici, RDD est structuré ou non structuré.
Trame de données
DataFrame est une API disponible en Scala, Java, Python et R. Elle permet de traiter tout type de données structurées et semi-structurées. Pour définir DataFrame, un ensemble de données distribuées organisées en colonnes nommées appelées DataFrame. Vous pouvez facilement optimiser RDDs dans DataFrame. Vous pouvez traiter des données JSON, des données de parquet, des données HiveQL à la fois en utilisant DataFrame.
val sampleRDD = sqlContext.jsonFile("hdfs://localhost:9000/jsondata.json")
val sample_DF = sampleRDD.toDF()
Ici Sample_DF considère comme DataFrame. sampleRDD est (données brutes) appelé RDD.
Parce que DataFrame est faiblement typé et que les développeurs ne bénéficient pas des avantages du système de types. Par exemple, disons que vous voulez lire quelque chose à partir de SQL et exécuter une agrégation dessus:
val people = sqlContext.read.parquet("...")
val department = sqlContext.read.parquet("...")
people.filter("age > 30")
.join(department, people("deptId") === department("id"))
.groupBy(department("name"), "gender")
.agg(avg(people("salary")), max(people("age")))
Lorsque vous dites people("deptId"), vous ne récupérez pas une Int, ou une Long, vous récupérez un objet Column sur lequel vous devez opérer. Dans les langues avec des systèmes de types riches tels que Scala, vous finissez par perdre toute la sécurité de type, ce qui augmente le nombre d'erreurs d'exécution des choses pouvant être découvertes lors de la compilation.
Au contraire, DataSet[T] est saisi. quand tu fais:
val people: People = val people = sqlContext.read.parquet("...").as[People]
Vous récupérez en fait un objet People, où deptId est un type entier réel et non un type de colonne, tirant ainsi parti du système de types.
À partir de Spark 2.0, les API DataFrame et DataSet seront unifiées, où DataFrame sera un alias de type pour DataSet[Row].
Un DataFrame est équivalent à une table dans un SGBDR et peut également être manipulé de la même façon que les collections distribuées "natives" dans les RDD. Contrairement aux RDD, les cadres de données suivent le schéma et prennent en charge diverses opérations relationnelles conduisant à une exécution plus optimisée . Chaque objet DataFrame représente un plan logique, mais en raison de sa nature "paresseuse", aucune exécution n’a lieu tant que l’utilisateur n’appelle pas une "sortie spécifique". opération".
La plupart des réponses sont correctes, je veux seulement ajouter un point ici
Dans Spark 2.0, les deux API (DataFrame + DataSet) seront unifiées ensemble en une seule API.
"Unification DataFrame et Dataset: Dans Scala et Java, DataFrame et Dataset ont été unifiés. DataFrame est simplement un alias de type pour Dataset of Row. En Python et R, étant donné le manque de sécurité de type, DataFrame est l'interface principale de programmation."
Les ensembles de données sont similaires aux RDD. Cependant, au lieu d'utiliser la sérialisation Java ou Kryo, ils utilisent un encodeur spécialisé pour sérialiser les objets en vue de leur traitement ou de leur transmission sur le réseau.
Spark SQL prend en charge deux méthodes différentes pour convertir les RDD existants en jeux de données. La première méthode utilise la réflexion pour déduire le schéma d'un RDD contenant des types d'objets spécifiques. Cette approche basée sur la réflexion conduit à un code plus concis et fonctionne bien lorsque vous connaissez déjà le schéma lors de l'écriture de votre application Spark.
La deuxième méthode de création de jeux de données consiste à utiliser une interface de programmation qui vous permet de construire un schéma, puis de l'appliquer à un RDD existant. Bien que cette méthode soit plus détaillée, elle vous permet de construire des ensembles de données lorsque les colonnes et leurs types ne sont pas connus avant l'exécution.
Ici vous pouvez trouver la réponse de conversation de trame de données RDD tof Data
Une Dataframe est un RDD d'objets Row, chacun représentant un enregistrement. A Dataframe connaît également le schéma (c'est-à-dire les champs de données) de ses lignes. Alors que Dataframes .__ ressemblent à des RDD classiques, ils stockent les données de manière plus efficace en interne, en tirant parti de leur schéma. En outre, ils fournissent de nouvelles opérations non disponibles sur les RDD, telles que la possibilité d'exécuter des requêtes SQL. Les cadres de données peuvent être créés à partir de sources de données externes, des résultats de requêtes ou de RDD classiques.
Référence: Zaharia M., et al. Learning Spark (O'Reilly, 2015)
Quelques idées du point de vue de l’utilisation, RDD vs DataFrame:
- Les RDD sont incroyables! car ils nous donnent toute la flexibilité nécessaire pour traiter pratiquement n'importe quel type de données; données non structurées, semi-structurées et structurées. Comme, souvent, les données ne sont pas prêtes à être intégrées dans un DataFrame (même au format JSON), les RDD peuvent être utilisés pour effectuer un prétraitement sur les données afin qu'elles puissent s'intégrer dans une image. Les RDD sont une abstraction de base de données dans Spark.
- Toutes les transformations possibles sur RDD ne sont pas possibles sur DataFrames, par exemple, subtract () concerne RDD vs except () concerne DataFrame.
- Comme les DataFrames ressemblent à une table relationnelle, ils appliquent des règles strictes lors de l’utilisation de transformations théorie set/relationnelle. Par exemple, si vous souhaitez unir deux images, l’exigence est que les deux dfs aient le même nombre de colonnes et les types de données de colonne associés. Les noms de colonnes peuvent être différents. Ces règles ne s'appliquent pas aux RDD. Voici un bon tutoriel expliquant ces faits.
- L'utilisation de DataFrames offre des gains de performances, comme d'autres l'ont déjà expliqué en détail.
- En utilisant DataFrames, vous n’avez pas besoin de passer la fonction arbitraire comme vous le faites lorsque vous programmez avec des RDD.
- Vous avez besoin de SQLContext/HiveContext pour programmer les cadres de données car ils se trouvent dans la zone SparkSQL de spark eco-system, mais pour RDD, vous n'avez besoin que de SparkContext/JavaSparkContext, qui se trouvent dans les bibliothèques Spark Core.
- Vous pouvez créer un fichier DF à partir d'un RDD si vous pouvez définir un schéma pour celui-ci.
- Vous pouvez également convertir un df en rdd et un rdd en df.
J'espère que ça aide!
Vous pouvez utiliser les RDD avec Structured et non-structuré alors que Dataframe/Dataset peut uniquement traiter des données structurées et semi-structurées
Spark RDD (resilient distributed dataset):
RDD est l'API d'abstraction de données principale et est disponible depuis la toute première version de Spark (Spark 1.0). Il s'agit d'une API de niveau inférieur permettant de manipuler une collection de données distribuée. Les API RDD présentent des méthodes extrêmement utiles qui peuvent être utilisées pour obtenir un contrôle très étroit de la structure de données physique sous-jacente. Il s'agit d'une collection immuable (en lecture seule) de données partitionnées réparties sur différentes machines. RDD permet le calcul en mémoire sur de grands groupes pour accélérer le traitement de données volumineuses de manière tolérante aux pannes. Pour activer la tolérance de panne, RDD utilise DAG (Directed Acyclic Graph), constitué d’un ensemble de sommets et d’arêtes. Les sommets et les arêtes dans le DAG représentent le RDD et l'opération à appliquer à ce RDD, respectivement. Les transformations définies sur RDD sont paresseuses et s’exécutent uniquement lorsqu’une action est appelée.
Spark DataFrame:
Spark 1.3 a introduit deux nouvelles API d’abstraction de données - DataFrame et DataSet. Les API DataFrame organisent les données dans des colonnes nommées, comme une table dans une base de données relationnelle. Il permet aux programmeurs de définir un schéma sur une collection de données distribuée. Chaque ligne d'un DataFrame est une ligne de type objet. Comme une table SQL, chaque colonne doit avoir le même nombre de lignes dans un DataFrame. En bref, DataFrame est un plan évalué paresseusement qui spécifie les opérations à effectuer sur la collecte distribuée des données. DataFrame est également une collection immuable.
Spark DataSet:
En tant qu'extension des API DataFrame, Spark 1.3 a également introduit les API DataSet, qui fournissent une interface de programmation strictement typée et orientée objet dans Spark. Il s’agit d’une collecte de données distribuées immuable et sans danger pour le type. Comme DataFrame, les API DataSet utilisent également le moteur Catalyst afin de permettre l'optimisation de l'exécution. DataSet est une extension des API DataFrame.
Other Differences -
Toutes les bonnes réponses et l’utilisation de chaque API a des inconvénients . Le jeu de données est conçu pour être une super API, mais de nombreuses fois, RDD fonctionne toujours mieux si vous comprenez vos données et si l’algorithme de traitement est optimisé. en un seul passage vers des données volumineuses, RDD semble être la meilleure option.
L'agrégation à l'aide de l'API de jeu de données consomme toujours de la mémoire et s'améliorera avec le temps.
Un DataFrame est un RDD qui a un schéma. Vous pouvez le considérer comme une table de base de données relationnelle, chaque colonne ayant un nom et un type connu. La puissance de DataFrames provient du fait que, lorsque vous créez un DataFrame à partir d’un jeu de données structuré (Json, Parquet ..), Spark peut déduire un schéma en effectuant un passage sur l’ensemble (Json, Parquet. .) ensemble de données en cours de chargement. Ensuite, lors du calcul du plan d'exécution, Spark peut utiliser le schéma et optimiser considérablement les calculs. Notez que DataFrame était appelé SchemaRDD avant Spark v1.3.0