Partilhar via


Use sparklyr

sparklyr é uma interface R para o Apache Spark. Ele fornece um mecanismo para interagir com o Spark usando interfaces R familiares. Você pode usar o sparklyr por meio de definições de trabalho em lote do Spark ou com blocos de anotações interativos do Microsoft Fabric.

sparklyr é utilizado juntamente com outros pacotes tidyverse , como dplyr. Microsoft Fabric distribui a versão estável mais recente do sparklyr e do tidyverse a cada lançamento de runtime. Você pode importá-los e começar a usar a API.

Pré-requisitos

  • Obtenha uma assinatura Microsoft Fabric. Ou inscreva-se para obter uma avaliação gratuita do Microsoft Fabric.

  • Inicie sessão em Microsoft Fabric.

  • Use o seletor de experiência no canto inferior esquerdo da página inicial para alternar para o Fabric.

    Captura de tela do menu do seletor de experiências, mostrando onde selecionar Ciência de Dados.

  • Abra ou crie um bloco de notas. Para saber como, consulte Como usar blocos de anotações do Microsoft Fabric.

  • Defina a opção de idioma como SparkR (R) para alterar o idioma principal.

  • Ligue o seu bloco de notas a uma casa no lago. No lado esquerdo, selecione Adicionar Adicionar para adicionar uma casa de lago existente ou para criar uma casa de lago.

Conecte o sparklyr ao cluster Synapse Spark

Use o seguinte método de conexão no spark_connect() para estabelecer uma conexão sparklyr. Suportamos um novo método de conexão chamado synapse, que permite que você se conecte a uma sessão Spark existente. Reduz drasticamente o tempo de início da sessão sparklyr. Além disso, contribuímos com este método de conexão para o projeto sparklyr de código-fonte aberto. Com o method = "synapse", você pode usar sparklyr e SparkR na mesma sessão e facilmente compartilhar dados entre eles.

# connect sparklyr to your spark cluster
spark_version <- sparkR.version()
config <- spark_config()
sc <- spark_connect(master = "yarn", version = spark_version, spark_home = "/opt/spark", method = "synapse", config = config)

Usar o sparklyr para ler dados

Uma nova sessão do Spark não contém dados. A primeira etapa é carregar dados na memória da sessão do Spark ou apontar o Spark para o local dos dados para que ele possa acessar os dados sob demanda.

# load the sparklyr package
library(sparklyr)

# copy data from R environment to the Spark session's memory
mtcars_tbl <- copy_to(sc, mtcars, "spark_mtcars", overwrite = TRUE)

head(mtcars_tbl)

Usando sparklyr, você também pode write e read dados de um arquivo Lakehouse usando o caminho ABFS. Para ler e escrever numa Lakehouse, primeiro adicione-a à sua sessão. No lado esquerdo do notebook, selecione Adicionar para adicionar um Lakehouse existente ou criar um Lakehouse.

Para encontrar seu caminho ABFS, clique com o botão direito do mouse na pasta Files em sua Lakehouse e, em seguida, selecione Copiar caminho ABFS. Cole o seu caminho para substituir o abfss://xxxx@onelake.dfs.fabric.microsoft.com/xxxx/Files neste código:

temp_csv = "abfss://xxxx@onelake.dfs.fabric.microsoft.com/xxxx/Files/data/mtcars.csv"

# write the table to your lakehouse using the ABFS path
spark_write_csv(mtcars_tbl, temp_csv, header = TRUE, mode = 'overwrite')

# read the data as CSV from lakehouse using the ABFS path
mtcarsDF <- spark_read_csv(sc, temp_csv) 
head(mtcarsDF)

Utilize sparklyr para manipular dados

sparklyr fornece vários métodos para processar dados dentro do Spark usando:

  • dplyr comandos
  • SparkSQL
  • Transformadores de características Spark

Utilize dplyr

Você pode usar comandos dplyr familiares para preparar dados dentro do Spark. Os comandos são executados dentro do Spark, portanto, não há transferências de dados desnecessárias entre o R e o Spark.

