Vue d’ensemble de SparkR 1.6SparkR 1.6 overview

Notes

Pour plus d’informations sur la dernière bibliothèque Sparkr, consultez Azure Databricks pour les développeurs R.For information about the latest SparkR library, see the Azure Databricks for R developers.

Sparkr est un package R qui fournit un serveur frontal léger pour utiliser Apache Spark à partir de R. à partir de Spark 1.5.1, Sparkr fournit une implémentation tableau distribuée qui prend en charge des opérations telles que la sélection, le filtrage et l’agrégation (similaires aux trames de données R et dplyr), mais aussi aux jeux de données volumineux.SparkR is an R package that provides a light-weight frontend to use Apache Spark from R. Starting with Spark 1.5.1, SparkR provides a distributed DataFrame implementation that supports operations like selection, filtering, and aggregation (similar to R data frames and dplyr) but on large datasets. Sparkr prend également en charge les Machine Learning distribués à l’aide de MLlib.SparkR also supports distributed machine learning using MLlib.

Création de trames SparkrCreating SparkR DataFrames

Les applications peuvent créer des trames à partir d’une trame de données R locale, à partir de sources de données ou à l’aide de requêtes Spark SQL.Applications can create DataFrames from a local R data frame, from data sources, or using Spark SQL queries.

La façon la plus simple de créer un tableau consiste à convertir une trame de données R locale en tableau Sparkr.The simplest way to create a DataFrame is to convert a local R data frame into a SparkR DataFrame. Plus précisément, nous pouvons utiliser créer un tableau et transmettre la trame de données R locale pour créer un tableau Sparkr.Specifically we can use create a DataFrame and pass in the local R data frame to create a SparkR DataFrame. Par exemple, la cellule suivante crée un tableau à l’aide du jeu de données fidèle de R.As an example, the following cell creates a DataFrame using the faithful dataset from R.

df <- createDataFrame(sqlContext, faithful)

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

À partir de sources de données à l’aide de Spark SQLFrom data sources using Spark SQL

La méthode générale pour créer des trames à partir de sources de données est Read. DF.The general method for creating DataFrames from data sources is read.df. Cette méthode prend le SQLContext, le chemin d’accès du fichier à charger et le type de la source de données.This method takes in the SQLContext, the path for the file to load and the type of data source. Sparkr prend en charge la lecture de fichiers JSON et parquet en mode natif et par le biais de packages Spark. vous trouverez des connecteurs de source de données pour des formats de fichiers populaires tels que CSV et Avro.SparkR supports reading JSON and Parquet files natively and through Spark Packages you can find data source connectors for popular file formats like CSV and Avro.

%fs rm dbfs:/tmp/people.json
%fs put dbfs:/tmp/people.json
'{"age": 10, "name": "John"}
{"age": 20, "name": "Jane"}
{"age": 30, "name": "Andy"}'
people <- read.df(sqlContext, "dbfs:/tmp/people.json", source="json")

Sparkr déduit automatiquement le schéma à partir du fichier JSON.SparkR automatically infers the schema from the JSON file.

printSchema(people)
display(people)

Utilisation de connecteurs de source de données avec des packages SparkUsing data source connectors with Spark Packages

Par exemple, nous allons utiliser le package de volume partagé de cluster Spark pour charger un fichier CSV.As an example, we will use the Spark CSV package to load a CSV file. Vous trouverez une liste de packages Spark par Databricks ici.You can find a list of Spark Packages by Databricks here.

diamonds <- read.df(sqlContext, "/databricks-datasets/Rdatasets/data-001/csv/ggplot2/diamonds.csv",
                    source = "com.databricks.spark.csv", header="true", inferSchema = "true")
head(diamonds)

L’API de sources de données peut également être utilisée pour enregistrer des trames dans plusieurs formats de fichier.The data sources API can also be used to save out DataFrames into multiple file formats. Par exemple, nous pouvons enregistrer le tableau de l’exemple précédent dans un fichier parquet à l’aide de Write. DFFor example we can save the DataFrame from the previous example to a Parquet file using write.df

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

À partir de requêtes Spark SQLFrom Spark SQL queries

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(sqlContext, "SELECT age FROM peopleTemp")
head(age)
# Resulting df is a SparkR df
str(age)

Opérations tableauDataFrame operations

Sparkr trames prend en charge un certain nombre de fonctions pour le traitement structuré des données.SparkR DataFrames support a number of functions to do structured data processing. Ici, nous incluons des exemples de base et une liste complète se trouve dans les documents de l' API.Here we include some basic examples and a complete list can be found in the API docs.

Sélection de lignes et de colonnesSelecting rows and columns

# Create DataFrame
df <- createDataFrame(sqlContext, faithful)
df
# 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

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

head(count(groupBy(df, df$waiting)))
# We 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 learningMachine learning

À partir de Spark 1,5, Sparkr permet le montage de modèles linéaires généralisés sur Sparkr trames à l’aide de la fonction GLM ().As of Spark 1.5, SparkR allows the fitting of generalized linear models over SparkR DataFrames using the glm() function. En coulisse, Sparkr utilise MLlib pour effectuer l’apprentissage d’un modèle de la famille spécifiée.Under the hood, SparkR uses MLlib to train a model of the specified family. Nous prenons en charge un sous-ensemble des opérateurs de formule R disponibles pour le modèle d’ajustement, y compris' ~ ', '. ', ' + 'et'-'.We support a subset of the available R formula operators for model fitting, including ‘~’, ‘.’, ‘+’, and ‘-‘.

En coulisses, Sparkr effectue automatiquement un encodage à chaud des fonctionnalités catégoriques afin qu’il n’ait pas besoin d’être effectué manuellement.Under the hood, 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.

L’exemple suivant illustre l’utilisation de la création d’un modèle GLM gaussien à l’aide de Sparkr.The following example shows the use of building a gaussian GLM model using SparkR. Pour exécuter la régression linéaire, affectez à Family la valeur « gaussienne ».To run Linear Regression, set family to “gaussian”. Pour exécuter la régression logistique, affectez à Family la valeur « binomiale ».To run Logistic Regression, set family to “binomial”.

# Create the DataFrame
df <- createDataFrame(sqlContext, 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)

Conversion de trames de données R locales en Spark-tramesConverting local R data frames to SparkR DataFrames

Vous pouvez utiliser createDataFrame pour convertir les trames de données R locales en sparkr trames.You can use createDataFrame to convert local R data frames to SparkR DataFrames.

# Create SparkR DataFrame using localDF
convertedSparkDF <- createDataFrame(sqlContext, localDF)
str(convertedSparkDF)
# Another example: Create SparkR DataFrame with a local R data frame
anotherSparkDF <- createDataFrame(sqlContext, data.frame(surname = c("Tukey", "Venables", "Tierney", "Ripley", "McNeil"),
                                                         nationality = c("US", "Australia", "US", "UK", "Australia"),
                                                         deceased = c("yes", rep("no", 4))))
count(anotherSparkDF)