Science des données avec une image Data Science Virtual Machine Ubuntu sur Azure

Cette procédure pas à pas décrit comment effectuer plusieurs tâches courantes de science des données avec la Data Science Virtual Machine (DSVM) Ubuntu. La DSVM Ubuntu est une image de machine virtuelle disponible dans Azure, avec une collection d’outils préinstallée couramment utilisée dans le cadre de l’analytique données et du Machine Learning. La ressource Approvisionner la Data Science Virtual Machine Ubuntu énumère les composants logiciels clés. L’image DSVM facilite la prise en main de la science des données en quelques minutes, et évite de devoir installer et configurer individuellement chacun des outils. Vous pouvez aisément mettre à l’échelle la DSVM si nécessaire, et vous pouvez l’arrêter lorsqu’elle n’est pas utilisée. Cette DSVM est donc flexible et économique.

Au cours de cette procédure pas à pas, nous analysons le jeu de données spambase. Spambase est un ensemble d’e-mails marqués comme courrier indésirable ou normal (n’est pas considéré comme courrier indésirable). Spambase contient également des statistiques sur le contenu des e-mails. Nous discuterons des statistiques plus loin dans la procédure pas à pas.

Prérequis

Avant de pouvoir utiliser une DSVM Linux, vous devez satisfaire les prérequis suivants :

• Abonnement Azure. Pour obtenir un abonnement Azure, consultez Créez dans le cloud avec un compte gratuit Azure.

• Instance Ubuntu de Data Science Virtual Machine. Pour plus d’informations sur l’approvisionnement de la machine virtuelle, consultez Approvisionnement de la Data Science Virtual Machine Ubuntu.

• X2Go installé sur votre ordinateur et une session XFCE ouverte. Pour plus d’informations, consultez Installer et configurer le client X2Go.

Télécharger le jeu de données spambase

Le jeu de données spambase est un jeu de données relativement réduit contenant 4601 exemples. La taille pratique et gérable de cette ressource facilite l’illustration de certaines des fonctionnalités clés de la DSVM en raison des besoins modestes en ressources.

Remarque

Cette procédure pas à pas a été créée avec une DSVM Linux de taille D2 v2. Vous pouvez utiliser une DSVM de cette taille pour effectuer les étapes décrites dans cette procédure pas à pas.

Pour disposer de davantage d’espace de stockage, vous pouvez créer des disques supplémentaires et les joindre à votre DSVM. Les disques utilisent le stockage Azure persistant ; ainsi, leurs données sont conservées même si le serveur est réapprovisionné en raison d’un redimensionnement ou d’un arrêt. Pour ajouter un disque et l’attacher à votre DSVM, suivez les étapes de la section Ajouter un disque à une machine virtuelle Linux. Les étapes d’ajout d’un disque utilisent l’interface Azure CLI, qui est déjà installée sur la DSVM. Vous pouvez effectuer l’intégralité des étapes à partir de la DSVM elle-même. Une autre option pour augmenter le stockage consiste à utiliser Azure Files.

Pour télécharger les données, ouvrez une fenêtre de terminal et exécutez cette commande :

wget --no-check-certificate https://archive.ics.uci.edu/ml/machine-learning-databases/spambase/spambase.data

Le fichier téléchargé n’a pas de ligne d’en-tête. Nous allons créer un autre fichier qui possède un en-tête. Exécutez cette commande pour créer un fichier avec les en-têtes appropriés :

echo 'word_freq_make, word_freq_address, word_freq_all, word_freq_3d,word_freq_our, word_freq_over, word_freq_remove, word_freq_internet,word_freq_order, word_freq_mail, word_freq_receive, word_freq_will,word_freq_people, word_freq_report, word_freq_addresses, word_freq_free,word_freq_business, word_freq_email, word_freq_you, word_freq_credit,word_freq_your, word_freq_font, word_freq_000, word_freq_money,word_freq_hp, word_freq_hpl, word_freq_george, word_freq_650, word_freq_lab,word_freq_labs, word_freq_telnet, word_freq_857, word_freq_data,word_freq_415, word_freq_85, word_freq_technology, word_freq_1999,word_freq_parts, word_freq_pm, word_freq_direct, word_freq_cs, word_freq_meeting,word_freq_original, word_freq_project, word_freq_re, word_freq_edu,word_freq_table, word_freq_conference, char_freq_semicolon, char_freq_leftParen,char_freq_leftBracket, char_freq_exclamation, char_freq_dollar, char_freq_pound, capital_run_length_average,capital_run_length_longest, capital_run_length_total, spam' > headers