Clique no Manipulando dados com dplyr para ver a documentação adicional sobre como usar o dplyr com o Spark.

# count cars by the number of cylinders the engine contains (cyl), order the results descendingly
library(dplyr)

cargroup <- group_by(mtcars_tbl, cyl) %>%
  count() %>%
  arrange(desc(n))

cargroup

sparklyr e dplyr traduzem os comandos R para o Spark SQL para nós. Para ver a consulta resultante, use show_query():

# show the dplyr commands that are to run against the Spark connection
dplyr::show_query(cargroup)

Usar SQL

Também é possível executar consultas SQL diretamente em tabelas dentro de um cluster do Spark. O objeto implementa uma interface de DBI para o Spark, para que você possa usar para executar SQL e retornar o resultado como um quadro de dados R:

library(DBI)
dbGetQuery(sc, "select cyl, count(*) as n from spark_mtcars
GROUP BY cyl
ORDER BY n DESC")

Usar transformadores de características

Ambos os métodos anteriores dependem de instruções SQL. O Spark fornece comandos que tornam algumas transformações de dados mais convenientes e sem o uso de SQL.

Por exemplo, o comando ft_binarizer() simplifica a criação de uma nova coluna que indica se o valor de outra coluna está acima de um determinado limite.

Você pode encontrar a lista completa dos Transformadores de Faísca disponíveis através do sparklyr em Reference -FT.

mtcars_tbl %>% 
  ft_binarizer("mpg", "over_20", threshold = 20) %>% 
  select(mpg, over_20) %>% 
  head(5)

Partilhar dados entre sparklyr e SparkR

Quando se conectar sparklyr ao cluster Synapse Spark com method = "synapse", pode usar tanto sparklyr como SparkR na mesma sessão, e facilmente partilhar dados entre ambos. Você pode criar uma tabela Spark no sparklyr e lê-la a partir de SparkR.

# load the sparklyr package
library(sparklyr)

# Create table in `sparklyr`
mtcars_sparklyr <- copy_to(sc, df = mtcars, name = "mtcars_tbl", overwrite = TRUE, repartition = 3L)

# Read table from `SparkR`
mtcars_sparklr <- SparkR::sql("select cyl, count(*) as n
from mtcars_tbl
GROUP BY cyl
ORDER BY n DESC")

head(mtcars_sparklr)

Aprendizagem automática

Aqui está um exemplo em que usamos ml_linear_regression() para ajustar um modelo de regressão linear. Usamos o conjunto de dados de mtcars embutido e vemos se podemos prever o consumo de combustível de um carro (mpg) com base no seu peso (wt), e o número de cilindros que o motor contém (cyl). Assumimos em cada caso que a relação entre mpg e cada uma das nossas características é linear.

Gerar conjuntos de dados de teste e treinamento

Use uma divisão de 70% para treinamento e 30% para testar o modelo. Brincar com esta proporção resulta em modelos diferentes.

# split the dataframe into test and training dataframes

partitions <- mtcars_tbl %>%
  select(mpg, wt, cyl) %>% 
  sdf_random_split(training = 0.7, test = 0.3, seed = 2023)

Treinar o modelo

Treinar o modelo de Regressão Logística.

fit <- partitions$training %>%
  ml_linear_regression(mpg ~ .)

fit

Agora use summary() para aprender um pouco mais sobre a qualidade do nosso modelo e a significância estatística de cada um dos nossos preditores.

summary(fit)

Use o modelo

Você pode aplicar o modelo no conjunto de dados de teste chamando ml_predict().

pred <- ml_predict(fit, partitions$test)

head(pred)

Para obter uma lista dos modelos do Spark ML disponíveis através do sparklyr, visite Reference - ML

Desconectar do cluster Spark

Você pode ligar para spark_disconnect() ou selecionar o botão Parar sessão na parte superior da faixa de opções do bloco de anotações para encerrar a sessão do Spark.

spark_disconnect(sc)

Saiba mais sobre as funcionalidades R: