Utiliser sparklyr
sparklyr est une interface R pour Apache Spark. Il fournit un mécanisme permettant d’interagir avec Spark à l’aide d’interfaces R familières. Vous pouvez utiliser sparklyr via des définitions de travaux par lots Spark ou avec des notebooks Microsoft Fabric interactifs.
sparklyr est utilisé avec d’autres packages tidyverse tels que dplyr. Microsoft Fabric distribue la dernière version stable de sparklyr et tidyverse avec chaque version du runtime. Vous pouvez les importer 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
Utilisez la méthode de connexion suivante dans spark_connect() pour établir une connexion sparklyr. Nous prenons en charge une nouvelle méthode de connexion appelée synapse, qui vous permet de vous connecter à une session Spark existante. Cela réduit considérablement l’heure de début de la session sparklyr. En outre, nous avons contribué cette méthode de connexion au projet open source sparklyr . Avec method = "synapse", vous pouvez utiliser sparklyr et SparkR dans la même session et facilement partager des données entre eux.
# 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. La première étape consiste à charger des données dans la mémoire de votre session Spark ou à pointer Spark vers l’emplacement des données afin qu’elles puissent 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)
À l’aide de sparklyr, vous pouvez également utiliser les données write et read d’un fichier Lakehouse à l’aide du chemin ABFS. Pour lire et écrire dans un lakehouse, commencez par l’ajouter à votre session. Sur le côté gauche du bloc-notes, sélectionnez Ajouter pour ajouter un Lakehouse existant ou créer un Lakehouse.
Pour rechercher votre chemin ABFS, cliquez avec le bouton droit sur le dossier Files dans votre Lakehouse, puis sélectionnez Copier le chemin ABFS. Collez votre chemin d’accès à remplacer dans ce code abfss://xxxx@onelake.dfs.fabric.microsoft.com/xxxx/Files :
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 plusieurs méthodes pour traiter les données à l’intérieur de Spark à l’aide de :
- 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. Il n’existe donc aucun transfert de données inutile entre R et Spark.
Cliquez sur Manipulation de données avec dplyr pour afficher une documentation supplémentaire sur l’utilisation de dplyr avec 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 et dplyr traduisent les commandes R en Spark SQL pour nous. Pour voir la requête résultante, utilisez show_query():
# show the dplyr commands that are to run against the Spark connection
dplyr::show_query(cargroup)
Utiliser SQL
Il est également possible d’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 et sans l’utilisation de SQL.
Par exemple, la commande ft_binarizer() simplifie la création d’une nouvelle colonne qui indique si la valeur d’une autre colonne dépasse un certain seuil.
Vous trouverez la liste complète des transformateurs de fonctionnalités Spark disponibles sur sparklyr à partir de Référence -FT.
mtcars_tbl %>%
ft_binarizer("mpg", "over_20", threshold = 20) %>%
select(mpg, over_20) %>%
head(5)
Partager des données entre sparklyr et SparkR
Lorsque vous vous connectezsparklyr au cluster synapse Spark avec method = "synapse", vous pouvez utiliser sparklyr et SparkR dans la même session et partager facilement des données entre eux. 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
Voici un exemple où nous utilisons ml_linear_regression() pour ajuster un modèle de régression linéaire. Nous utilisons le jeu de données intégré mtcars et voyons si nous pouvons prédire la consommation de carburant d’une voiture (mpg) en fonction de son poids (wt), et le nombre de cylindres que le moteur contient (cyl). Nous partons du principe que la relation entre mpg et chacune de nos caractéristiques est linéaire.
Générer des jeux de données de test et d’apprentissage
Utilisez un fractionnement de 70% pour l’entraînement et 30% pour tester le modèle. Le fait de jouer avec ce ratio entraîne des modèles différents.
# 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 maintenant summary() pour en savoir plus sur la qualité de notre modèle et la signification statistique de chacun de nos prédicteurs.
summary(fit)
Utiliser le modèle
Vous pouvez appliquer le modèle sur le jeu de données de test en appelant ml_predict().
pred <- ml_predict(fit, partitions$test)
head(pred)
Pour obtenir la liste des modèles Spark ML disponibles via sparklyr, consultez référence - ML
Se déconnecter du cluster Spark
Vous pouvez appeler spark_disconnect() ou sélectionner le bouton Arrêter la session en haut du ruban du notebook pour terminer votre session Spark.
spark_disconnect(sc)
Contenu connexe
En savoir plus sur les fonctionnalités R :