Ensuite, concaténez les deux fichiers :

cat spambase.data >> headers
mv headers spambaseHeaders.data

Le jeu de données possède plusieurs types de statistiques pour chaque e-mail :

• Les colonnes telles que word_freq_WORD indiquent le pourcentage de mots dans l’e-mail correspondant à WORD. Par exemple, si word_freq_make est égal à 1, make représentait 1 % de tous les mots dans l’e-mail.
• Les colonnes telles que char_freqCHAR indiquent le pourcentage de tous les caractères dans l’e-mail correspondant à CHAR.
• capital_run_length_longest est la longueur la plus longue d’une séquence de lettres majuscules.
• capital_run_length_average est la longueur moyenne de toutes les séquences de lettres majuscules.
• capital_run_length_total est la longueur totale de toutes les séquences de lettres majuscules.
• spam indique si l’e-mail a été considéré comme du courrier indésirable ou non (1 = courrier indésirable, 0 = courrier non indésirable).

Explorer le jeu de données à l’aide de R Open

Examinons les données et utilisons R pour effectuer un Machine Learning de base. CRAN R est préinstallé sur la DSVM.

Pour récupérer des copies des exemples de code utilisés dans cette procédure pas à pas, utilisez git pour cloner le dépôt Azure-Machine-Learning-Data-Science. Git est préinstallé sur la DSVM. Depuis la ligne de commande git, exécutez :

git clone https://github.com/Azure/Azure-MachineLearning-DataScience.git

Ouvrez une fenêtre de terminal et démarrez une nouvelle session R dans la console interactive R. Pour importer les données et configurer l’environnement, exécutez :

data <- read.csv("spambaseHeaders.data")
set.seed(123)

Cet exemple de code affiche un résumé des statistiques concernant chaque colonne :

summary(data)

Pour une vue différente des données :

str(data)

Cette vue montre le type de chaque variable et les premières valeurs dans le jeu de données.

La colonne spam a été lue comme un entier, mais il s’agit en fait d’une variable par catégorie (ou facteur). Pour définir son type :

data$spam <- as.factor(data$spam)

Pour une analyse exploratoire, utilisez le package ggplot2, une bibliothèque de graphiques populaire pour R. Le package ggplot2 est préinstallé sur la DSVM. À partir des données récapitulatives affichées précédemment, nous disposons de statistiques résumées sur la fréquence du point d’exclamation. Pour tracer ces fréquences ici, exécutez ces commandes :

library(ggplot2)
ggplot(data) + geom_histogram(aes(x=char_freq_exclamation), binwidth=0.25)

Étant donné que la barre de zéro décale le tracé, nous allons l’éliminer :

email_with_exclamation = data[data$char_freq_exclamation > 0, ]
ggplot(email_with_exclamation) + geom_histogram(aes(x=char_freq_exclamation), binwidth=0.25)

Une densité non triviale au-dessus de 1 semble intéressante. Examinons uniquement ces données :

ggplot(data[data$char_freq_exclamation > 1, ]) + geom_histogram(aes(x=char_freq_exclamation), binwidth=0.25)

Ensuite, répartissez-les en courrier indésirable et courrier légitime :

ggplot(data[data$char_freq_exclamation > 1, ], aes(x=char_freq_exclamation)) +
geom_density(lty=3) +
geom_density(aes(fill=spam, colour=spam), alpha=0.55) +
xlab("spam") +
ggtitle("Distribution of spam \nby frequency of !") +
labs(fill="spam", y="Density")

Ces exemples devraient vous aider à effectuer des tracés similaires et à explorer les données dans les autres colonnes.

Apprentissage et test d’un modèle de Machine Learning

Nous allons entraîner quelques modèles Machine Learning pour identifier les e-mails du jeu de données qui contiennent du courrier indésirable ou du courrier légitime. Dans cette section, nous allons former un modèle d’arbre de décision et un modèle de forêt aléatoire. Ensuite, nous allons tester la précision des prédictions.

Notes

Le package rpart (partition récursive et arbres de régression) utilisé dans le code suivant est déjà installé sur la Data Science VM.

Nous allons commencer par diviser le jeu de données en jeu d’apprentissage et jeu de test :

