Utiliser sparklyr

2025-04-18

La ressource sparklyr de langage R sert d’interface à Apache Spark. La ressource sparklr fournit un mécanisme permettant d’interagir avec Spark avec des interfaces R familières. Utilisez sparklyr à travers les définitions de tâches par lots Spark ou avec des notebooks Microsoft Fabric interactifs.

sparklyr est utilisé avec d’autres packages tidyverse , par exemple dplyr. Microsoft Fabric distribue la dernière version stable de sparklyr et tidyverse avec chaque version du runtime. Vous pouvez importer ces ressources et commencer à utiliser l’API.

Conditions préalables

Souscrivez à un abonnement Microsoft Fabric . Vous pouvez également vous inscrire à une version d’évaluation gratuite de Microsoft Fabric .
Connectez-vous à Microsoft Fabric.
Utilisez le sélecteur d’expérience en bas à gauche de votre page d’accueil pour basculer vers Fabric.

Ouvrez ou créez un bloc-notes. Pour en savoir plus, consultez Comment utiliser des notebooks Microsoft Fabric.
Définissez l’option de langue sur SparkR (R) pour modifier la langue primaire.
Attachez votre notebook à un lakehouse. Sur le côté gauche, sélectionnez Ajouter pour ajouter un lakehouse existant ou pour créer un lakehouse.

Connecter sparklyr à un cluster Synapse Spark

La méthode de connexion par fonction spark_connect() établit une connexion sparklyr. La fonction génère une nouvelle méthode de connexion nommée synapse, qui se connecte à une session Spark existante. Cela réduit considérablement l’heure de début de la session sparklyr. Cette méthode de connexion est disponible dans le projet sparklyr open source. Avec method = "synapse", vous pouvez utiliser à la fois sparklyr et SparkR dans la même session, et partager facilement des données entre elles. L’exemple de code de cellule de bloc-notes suivant utilise la spark_connect() fonction :

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

Utiliser sparklyr pour lire des données

Une nouvelle session Spark ne contient aucune donnée. Vous devez ensuite charger des données dans la mémoire de votre session Spark, ou pointer Spark vers l’emplacement des données afin que la session puisse accéder aux données à la demande :

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

Avec sparklyr, vous pouvez également utiliser les données write et read d’un fichier Lakehouse à l’aide d’une valeur de chemin ABFS. Pour lire et écrire dans un lakehouse, commencez par ajouter le Lakehouse à votre session. Sur le côté gauche du bloc-notes, sélectionnez Ajouter pour ajouter un Lakehouse existant. En outre, vous pouvez créer un Lakehouse.

Pour rechercher votre chemin ABFS, sélectionnez avec le bouton droit le dossier Fichiers dans votre Lakehouse, puis sélectionnez Copier le chemin ABFS. Collez votre chemin d’accès pour remplacer abfss://xxxx@onelake.dfs.fabric.microsoft.com/xxxx/Files dans l’exemple de code suivant :

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)

Utiliser sparklyr pour manipuler des données

sparklyr fournit différentes façons de traiter les données à l’intérieur de Spark, avec :

Commandes dplyr
SparkSQL
Transformateurs de fonctionnalités de Spark

Utiliser `dplyr`

Vous pouvez utiliser des commandes dplyr familières pour préparer des données à l’intérieur de Spark. Les commandes s’exécutent à l’intérieur de Spark, ce qui empêche les transferts de données inutiles entre R et 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

La manipulation de données avec dplyr ressource offre plus d’informations sur l’utilisation de dplyr avec Spark. sparklyr et dplyr traduisez les commandes R en SPARK SQL. Permet show_query() d’afficher la requête résultante :

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

Utiliser SQL

Vous pouvez également exécuter des requêtes SQL directement sur des tables au sein d’un cluster Spark. L’objet spark_connection() implémente une interface de DBI pour Spark. Vous pouvez donc utiliser dbGetQuery() pour exécuter SQL et retourner le résultat sous forme de trame de données R :

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

Utiliser des transformateurs de fonctionnalités

Les deux méthodes précédentes s’appuient sur des instructions SQL. Spark fournit des commandes qui rendent certaines transformations de données plus pratiques, sans utiliser SQL. Par exemple, la ft_binarizer() commande simplifie la création d’une nouvelle colonne qui indique si une valeur dans une autre colonne dépasse un certain seuil :

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

La ressource Référence -FT offre une liste complète des transformateurs de fonctionnalités Spark disponibles via sparklyr.

Partager des données entre `sparklyr` et `SparkR`

Lorsque vous vous connectez sparklyr à un cluster Synapse spark avec method = "synapse", sparklyr et SparkR deviennent disponibles dans la même session et pouvez facilement partager des données entre elles. Vous pouvez créer une table Spark dans sparklyr, et la lire à 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)

Apprentissage automatique

L’exemple suivant utilise ml_linear_regression() pour ajuster un modèle de régression linéaire. Le modèle utilise le jeu de données intégré mtcars pour tenter de prédire la consommation de carburant (mpg) d’une voiture en fonction du poids (wt) de la voiture et du nombre de cylindres (cyl) du moteur de voiture. Tous les cas ici supposent une relation linéaire entre mpg et chacune de nos caractéristiques.

Générer des jeux de données de test et d’apprentissage

Utilisez un fractionnement - 70% pour l’entraînement et 30% - pour tester le modèle. Les modifications apportées à ce rapport mènent à différents modèles :

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

Entraîner le modèle

Entraîner le modèle de régression logistique.

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

fit

Utilisez summary() pour en savoir plus sur la qualité de notre modèle et sur la signification statistique de chacun de nos prédicteurs :

summary(fit)

Utiliser le modèle

Appelez ml_predict() pour appliquer le modèle au jeu de données de test :

pred <- ml_predict(fit, partitions$test)

head(pred)

Consultez référence - ML pour obtenir la liste des modèles Spark ML disponibles via sparklyr.

Se déconnecter du cluster Spark

Appelez spark_disconnect()ou sélectionnez le bouton Arrêter la session en haut du ruban du bloc-notes pour mettre fin à votre session Spark :

spark_disconnect(sc)

En savoir plus sur les fonctionnalités R :