Comment utiliser SingleStore avec Spark ML pour la détection de fraude

Résumé

Dans la première partie de cette série de détection de fraude, nous avons créé et configuré un cluster Databricks CE. Dans ce deuxième article, nous allons charger les données de carte de crédit dans notre environnement Spark. Nous comparerons également les performances du connecteur SingleStore Spark à celles de JDBC pour le chargement de nos données dans SingleStore à partir de Spark.

Les fichiers de bloc-notes utilisés dans cette série d’articles sont disponibles sur GitHub aux formats DBC, HTML et iPython.

introduction

Il s’agit d’une série d’articles en 3 parties et elle est structurée comme suit :

1. Configurez Databricks CE.
2. Chargez les données de la carte de crédit dans SingleStore.
3. Créez et évaluez un modèle de régression logistique.

Ce deuxième article couvre la partie 2, Charger les données de carte de crédit dans SingleStore. Si vous suivez cette série, assurez-vous d’avoir terminé avec succès la configuration et les exigences décrites dans le premier article.

Dans notre compte de service géré SingleStore, utilisons l’éditeur SQL pour créer une nouvelle base de données. Appelez ceci détection de fraude, comme suit:

CREATE DATABASE IF NOT EXISTS fraud_detection;

Nous allons exécuter la commande et vérifier qu’elle s’est terminée avec succès.

Nous avons besoin de quelques données pour notre cas d’utilisation. Nous pouvons trouver de vraies données de carte de crédit sur Kaggle. Si vous n’avez pas de compte chez Kaggle, créez-en simplement un et téléchargez le carte de crédit.csv déposer. Sur le site Web de Kaggle, il est indiqué que ce fichier a une taille de 143,84 Mo.

Les données sont des transactions par carte de crédit anonymisées qui contiennent à la fois des cas authentiques et frauduleux. Les transactions se sont déroulées sur 2 jours en septembre 2013 et l’ensemble de données contient un total de 284 807 transactions dont 492 frauduleuses, représentant seulement 0,172 % du total. Cet ensemble de données présente donc certains défis pour l’analyse car il est très déséquilibré. L’ensemble de données se compose des champs suivants :

• Temps: Le nombre de secondes écoulées entre une transaction et la première transaction dans l’ensemble de données.
• V1 à V28 : Détails non disponibles pour des raisons de confidentialité.
• Montant: La valeur monétaire de la transaction.
• Classer: La variable de réponse (0 = pas de fraude, 1 = fraude).

Télécharger le fichier CSV

Nous pouvons télécharger le fichier CSV dans Databricks CE en utilisant le Navigateur de fichiers DBFS. Nous pouvons vérifier que le navigateur de fichiers DBFS est activé en localisant d’abord Paramètres dans le volet de navigation de gauche. Maintenant, nous allons sélectionner le Console d’administration. Sur la page de la console d’administration, nous pouvons voir 3 options :

nous sélectionnerons Paramètres de l’espace de travail.

En faisant défiler la page Paramètres de l’espace de travail vers le bas, nous localiserons le navigateur de fichiers DBFS, comme suit :

Dans ce cas, on voit qu’il est désactivé. Il suffit de basculer le bouton sur le côté droit pour activer cette fonctionnalité, comme suit :

Ensuite, nous devrons recharger cette page de navigateur pour nous assurer que la fonctionnalité est active. Une fois cela fait, nous sélectionnerons Données (1) dans le volet de navigation de gauche, suivi de DBFS (2), alors Magasin de fichiers (3), et enfin le Télécharger bouton (4), comme le montre la figure 1.

Ensuite, nous allons localiser le fichier CSV que nous avons téléchargé précédemment et Faites glisser les fichiers à télécharger ou utilisez le navigateur de fichiers (1) puis cliquez sur Terminé (2) comme le montre la figure 2.

Une fois le fichier CSV téléchargé avec succès, il devrait y avoir une coche à côté du fichier (1) et nous pouvons cliquer sur Terminé (2) comme le montre la figure 3.

Le fichier CSV doit maintenant être visible dans le répertoire, comme le montre la figure 4.

Remplissez le cahier

Créons maintenant un nouveau bloc-notes. Nous l’appellerons Chargeur de données pour la détection de fraude à l’aide de la régression logistique. Nous allons attacher notre nouveau bloc-notes à notre cluster, comme le montre la figure 5.

À l’aide des options du menu déroulant pour une cellule de code (1), nous pouvons afficher le titre d’une cellule de code (2), comme le montre la figure 6.