rnd <- runif(dim(data)[1])
trainSet = subset(data, rnd <= 0.7)
testSet = subset(data, rnd > 0.7)

Ensuite, créez un arbre de décision pour classer les e-mails :

require(rpart)
model.rpart <- rpart(spam ~ ., method = "class", data = trainSet)
plot(model.rpart)
text(model.rpart)

Voici le résultat :

Utilisez cet exemple de code pour déterminer la qualité d’exécution sur le jeu d’entraînement :

trainSetPred <- predict(model.rpart, newdata = trainSet, type = "class")
t <- table(`Actual Class` = trainSet$spam, `Predicted Class` = trainSetPred)
accuracy <- sum(diag(t))/sum(t)
accuracy

Pour déterminer la qualité d’exécution sur le jeu de test, exécutez ce code :

testSetPred <- predict(model.rpart, newdata = testSet, type = "class")
t <- table(`Actual Class` = testSet$spam, `Predicted Class` = testSetPred)
accuracy <- sum(diag(t))/sum(t)
accuracy

Essayons également un modèle de forêts aléatoires. Une forêt aléatoire entraîne plusieurs arbres de décision. Elle génère une classe qui est la valeur de mode des classifications de tous les arbres de décision individuels. Elles fournissent une approche de Machine Learning plus puissante, car elles corrigent la tendance d’un modèle d’arbre de décision à dépasser un jeu de données d’apprentissage.

require(randomForest)
trainVars <- setdiff(colnames(data), 'spam')
model.rf <- randomForest(x=trainSet[, trainVars], y=trainSet$spam)

trainSetPred <- predict(model.rf, newdata = trainSet[, trainVars], type = "class")
table(`Actual Class` = trainSet$spam, `Predicted Class` = trainSetPred)

testSetPred <- predict(model.rf, newdata = testSet[, trainVars], type = "class")
t <- table(`Actual Class` = testSet$spam, `Predicted Class` = testSetPred)
accuracy <- sum(diag(t))/sum(t)
accuracy

Didacticiels et procédures pas à pas de l’apprentissage profond

Outre les exemples basés sur les frameworks, un ensemble de procédures détaillées complètes est également fourni. Ces procédures vous permettent de vous lancer dans le développement d’applications de Deep Learning dans des domaines tels que la compréhension d’image, de texte ou du langage.

• Exécution de réseaux neuronaux sur différents frameworks : procédure pas à pas complète qui montre comment migrer du code depuis un framework vers un autre. Elle montre également comment comparer les performances des modèles et du runtime d’un framework à un autre.

• Guide pratique pour créer une solution de bout en bout afin de détecter des produits dans des images : la technique de détection d’image peut localiser des objets dans les images, et les classifier. Cette technologie peut procurer d’énormes avantages dans de nombreux domaines métier réels. Par exemple, un détaillant peut utiliser cette technique pour déterminer quel produit un client a choisi dans un rayon. Il peut ensuite utiliser ces informations pour gérer le stock des produits.

• Deep learning pour l’audio : ce tutoriel montre comment entraîner un modèle de deep learning pour la détection d’événements audio sur le jeu de données de sons urbains. Ce didacticiel fournit également une vue d’ensemble de l’utilisation des données audio.

• Classification de documents texte : cette procédure pas à pas montre comment créer et entraîner deux architectures de réseau neuronal différentes : le réseau d’attention hiérarchisée et le réseau à mémoire à long ou court terme. Pour classifier les documents texte, ces réseaux neuronaux utilisent l’API Keras pour le Deep Learning. Keras facilite l’utilisation de trois des frameworks d’apprentissage profond les plus populaires, à savoir Microsoft Cognitive Toolkit, TensorFlow et Theano.

Autres outils

Les sections restantes montrent comment utiliser certains des outils installés sur la DSVM Linux. Nous examinons ces outils :

• XGBoost
• Python
• JupyterHub
• Rattle
• PostgreSQL et SQuirreL SQL
• Azure Synapse Analytics (anciennement SQL DW)

XGBoost

XGBoost offre une implémentation rapide et précise des arborescences optimisées.

require(xgboost)
data <- read.csv("spambaseHeaders.data")
set.seed(123)

rnd <- runif(dim(data)[1])
trainSet = subset(data, rnd <= 0.7)
testSet = subset(data, rnd > 0.7)

