Notes
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
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)
Contenu connexe
En savoir plus sur les fonctionnalités R :