Ce titre peut ensuite être modifié simplement en l’éditant (1), comme le montre la figure 7. Cela nous aidera à organiser notre code et à nous rappeler ce que nous essayons de réaliser dans chaque cellule de code.

Nous allons ajouter le code suivant (2) :

df = spark.read.csv("/FileStore/creditcard.csv",
                    header = True,
                    inferSchema = True)

Cela lit le fichier CSV et crée un Dataframe appelé df. Nous indiquons également à Spark qu’il existe une ligne d’en-tête et lui demandons de déterminer quels sont les types de données pour chaque colonne. Enfin, nous pouvons ajouter une nouvelle cellule de code en survolant le signe + sous une cellule de code existante (3) et en cliquant dessus.

Pour exécuter chaque cellule de code, nous pouvons utiliser Shift + Enter. Dans ce premier exemple, cela créera le Dataframe.

Dans la cellule de code suivante, nous compterons le nombre de lignes, comme suit :

En exécutant cela, nous obtenons la valeur 284807.

Dans la cellule de code suivante, pour afficher le Dataframe, nous pouvons utiliser :

Dans la cellule de code suivante, pour trouver le nombre de transactions frauduleuses et non frauduleuses, on peut utiliser :

display(df.groupBy("Class").count())

Cela nous montre qu’il y a 492 (1 = fraude) et 284315 (0 = aucune fraude) transactions.

Nous sommes maintenant prêts à écrire le Dataframe dans SingleStore. Dans la cellule de code suivante, nous pouvons ajouter les éléments suivants :

Cela exécutera le bloc-notes que nous avons créé dans l’article précédent. Nous devons nous assurer que l’adresse du serveur et le mot de passe ont été ajoutés pour notre cluster de services gérés SingleStore.

Dans la cellule de code suivante, nous allons définir certains paramètres pour le connecteur Spark SingleStore, comme suit :

spark.conf.set("spark.datasource.singlestore.ddlEndpoint", cluster)
spark.conf.set("spark.datasource.singlestore.user", "admin")
spark.conf.set("spark.datasource.singlestore.password", password)
spark.conf.set("spark.datasource.singlestore.disablePushdown", "false")

Il s’agit des paramètres du cluster SingleStore, du nom d’utilisateur, du mot de passe et de l’activation ou de la désactivation de Pushdown. Nous discuterons de Pushdown dans un article séparé.

Enfin, nous sommes prêts à écrire le Dataframe dans SingleStore à l’aide du Spark Connector :

%%time

(df.write
   .format("singlestore")
   .option("loadDataCompression", "LZ4")
   .mode("overwrite")
   .save("fraud_detection.credit_card_tx"))

Cela écrira le Dataframe dans une table appelée credit_card_tx dans le détection de fraude base de données. Nous pouvons vérifier que cette table a été créée avec succès à partir de SingleStore. En utilisant le %%time dans la cellule de code nous permet de mesurer l’opération d’écriture. Nous pouvons ensuite comparer cela à l’utilisation de JDBC.

Visuellement, la figure 8 montre notre configuration Spark Connector.

Dans la cellule de code suivante, nous pouvons définir les variables JDBC, comme suit :

jdbc_url = "jdbc:mysql://{0}:{1}/{2}".format(server, port, "fraud_detection")

properties = {
  "user": "admin",
  "password": password,
}

Dans la cellule de code suivante, nous pouvons enregistrer le Dataframe dans SingleStore à l’aide de JDBC :

%%time

(df.write
   .jdbc(url = jdbc_url,
         table = "credit_card_tx2",
         mode = "overwrite",
         properties = properties))

Cela écrira le Dataframe dans une table appelée credit_card_tx2 dans le détection de fraude base de données. Nous pouvons vérifier que cette table a été créée avec succès à partir de SingleStore. En utilisant le %%time dans la cellule de code nous permet de mesurer l’opération d’écriture.

Visuellement, la figure 9 montre notre configuration JDBC.

En comparant les deux valeurs de %%time il doit être clair que, prêt à l’emploi, le connecteur Spark SingleStore est beaucoup plus rapide que JDBC. Par conséquent, nous pourrions utiliser Spark pour effectuer des opérations ETL avec SingleStore.

Sommaire

Dans ce deuxième article de cette série de détection de fraude, nous avons chargé avec succès nos données de carte de crédit dans un Spark Dataframe, vérifié le nombre de lignes, puis écrit le Dataframe dans SingleStore en utilisant à la fois le connecteur SingleStore Spark et JDBC. En comparant les performances de ces deux approches, nous devrions voir que, prêt à l’emploi, le connecteur Spark SingleStore est beaucoup plus rapide que JDBC.