bst <- xgboost(data = data.matrix(trainSet[,0:57]), label = trainSet$spam, nthread = 2, nrounds = 2, objective = "binary:logistic")

pred <- predict(bst, data.matrix(testSet[, 0:57]))
accuracy <- 1.0 - mean(as.numeric(pred > 0.5) != testSet$spam)
print(paste("test accuracy = ", accuracy))

XGBoost peut également appeler à partir de Python ou d’une ligne de commande.

Python

Pour le développement Python, les distributions Python Anaconda 3.5 et 2.7 sont préinstallées sur la DSVM.

Remarque

La distribution Anaconda comprend Conda. Vous pouvez utiliser Conda pour créer des environnements Python personnalisés sur lesquels des versions ou des packages différents sont installés.

Nous allons lire le jeu de données spambase, et classifier les e-mails avec des machines à vecteurs de prise en charge dans Scikit-learn :

import pandas
from sklearn import svm
data = pandas.read_csv("spambaseHeaders.data", sep = ',\s*')
X = data.ix[:, 0:57]
y = data.ix[:, 57]
clf = svm.SVC()
clf.fit(X, y)

Pour effectuer des prédictions :

clf.predict(X.ix[0:20, :])

Pour montrer comment publier un point de terminaison Azure Machine Learning, nous allons créer un modèle plus basique. Nous utilisons les trois variables que nous avons utilisées quand nous avons publié le modèle R plus tôt :

X = data[["char_freq_dollar", "word_freq_remove", "word_freq_hp"]]
y = data.ix[:, 57]
clf = svm.SVC()
clf.fit(X, y)

JupyterHub

La distribution Anaconda dans la DSVM est fournie avec un notebook Jupyter. Cette ressource est un environnement multiplateforme pour le partage de code Python, R ou Julia et l’analyse. Le serveur Jupyter Notebook est accessible via JupyterHub. Vous vous connectez en utilisant votre nom d’utilisateur Linux local et votre mot de passe à https://<nom DNS de DSVM ou adresse IP>:8000/. Vous trouverez tous les fichiers de configuration JupyterHub dans /etc/jupyterhub.

Remarque

Pour utiliser le gestionnaire de package Python (via la commande pip) à partir d’un notebook Jupyter situé dans le noyau actif, utilisez cette commande dans la cellule de code :

 import sys
 ! {sys.executable} -m pip install numpy -y

Pour utiliser le programme d’installation Conda (via la commande conda) à partir d’un notebook Jupyter situé dans le noyau actif, utilisez cette commande dans une cellule de code :

 import sys
 ! {sys.prefix}/bin/conda install --yes --prefix {sys.prefix} numpy

Plusieurs exemples de notebooks sont déjà installés sur la DSVM :

• Exemples de notebooks Python :
  • IntroToJupyterPython.ipynb
• Exemple de notebook R :
  • IntroTutorialinR

Notes

Le langage Julia est également disponible à partir de la ligne de commande sur la DSVM Linux.

Rattle

Vous pouvez utiliser l’outil R graphique Rattle (RAnalytical Tool To Learn Easily) pour l’exploration de données. Rattle possède une interface intuitive qui facilite la charge, l’exploration et la transformation des données, ainsi que la création et l’évaluation des modèles. Rattle : une interface utilisateur graphique pour l’exploration de données pour R fournit une procédure pas à pas présentant les fonctionnalités de Rattle.

Exécutez ces commandes pour installer et démarrer Rattle :

if(!require("rattle")) install.packages("rattle")
require(rattle)
rattle()

Remarque

Vous n’avez pas besoin d’installer Rattle sur la DSVM. Toutefois, vous pouvez être invité à installer des packages supplémentaires quand Rattle s’ouvre.

Rattle utilise une interface basée sur des onglets. La plupart des onglets correspondent aux étapes du Processus de science des données de l’équipe, telles que le chargement de données ou leur exploration. Le processus de science des données se déroule de gauche à droite à travers les onglets. Le dernier onglet contient un journal des commandes R exécutées par Rattle.

Pour charger et configurer le jeu de données :

1. Pour charger le fichier, sélectionnez l’onglet Data.
2. Choisissez le sélecteur en regard de Filename, puis sélectionnez spambaseHeaders.data.
3. Pour charger le fichier, sélectionnez Exécuter. Vous devez voir un résumé de chaque colonne, notamment son type de données identifié, qu’il s’agisse d’une entrée, d’une cible ou d’un autre type de variable, ainsi que le nombre de valeurs uniques.
4. Rattle a correctement identifié la colonne spam comme étant la cible. Sélectionnez la colonne Spam, puis définissez Target Data Type sur Categoric.

