Vue d’ensemble de SparkRSparkR overview

Sparkr est un package R qui fournit un serveur frontal léger pour utiliser Apache Spark à partir de R. Sparkr prend également en charge les Machine Learning distribuées à l’aide de MLlib.SparkR is an R package that provides a light-weight frontend to use Apache Spark from R. SparkR also supports distributed machine learning using MLlib.

Sparkr dans les NotebooksSparkR in notebooks

  • Pour Spark 2,0 et versions ultérieures, vous n’avez pas besoin de passer explicitement un sqlContext objet à chaque appel de fonction.For Spark 2.0 and above, you do not need to explicitly pass a sqlContext object to every function call. Cet article utilise la nouvelle syntaxe.This article uses the new syntax. Pour les anciens exemples de syntaxe, consultez sparkr 1,6 Overview.For old syntax examples, see SparkR 1.6 overview.
  • Pour Spark 2,2 et versions ultérieures, les blocs-notes n’importent plus Spark par défaut, car les fonctions Spark sont en conflit avec des fonctions portant le même nom dans d’autres packages populaires.For Spark 2.2 and above, notebooks no longer import SparkR by default because SparkR functions were conflicting with similarly named functions from other popular packages. Pour utiliser Sparkr, vous pouvez appeler library(SparkR) dans vos blocs-notes.To use SparkR you can call library(SparkR) in your notebooks. La session Sparkr est déjà configurée, et toutes les fonctions Sparkr communiquent avec votre cluster attaché à l’aide de la session existante.The SparkR session is already configured, and all SparkR functions will talk to your attached cluster using the existing session.

Sparkr dans les travaux d’envoi SparkSparkR in spark-submit jobs

Vous pouvez exécuter des scripts qui utilisent Sparkr sur Azure Databricks en tant que travaux Spark-Submit, avec des modifications de code mineures.You can run scripts that use SparkR on Azure Databricks as spark-submit jobs, with minor code modifications. Pour obtenir un exemple, reportez-vous à la rubrique créer et exécuter une tâche Spark-submit pour les scripts R.For an example, refer to Create and run a spark-submit job for R scripts.

Créer un trames SparkrCreate SparkR DataFrames

Vous pouvez créer un tableau à partir d’un R local data.frame , d’une source de données ou à l’aide d’une requête Spark SQL.You can create a DataFrame from a local R data.frame, from a data source, or using a Spark SQL query.

À partir d’un R local data.frameFrom a local R data.frame

La façon la plus simple de créer un tableau consiste à convertir un R local data.frame en un SparkDataFrame .The simplest way to create a DataFrame is to convert a local R data.frame into a SparkDataFrame. En particulier, nous pouvons utiliser createDataFrame et passer le R local data.frame pour créer un SparkDataFrame .Specifically we can use createDataFrame and pass in the local R data.frame to create a SparkDataFrame. Comme la plupart des autres fonctions Sparkr, la createDataFrame syntaxe a changé dans Spark 2,0.Like most other SparkR functions, createDataFrame syntax changed in Spark 2.0. Vous pouvez voir des exemples de cela dans l’extrait de code souffle.You can see examples of this in the code snippet bellow. Pour plus d’exemples, reportez-vous à createDataFrame .Refer to createDataFrame for more examples.

library(SparkR)
df <- createDataFrame(faithful)

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

Utilisation de l’API de source de donnéesUsing the data source API

La méthode générale pour créer un tableau à partir d’une source de données est read.df .The general method for creating a DataFrame from a data source is read.df. Cette méthode prend le chemin d’accès du fichier à charger et le type de source de données.This method takes the path for the file to load and the type of data source. Sparkr prend en charge la lecture des fichiers CSV, JSON, Text et parquet en mode natif.SparkR supports reading CSV, JSON, text, and Parquet files natively.

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 à partir du fichier CSV.SparkR automatically infers the schema from the CSV file.

Ajout d’un connecteur de source de données avec des packages SparkAdding a data source connector with Spark Packages

