Aller au contenu principal
Dernière mise à jour le

Présentation de SparkR

important

SparkR dans Databricks est déprécié dans Databricks Runtime 16.0 et versions ultérieures. Databricks recommande d'utiliser sparklyr plutôt.

SparkR est un package R qui fournit une interface légère pour utiliser Apache Spark depuis R. SparkR prend également en charge le machine learning distribué à l'aide de MLlib.

Référence de la fonction SparkR​

Vous pouvez trouver la référence de fonction SparkR la plus récente sur spark.apache.org.

Vous pouvez également consulter l'aide des fonctions dans les Notebooks R ou RStudio après avoir importé le package SparkR.

Documentation R intégrée

SparkR dans les Notebook​

  • Pour Spark 2.0 et versions ultérieures, vous n'avez pas besoin de passer explicitement un objet sqlContext à chaque appel de fonction.
  • Pour Spark 2,2 et versions ultérieures, les notebooks n'importent plus SparkR par default, car les fonctions SparkR entraient en conflit avec des fonctions de noms similaires provenant d'autres packages populaires. Pour utiliser SparkR, vous pouvez appeler library(SparkR) dans vos notebooks. La session SparkR est déjà configurée, et toutes les fonctions SparkR communiqueront avec votre cluster attaché en utilisant la session existante.

SparkR dans les Jobs spark-submit​

Vous pouvez exécuter des scripts qui utilisent SparkR sur Databricks en tant que jobs spark-submit, avec des modifications mineures du code.

Créer des DataFrames SparkR​

Vous pouvez créer un DataFrame à partir d'un data.frame R local, d'une source de données ou à l'aide d'une query Spark SQL.

À partir d'un R local data.frame​

La façon la plus simple de créer un DataFrame est de convertir un data.frame R local en un SparkDataFrame. Plus précisément, nous pouvons utiliser createDataFrame et transmettre le R local data.frame pour créer un SparkDataFrame. Comme la plupart des autres fonctions SparkR, la createDataFrame syntaxe a changé dans Spark 2.0. Vous pouvez voir des exemples de ceci dans l'extrait de code ci-dessous. Pour plus d'exemples, consultez createDataFrame.

R
library(SparkR)
df <- createDataFrame(faithful)

# Displays the content of the DataFrame to stdout
head(df)

Utilisation de l'API de source de données​

La méthode générale de création d'un DataFrame à partir d'une source de données est read.df. Cette méthode prend le chemin du fichier à charger et le type de source de données. SparkR prend en charge la lecture des fichiers CSV, JSON, texte et Parquet en mode natif.

R
library(SparkR)
diamondsDF <- read.df("/databricks-datasets/Rdatasets/data-001/csv/ggplot2/diamonds.csv", source = "csv", header="true", inferSchema = "true")
head(diamondsDF)

SparkR déduit automatiquement le schéma du fichier CSV.

Ajout d'un connecteur de source de données avec les packages Spark​

Via les Packages Spark, vous pouvez trouver des connecteurs de sources de données pour les formats de fichier populaires tels qu'Avro. Par exemple, utilisez le package spark-avro pour charger un fichier Avro. La disponibilité du package spark-avro dépend de la version de votre cluster. Consultez Lecture et écriture de fichiers Avro.

Prenez d'abord un data.frame existant, convertissez-le en DataFrame Spark et enregistrez-le en tant que fichier Avro.

R
require(SparkR)
irisDF <- createDataFrame(iris)
write.df(irisDF, source = "com.databricks.spark.avro", path = "dbfs:/tmp/iris.avro", mode = "overwrite")

Pour vérifier qu'un fichier Avro a été enregistré :

R
%fs ls /tmp/iris.avro

Utilisez maintenant le package spark-avro à nouveau pour relire les données.

R
irisDF2 <- read.df(path = "/tmp/iris.avro", source = "com.databricks.spark.avro")
head(irisDF2)

L'API de source de données peut également être utilisée pour enregistrer des DataFrames dans plusieurs formats de fichier. Par exemple, vous pouvez enregistrer le DataFrame de l'exemple précédent dans un fichier Parquet à l'aide de write.df.

R
write.df(irisDF2, path="dbfs:/tmp/iris.parquet", source="parquet", mode="overwrite")
Bash
%fs ls dbfs:/tmp/iris.parquet

À partir d'une query Spark SQL​

Vous pouvez également créer des DataFrames SparkR en utilisant des queries Spark SQL.

R
# Register earlier df as temp view
createOrReplaceTempView(irisDF2, "irisTemp")
R
# Create a df consisting of only the 'species' column using a Spark SQL query
species <- sql("SELECT species FROM irisTemp")

species est un SparkDataFrame.

Opérations de DataFrame​

Les DataFrames Spark prennent en charge un certain nombre de fonctions pour effectuer le traitement de données structurées. Voici quelques exemples de base. Une liste complète se trouve dans la documentation de l'API.

Sélectionner des lignes et des colonnes​

R
# Import SparkR package if this is a new notebook
require(SparkR)

# Create DataFrame
df <- createDataFrame(faithful)
R
# Select only the "eruptions" column
head(select(df, df$eruptions))
R
# You can also pass in column name as strings
head(select(df, "eruptions"))
R
# Filter the DataFrame to only retain rows with wait times shorter than 50 mins
head(filter(df, df$waiting < 50))

Regroupement et agrégation​

Les SparkDataFrames prennent en charge un certain nombre de fonctions couramment utilisées pour agréger les données après le regroupement. Par exemple, vous pouvez compter le nombre de fois où chaque temps d'attente apparaît dans le dataset fidèle.

R
head(count(groupBy(df, df$waiting)))
R
# You can also sort the output from the aggregation to get the most common waiting times
waiting_counts <- count(groupBy(df, df$waiting))
head(arrange(waiting_counts, desc(waiting_counts$count)))

Opérations de colonne​

SparkR fournit certaines fonctions qui peuvent être directement appliquées aux colonnes pour le traitement et l'agrégation des données. L'exemple suivant montre l'utilisation des fonctions arithmétiques de base.

R
# Convert waiting time from hours to seconds.
# You can assign this to a new column in the same DataFrame
df$waiting_secs <- df$waiting * 60
head(df)

Machine Learning​

SparkR expose la plupart des algorithmes de MLlib. En arrière-plan, SparkR utilise MLlib pour entraîner le modèle.

L'exemple suivant montre comment créer un modèle GLM gaussien à l'aide de SparkR. Pour exécuter une régression linéaire, définissez la famille sur "gaussian". Pour exécuter la régression logistique, définissez la famille sur "binomial". Lorsque vous utilisez SparkML GLM SparkR, l'encodage one-hot des fonctionnalités catégoriques est automatiquement effectué afin qu'il ne soit pas nécessaire de le faire manuellement. Au-delà des fonctionnalités de type chaîne et double, il est également possible d'adapter les fonctionnalités de vecteur MLlib, pour la compatibilité avec d'autres composants MLlib.

R
# Create the DataFrame
df <- createDataFrame(iris)

# Fit a linear model over the dataset.
model <- glm(Sepal_Length ~ Sepal_Width + Species, data = df, family = "gaussian")

# Model coefficients are returned in a similar format to R's native glm().
summary(model)

Pour les didacticiels, consultez Didacticiel : analyser les données avec glm.

Pour d'autres exemples, consultez Travailler avec des DataFrames et des tables dans R.

Sur cette page