Pour explorer les données :

1. Sélectionnez l’onglet Explore.
2. Pour afficher des informations sur les types de variables et certains résumés de statistiques, sélectionnez Summary>Execute.
3. Pour afficher d’autres types de statistiques relatives à chaque variable, sélectionnez d’autres options, comme Décrire ou Concepts de base.

Vous pouvez également utiliser l'onglet Explorer pour générer des tracés pertinents. Pour tracer un histogramme des données :

1. Sélectionnez Distributions.
2. Pour word_freq_remove et word_freq_you, sélectionnez Histogram.
3. Sélectionnez Exécuter. Vous devez voir les deux graphiques de densité dans une seule fenêtre de graphique, où le mot you (vous) apparaît beaucoup plus fréquemment dans les e-mails que le mot remove (supprimer).

Les tracés de Corrélation sont également intéressants. Pour créer un tracé :

1. Pour Type, sélectionnez Correlation.
2. Sélectionnez Exécuter
3. Rattle vous avertit qu’il recommande un maximum de 40 variables. Sélectionnez Yes pour afficher le tracé.

Certaines corrélations intéressantes apparaissent. Par exemple, il existe une corrélation étroite entre le terme technology et HP et labs. Ce terme est également étroitement corrélé avec 650, car l’indicatif régional des donneurs du jeu de données est 650.

Les valeurs numériques des corrélations entre les mots sont disponibles dans la fenêtre Explorer. Il est intéressant de noter, par exemple, que le terme technologie est négativement corrélé avec les termes votre et argent.

Rattle peut transformer le jeu de données pour gérer certains problèmes courants. Par exemple, il vous permet de remettre à l’échelle les fonctionnalités, d’imputer les valeurs manquantes, de gérer les valeurs hors-norme et de supprimer des variables ou des observations avec des données manquantes. Rattle peut également identifier des règles d’association entre des observations et des variables. Cette procédure pas à pas d’introduction ne couvre pas ces onglets.

Rattle peut également gérer les analyses de cluster. Nous allons exclure certaines fonctionnalités pour simplifier la lecture de la sortie. Sous l’onglet Data, sélectionnez Ignore en regard de chacune des variables, à l’exception de ces 10 éléments :

• word_freq_hp
• word_freq_technology
• word_freq_george
• word_freq_remove
• word_freq_your
• word_freq_dollar
• word_freq_money
• capital_run_length_longest
• word_freq_business
• spam

Revenez à l'onglet Cluster. Sélectionnez KMeans, puis définissez le Nombre de clusters sur 4. Sélectionnez Exécuter. La fenêtre de sortie affiche les résultats. Un cluster a des fréquences élevées de george et de hp, et est probablement un e-mail professionnel légitime.

Pour créer un modèle Machine Learning d’arbre de décision de base :

1. Sélectionnez l’onglet Model.
2. Pour Type, sélectionnez Tree.
3. Sélectionnez Execute pour afficher l’arbre sous forme de texte dans la fenêtre de sortie.
4. Sélectionnez le bouton Dessin pour afficher une version graphique. L’arbre de décision ressemble à l’arbre obtenu précédemment avec rpart.

Rattle peut exécuter plusieurs méthodes de Machine Learning et les évaluer rapidement. Cette fonctionnalité est utile. Voici comment procéder :

1. Pour Type, sélectionnez All.
2. Sélectionnez Exécuter
3. Une fois l’exécution de Rattle terminée, vous pouvez sélectionner n’importe quelle valeur de Type, par exemple SVM, et afficher les résultats.
4. Vous pouvez également comparer les performances des modèles sur le jeu de validation avec l’onglet Evaluate. Par exemple, la sélection de l’option Matrice d’erreur affiche la matrice de confusion, l’erreur globale et l’erreur de classe moyennée pour chaque modèle sur le jeu de validation. Vous pouvez également tracer des courbes ROC, exécuter des analyses de sensibilité et d’autres types d’évaluations de modèle.

Une fois que vous avez terminé la création de vos modèles, sélectionnez l’onglet Log pour afficher le code R exécuté par Rattle pendant votre session. Vous pouvez sélectionner le bouton Exporter pour l’enregistrer.