Grâce aux packages Spark, vous trouverez des connecteurs de source de données pour des formats de fichiers populaires tels que Avro.Through Spark Packages you can find data source connectors for popular file formats such as Avro. Par exemple, utilisez le package Spark-Avro pour charger un fichier Avro .As an example, use the spark-avro package to load an Avro file. La disponibilité du package Spark-Avro dépend de la version de l' imagede votre cluster.The availability of the spark-avro package depends on your cluster’s image version. Consultez le fichier Avro.See Avro file.

Commencez par effectuer une data.frame conversion existante en tableau Spark, puis enregistrez-la en tant que fichier Avro.First take an existing data.frame, convert to a Spark DataFrame, and save it as an Avro file.

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é :To verify that an Avro file was saved:

%fs ls /tmp/iris

À présent, utilisez à nouveau le package Spark-Avro pour lire les données.Now use the spark-avro package again to read back the data.

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 trames dans plusieurs formats de fichier.The data source API can also be used to save DataFrames into multiple file formats. Par exemple, vous pouvez enregistrer le tableau de l’exemple précédent dans un fichier baParquet à l’aide de write.df .For example, you can save the DataFrame from the previous example to a Parquet file using write.df.

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

À partir d’une requête Spark SQLFrom a Spark SQL query

Vous pouvez également créer des trames Sparkr à l’aide de requêtes Spark SQL.You can also create SparkR DataFrames using Spark SQL queries.

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

age est un SparkDataFrame.age is a SparkDataFrame.

Opérations tableauDataFrame operations

Spark trames prend en charge un certain nombre de fonctions pour le traitement structuré des données.Spark DataFrames support a number of functions to do structured data processing. Voici quelques exemples de base.Here are some basic examples. Une liste complète se trouve dans les documents de l' API.A complete list can be found in the API docs.

Sélectionner les lignes et les colonnesSelect rows and columns

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

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

Regroupement et agrégationGrouping and aggregation

SparkDataFrames prend en charge un certain nombre de fonctions couramment utilisées pour agréger des données après le regroupement.SparkDataFrames support a number of commonly used functions to aggregate data after grouping. Par exemple, vous pouvez compter le nombre de fois où chaque temps d’attente s’affiche dans le jeu de données fidèle.For example you can count the number of times each waiting time appears in the faithful dataset.

head(count(groupBy(df, df$waiting)))
# 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 sur les colonnesColumn operations

Sparkr fournit un certain nombre de fonctions qui peuvent être appliquées directement aux colonnes pour le traitement et l’agrégation des données.SparkR provides a number of functions that can be directly applied to columns for data processing and aggregation. L’exemple suivant illustre l’utilisation de fonctions arithmétiques de base.The following example shows the use of basic arithmetic functions.

# 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 Machine learning

Sparkr expose la plupart des algorithmes MLLib.SparkR exposes most of MLLib algorithms. En coulisse, Sparkr utilise MLlib pour former le modèle.Under the hood, SparkR uses MLlib to train the model.

L’exemple suivant montre comment générer un modèle GLM gaussien à l’aide de Sparkr.The following example shows how to build a gaussian GLM model using SparkR. Pour exécuter la régression linéaire, affectez à Family la valeur "gaussian" .To run linear regression, set family to "gaussian". Pour exécuter la régression logistique, affectez à Family la valeur "binomial" .To run logistic regression, set family to "binomial". Quand vous utilisez SparkML GLM Sparkr effectue automatiquement un encodage à chaud des fonctionnalités catégoriques afin qu’il ne soit pas nécessaire de le faire manuellement.When using SparkML GLM SparkR automatically performs one-hot encoding of categorical features so that it does not need to be done manually. Au-delà des fonctionnalités de chaîne et de type double, il est également possible d’ajuster les fonctionnalités de vecteur MLlib pour la compatibilité avec d’autres composants MLlib.Beyond String and Double type features, it is also possible to fit over MLlib Vector features, for compatibility with other MLlib components.

# 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 obtenir des didacticiels, consultez les didacticiels sparkr ml.For tutorials, see SparkR ML tutorials.