SparkR 1.6: ÜbersichtSparkR 1.6 overview

Hinweis

Informationen zur aktuellen SparkR-Bibliothek finden Sie unter Azure Databricks für R-Entwickler.For information about the latest SparkR library, see the Azure Databricks for R developers.

Sparkr ist ein R-Paket, das ein Lightweight-Front-End für die Verwendung von Apache Spark von R bereitstellt. ab Spark 1.5.1 bietet sparkr eine verteilte dataframe-Implementierung, die Vorgänge wie Auswahl, Filterung und Aggregation (ähnlich wie R-Datenrahmen und dplyr) für große Datasets unterstützt.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 unterstützt auch das Erlernen verteilter Maschinelles Lernen mithilfe von mllib.SparkR also supports distributed machine learning using MLlib.

Erstellen von sparkr-dataframesCreating SparkR DataFrames

Anwendungen können dataframes aus einem lokalen R-Datenrahmen, aus Datenquellen oder mithilfe von Spark-SQL-Abfragen erstellen.Applications can create DataFrames from a local R data frame, from data sources, or using Spark SQL queries.

Die einfachste Möglichkeit zum Erstellen eines dataframes ist das Konvertieren eines lokalen R-Daten Rahmens in einen sparkr-dataframe.The simplest way to create a DataFrame is to convert a local R data frame into a SparkR DataFrame. Wir können insbesondere Create a dataframe verwenden und den lokalen R-Datenrahmen übergeben, um einen sparkr-dataframe zu erstellen.Specifically we can use create a DataFrame and pass in the local R data frame to create a SparkR DataFrame. Beispielsweise erstellt die folgende Zelle einen dataframe, der das Treue DataSet aus R verwendet.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)

Aus Datenquellen mit Spark SQLFrom data sources using Spark SQL

Die allgemeine Methode zum Erstellen von dataframes aus Datenquellen lautet Read. DF.The general method for creating DataFrames from data sources is read.df. Diese Methode übernimmt den SqlContext, den Pfad für die zu ladende Datei und den Typ der Datenquelle.This method takes in the SQLContext, the path for the file to load and the type of data source. Sparkr unterstützt nativ und über Spark-Pakete das Lesen von JSON-und Parkett Dateien. Sie finden datenquellenconnectors für beliebte Dateiformate wie CSV und 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 leitet automatisch das Schema aus der JSON-Datei ab.SparkR automatically infers the schema from the JSON file.

printSchema(people)
display(people)

Verwenden von datenquellenconnectors mit Spark-PaketenUsing data source connectors with Spark Packages

Als Beispiel verwenden wir das Spark-CSV-Paket, um eine CSV-Datei zu laden.As an example, we will use the Spark CSV package to load a CSV file. Eine Liste mit Spark-Paketen finden Sie hier: databricks.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)

Die Datenquellen-API kann auch verwendet werden, um dataframes in mehreren Dateiformaten zu speichern.The data sources API can also be used to save out DataFrames into multiple file formats. Beispielsweise können wir den dataframe aus dem vorherigen Beispiel mithilfe von Write. DF aus dem vorherigen Beispiel in eine Parkett Datei speichern.For 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

Aus Spark-SQL-AbfragenFrom Spark SQL queries

Sie können auch sparkr dataframes mithilfe von Spark-SQL-Abfragen erstellen.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)

Dataframe-VorgängeDataFrame operations

Sparkr dataframes unterstützen eine Reihe von Funktionen für die strukturierte Datenverarbeitung.SparkR DataFrames support a number of functions to do structured data processing. Hier finden Sie einige grundlegende Beispiele, und eine komplette Liste finden Sie in der API-Dokumentation.Here we include some basic examples and a complete list can be found in the API docs.

Auswählen von Zeilen und SpaltenSelecting 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))

Gruppierung und AggregationGrouping and aggregation

Sparkr dataframes unterstützen eine Reihe von häufig verwendeten Funktionen zum Aggregieren von Daten nach der Gruppierung.SparkR DataFrames support a number of commonly used functions to aggregate data after grouping. Beispielsweise können wir zählen, wie oft jede Wartezeit im treuen DataSet auftritt.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)))

Spaltenvorgänge (Column operations)Column operations

Sparkr bietet eine Reihe von Funktionen, die direkt auf Spalten für die Datenverarbeitungs-und Aggregations Verarbeitung angewendet werden können.SparkR provides a number of functions that can be directly applied to columns for data processing and aggregation. Das folgende Beispiel zeigt die Verwendung grundlegender arithmetischer Funktionen.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

Ab Spark 1,5 ermöglicht sparkr die Anpassung von verallgemeinerten linearen Modellen über sparkr dataframes mithilfe der GLM ()-Funktion.As of Spark 1.5, SparkR allows the fitting of generalized linear models over SparkR DataFrames using the glm() function. Im Hintergrund verwendet sparkr mllib, um ein Modell der angegebenen Familie zu trainieren.Under the hood, SparkR uses MLlib to train a model of the specified family. Wir unterstützen eine Teilmenge der verfügbaren R-Formel Operatoren für die Anpassung des Modells, einschließlich "~", ".", "+" und "-".We support a subset of the available R formula operators for model fitting, including ‘~’, ‘.’, ‘+’, and ‘-‘.

Im Hintergrund führt sparkr automatisch eine One-Hot-Codierung von kategorischen Features durch, sodass es nicht manuell ausgeführt werden muss.Under the hood, SparkR automatically performs one-hot encoding of categorical features so that it does not need to be done manually. Neben den Features von Zeichen folgen und doppelten Typen ist es auch möglich, über mllib-Vektor Features zu verfügen, um Kompatibilität mit anderen mllib-Komponenten zu erhalten.Beyond String and Double type features, it is also possible to fit over MLlib Vector features, for compatibility with other MLlib components.

Das folgende Beispiel zeigt die Verwendung des erbauens eines gauschen GLM-Modells mithilfe von sparkr.The following example shows the use of building a gaussian GLM model using SparkR. Um die lineare Regression auszuführen, legen Sie Familie auf "Gausch" fest.To run Linear Regression, set family to “gaussian”. Um die logistische Regression auszuführen, legen Sie Familie auf "Binomial" fest.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)

Lokale R-Datenrahmen werden in sparkr-dataframes umgerechnetConverting local R data frames to SparkR DataFrames

Sie können verwenden createDataFrame , um lokale R-Datenrahmen in sparkr dataframes zu konvertieren.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)