Notes

La version actuelle de Rattle contient un bogue. Pour modifier le script ou l’utiliser afin de répéter les étapes ultérieurement, vous devez insérer un caractère # devant l’option Export this log ... (Exporter ce journal) dans le texte du journal.

PostgreSQL et SQuirreL SQL

La machine virtuelle de science des données est fournie avec PostgreSQL installé. PostgreSQL est une base de données relationnelle open source sophistiquée. Cette section montre comment charger le jeu de données spambase dans PostgreSQL, puis l’interroger.

Avant de pouvoir charger les données, vous devez autoriser l’authentification par mot de passe à partir de l’hôte local. À l’invite de commandes, exécutez :

sudo gedit /var/lib/pgsql/data/pg_hba.conf

En bas du fichier de configuration, plusieurs lignes détaillent les connexions autorisées :

# "local" is only for Unix domain socket connections:
local   all             all                                     trust
# IPv4 local connections:
host    all             all             127.0.0.1/32            ident
# IPv6 local connections:
host    all             all             ::1/128                 ident

Modifiez la ligne Connexions locales IPv4 pour utiliser md5 plutôt qu’ident, afin que nous puissions nous connecter avec un nom d’utilisateur et un mot de passe :

# IPv4 local connections:
host    all             all             127.0.0.1/32            md5

Ensuite, redémarrez le service PostgreSQL :

sudo systemctl restart postgresql

Pour lancer psql, un terminal interactif pour PostgreSQL, en tant qu’utilisateur postgres intégré, exécutez la commande suivante :

sudo -u postgres psql

Créez un compte d’utilisateur avec le nom d’utilisateur du compte Linux que vous avez utilisé pour vous connecter. Créez un mot de passe :

CREATE USER <username> WITH CREATEDB;
CREATE DATABASE <username>;
ALTER USER <username> password '<password>';
\quit

Connectez-vous à psql :

psql

Importez les données dans une base de données :

CREATE DATABASE spam;
\c spam
CREATE TABLE data (word_freq_make real, word_freq_address real, word_freq_all real, word_freq_3d real,word_freq_our real, word_freq_over real, word_freq_remove real, word_freq_internet real,word_freq_order real, word_freq_mail real, word_freq_receive real, word_freq_will real,word_freq_people real, word_freq_report real, word_freq_addresses real, word_freq_free real,word_freq_business real, word_freq_email real, word_freq_you real, word_freq_credit real,word_freq_your real, word_freq_font real, word_freq_000 real, word_freq_money real,word_freq_hp real, word_freq_hpl real, word_freq_george real, word_freq_650 real, word_freq_lab real,word_freq_labs real, word_freq_telnet real, word_freq_857 real, word_freq_data real,word_freq_415 real, word_freq_85 real, word_freq_technology real, word_freq_1999 real,word_freq_parts real, word_freq_pm real, word_freq_direct real, word_freq_cs real, word_freq_meeting real,word_freq_original real, word_freq_project real, word_freq_re real, word_freq_edu real,word_freq_table real, word_freq_conference real, char_freq_semicolon real, char_freq_leftParen real,char_freq_leftBracket real, char_freq_exclamation real, char_freq_dollar real, char_freq_pound real, capital_run_length_average real, capital_run_length_longest real, capital_run_length_total real, spam integer);
\copy data FROM /home/<username>/spambase.data DELIMITER ',' CSV;
\quit

À présent, nous allons explorer les données et exécuter des requêtes avec Squirrel SQL, un outil graphique capable d’interagir avec des bases de données via un pilote JDBC.

Tout d’abord, dans le menu Applications, ouvrez SQuirreL SQL. Pour configurer le pilote :

1. Sélectionnez Windows>Afficher les pilotes.
2. Cliquez avec le bouton droit sur PostgreSQL et sélectionnez Modifier le pilote.
3. Sélectionnez Chemin de la classe supplémentaire>Ajouter.
4. Pour Nom de fichier, entrez /usr/share/java/jdbcdrivers/postgresql-9.4.1208.jre6.jar.
5. Sélectionnez Ouvrir
6. Sélectionnez Répertorier les pilotes. Pour Nom de la classe, sélectionnez org.postgresql.Driver, puis OK.

Pour configurer la connexion au serveur local :

