Översikt över SparkR 1.6

Anteckning

Information om det senaste SparkR-biblioteket finns i Azure Databricks för R-utvecklare.

Sparker är ett R-paket som ger en låg klient del som använder Apache Spark från R. från och med Spark 1.5.1 tillhandahåller sparker en distribuerad DataFrame-implementering som stöder åtgärder som markering, filtrering och agg regering (liknar R data ramar och dplyr), men på stora data mängder. Sparker har också stöd för distribuerad Machine Learning med MLlib.

Skapa sparker DataFrames

Program kan skapa DataFrames från en lokal R data-ram, från data källor eller med hjälp av Spark SQL-frågor.

Det enklaste sättet att skapa en DataFrame är att konvertera en lokal R data-ram till en spark-DataFrame. Vi kan särskilt använda skapa en DataFrame och skicka den lokala R data-ramen för att skapa en spark-DataFrame. Till exempel skapar följande cell en DataFrame med hjälp av den här data uppsättningen från R.

df <- createDataFrame(sqlContext, faithful)

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

Från data källor med Spark SQL

Den allmänna metoden för att skapa DataFrames från data källor är Read. DF. Den här metoden tar i SQLContext, sökvägen till filen som ska läsas in och typ av data källa. Sparker stöder läsning av JSON-och Parquet-filer internt och genom Spark-paket du kan hitta data käll anslutningar för populära fil format som CSV och 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")

Sparker härleder automatiskt schemat från JSON-filen.

printSchema(people)
display(people)

Använda data källans kopplingar med Spark-paket

Till exempel kommer vi att använda Spark CSV-paketet för att läsa in en CSV-fil. Du hittar en lista över Spark-paket efter Databricks här.

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

API: et för data källor kan också användas för att spara DataFrames i flera fil format. Vi kan till exempel spara DataFrame från föregående exempel till en Parquet-fil med 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

Från Spark SQL-frågor

Du kan också skapa Spark-DataFrames med hjälp av Spark SQL-frågor.

# 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-åtgärder

Spark-DataFrames stöder ett antal funktioner för att utföra strukturerad data bearbetning. Här finns några grundläggande exempel och en fullständig lista finns i API-dokumenten.

Markera rader och kolumner

# 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))

Gruppering och agg regering

Spark-DataFrames har stöd för ett antal funktioner som ofta används för att samla data efter gruppering. Vi kan till exempel räkna antalet gånger som vänte tiden visas i den förkonfigurerade data uppsättningen.

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)))

Kolumnåtgärder

Sparker innehåller ett antal funktioner som kan tillämpas direkt på kolumner för data bearbetning och agg regering. I följande exempel visas användningen av grundläggande aritmetiska funktioner.

# 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)

Maskininlärning

Från och med Spark 1,5 gör Sparkern det möjligt att anpassa generaliserade linjära modeller över Spark-DataFrames med hjälp av funktionen GLM (). Under huven använder sparker MLlib för att träna en modell av den angivna familjen. Vi har stöd för en delmängd av de tillgängliga R-formel operatörerna för modell anpassning, inklusive ~, ".", "+" och "-".

Under huven utför Sparkern automatiskt en-frekvent kodning av kategoriska-funktioner så att de inte behöver utföras manuellt. Utöver sträng-och dubbel typs funktioner är det också möjligt att passa över MLlib Vector-funktioner för kompatibilitet med andra MLlib-komponenter.

I följande exempel visas hur du skapar en Gaussisk GLM-modell med hjälp av Spark. Om du vill köra linjär regression ställer du in serien på "Gaussisk". Om du vill köra Logistisk regression ställer du in-serien till "binomialfördelningen".

# 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)

Konvertera lokala R data-ramar till Spark-DataFrames

Du kan använda createDataFrame för att konvertera lokala R data-ramar till Spark-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)