1. Sélectionnez Windows>Afficher les alias.
2. Sélectionnez le bouton + pour créer un nouvel alias. Comme nouveau nom d’alias, entrez Base de données de courrier indésirable.
3. Pour Pilote, sélectionnez PostgreSQL.
4. Définissez l’URL sur jdbc:postgresql://localhost/spam.
5. Entrez vos nom d’utilisateur et mot de passe.
6. Sélectionnez OK.
7. Pour ouvrir la fenêtre Connexion, double-cliquez sur l’alias Base de données de courrier indésirable.
8. Sélectionnez Connecter

Pour exécuter des requêtes :

1. Sélectionnez l’onglet SQL.
2. Dans la zone de requête située en haut de l’onglet SQL, entrez une requête de base, par exemple SELECT * from data;.
3. Appuyez sur Ctrl+Entrée pour exécuter la requête. Par défaut, SQuirreL SQL retourne les 100 premières lignes de votre requête.

Vous pouvez exécuter beaucoup plus de requêtes pour explorer ces données. Par exemple, en quoi la fréquence du mot make diffère-t-elle entre le courrier indésirable et le courrier légitime ?

SELECT avg(word_freq_make), spam from data group by spam;

Quelles sont les caractéristiques des e-mails qui contiennent souvent le terme 3d ?

SELECT * from data order by word_freq_3d desc;

La plupart des e-mails qui ont une occurrence élevée de 3d sont apparemment du spam. Ces informations peuvent être utiles pour la création d’un modèle prédictif afin de classer les e-mails.

Pour le Machine Learning utilisant des données stockées dans une base de données PostgreSQL, MADlib fonctionne bien.

Azure Synapse Analytics (anciennement SQL DW)

Azure Synapse Analytics est une base de données de scale-out basée sur le cloud capable de traiter de grands volumes de données relationnelles et non relationnelles. Pour plus d’informations, consultez Qu’est-ce qu’Azure Synapse Analytics ?.

Pour vous connecter à l’entrepôt de données et créer la table, exécutez cette commande à partir d’une invite de commandes :

sqlcmd -S <server-name>.database.windows.net -d <database-name> -U <username> -P <password> -I

À l’invite sqlcmd, exécutez la commande suivante :

CREATE TABLE spam (word_freq_make real, word_freq_address real, word_freq_all real, word_freq_3d real,word_freq_our real, word_freq_over real, word_freq_remove real, word_freq_internet real,word_freq_order real, word_freq_mail real, word_freq_receive real, word_freq_will real,word_freq_people real, word_freq_report real, word_freq_addresses real, word_freq_free real,word_freq_business real, word_freq_email real, word_freq_you real, word_freq_credit real,word_freq_your real, word_freq_font real, word_freq_000 real, word_freq_money real,word_freq_hp real, word_freq_hpl real, word_freq_george real, word_freq_650 real, word_freq_lab real,word_freq_labs real, word_freq_telnet real, word_freq_857 real, word_freq_data real,word_freq_415 real, word_freq_85 real, word_freq_technology real, word_freq_1999 real,word_freq_parts real, word_freq_pm real, word_freq_direct real, word_freq_cs real, word_freq_meeting real,word_freq_original real, word_freq_project real, word_freq_re real, word_freq_edu real,word_freq_table real, word_freq_conference real, char_freq_semicolon real, char_freq_leftParen real,char_freq_leftBracket real, char_freq_exclamation real, char_freq_dollar real, char_freq_pound real, capital_run_length_average real, capital_run_length_longest real, capital_run_length_total real, spam integer) WITH (CLUSTERED COLUMNSTORE INDEX, DISTRIBUTION = ROUND_ROBIN);
GO

Copiez les données avec bcp :

bcp spam in spambaseHeaders.data -q -c -t  ',' -S <server-name>.database.windows.net -d <database-name> -U <username> -P <password> -F 1 -r "\r\n"

Remarque

Le fichier téléchargé contient des fins de ligne de style Windows. L’outil bcp attend des fins de ligne de style Unix. Utilisez l’indicateur -r pour informer bcp de cet état de fait.

Ensuite, interrogez à l’aide de sqlcmd :

select top 10 spam, char_freq_dollar from spam;
GO

Vous pouvez également interroger à l’aide de SQuirreL SQL. Suivez des étapes similaires à PostgreSQL avec le pilote JDBC SQL Server. Le pilote JDBC se trouve dans le dossier /usr/share/java/jdbcdrivers/sqljdbc42.jar.