---

Avril 2016

Volume 31 numéro 4

Cet article a fait l'objet d'une traduction automatique.

Big Data : traitement des données et apprentissage automatique dans Spark

Par Eugene Chuvyrov

Voici une question pour vous : Quel est le nom de l'infrastructure empruntée fortement à partir du projet Microsoft Dryad, est devenu le projet open source populaire de 2015 et également définir un enregistrement de traitement de données, tri 100 To de données en à peine 23 minutes ? La réponse est simple : Apache Spark.

Dans cet article, je parlerai la vitesse et la popularité des Spark et pourquoi il est le vainqueur clair en cours dans le traitement des données volumineuses et l'espace d'analyse. À l'aide de votre abonnement Microsoft Azure, je présenterai exemples de problèmes machine learning (ML) avec Spark, en prenant un petit pas à partir de l'ingénierie logicielle dans l'univers de science des données. Mais avant de plonger dans l'analyse des données et ML, il est important de dire quelques mots sur divers composants du framework Spark et sur la relation de Spark avec Azure.

Composants Spark

La valeur de l'infrastructure Spark est qu'il permet le traitement des charges de travail de données volumineuses sur les clusters d'ordinateurs de marchandises. Spark est le moteur qui le rend possible de traitement, l'empaquetage des requêtes de données et les distribuer en toute transparence au sein du cluster. Outre Spark Core, il existe plusieurs autres composants du framework Spark, et chacun de ces composants s'applique à un domaine de problème spécifique. Il est possible que vous n'auriez jamais besoin de travailler avec un de ces composants si vous êtes uniquement intéressé par manipulation et de création de rapports sur les grandes charges de travail. Toutefois, dans cet article, je vais utiliser Spark MLLib pour générer un modèle ML qui vous laisse assez précise « deviner » les chiffres que vous avez été écrit à la main (beaucoup plus loin dans cette rubrique). Autoriser les autres composants de l'infrastructure Spark pour le traitement de données en continu (Streaming de Spark), manipulation de graphiques et le calcul de l'algorithme PageRank célèbre (GraphX) et l'exécution des requêtes SQL sur les données distribuées (Spark SQL).

Exécution de Spark sur Azure

Il existe quelques options en expérimentant Spark, de l'utilisation de services gérés à partir de databricks.com (cette société créée et continue à améliorer Spark), configuration un conteneur Docker et de récupérer des images Spark pré-installées Docker Hub, à l'obtention du référentiel de code source entière à partir de GitHub (github.com/apache/spark) et la création de produit. Mais étant donné que cet article concerne Azure, j'aimerais vous montrer comment créer des clusters Spark sur Azure. Cette option est très intéressante c'est parce que Azure fournit des garanties de niveau entreprise pour Spark déployés sur Azure compute clusters. Azure propose un contrat SLA de 99,9 % reposant sur Microsoft pour tous les clusters Spark et offre également une prise en charge 24 x 7 entreprise et analyse du cluster. Ces garanties, associés à la facilité de déploiement de cluster et une multitude d'annonces Spark et Azure pendant la 2016 Build make conférence Microsoft Cloud un excellent environnement pour vos travaux de données volumineuses.

La poussière Pixie

Le mot de passe rend Spark aujourd'hui si populaire parmi les scientifiques de données est double : Elle est rapide et il est facile pour programmer sur cette infrastructure. Tout d'abord, examinons ce qui rend beaucoup plus rapide que les infrastructures qui l'ont précédé Spark.

Prédécesseur, Spark, Hadoop MapReduce, a été le produit phare de l'espace d'analyse de données volumineuses depuis Doug couper et Mike Cafarella co-fondé le projet Apache Hadoop en 2005. MapReduce outils qui étaient disponibles uniquement dans les centres de données Google et ont été complètement fermées provenant. Hadoop fonctionnait bien pour l'analyse par lots de traitement sur le cluster en cours d'exécution, mais il souffrait de rigidité extrême. Mappage et réduire les opérations vont de pair ; tout d'abord procéder à la tâche de mappage, puis vous effectuez la tâche de réduction. Les tâches complexes avaient combiner plusieurs mappage et de réduire les étapes. En outre, chaque tâche dû être décomposée en un mappage permet de réduire les opérations. Qui prend beaucoup de temps pour exécuter ces opérations séquentielles et était ennuyeux de programme. En d'autres termes, ce n'était pas une analyse en temps réel.

En revanche, le framework Spark applique intelligence pour les tâches d'analyse de données à portée de main. Il construit une dirigées vers le graphique cyclique dirigé d'exécution avant de planifier des tâches, très similaires à la façon dont SQL Server construit un plan d'exécution avant d'exécuter une opération d'extraction ou de manipulation de données. DAG fournit des informations sur les transformations que vous allez être effectuée sur les données et Spark peut combiner intelligemment la plupart de ces transformations dans une étape unique et puis exécuter des transformations à la fois, une idée initialement développé par Microsoft Research dans le projet Dryad.

En outre, Spark est capable de conserver intelligemment les données en mémoire via les constructions appelée résilient Distributed Datasets (RDDs), que j'aborderai plus tard et le partager entre les groupes. Ce partage des données entre les travaux de DAG permet d'effectuer plus rapidement qu'ils devaient sans que l'optimisation. Figure 1 présente un DAG pour « hello world » de l'espace de science des données, le nombre de mots dans un fichier texte donné. Notez comment plusieurs opérations, à savoir lecture de fichier texte, flatMap et map, sont combinées en une phase unique, ce qui permet une exécution plus rapide. Le code suivant montre le code Scala (car Spark est enregistré dans Scala) exécution de comptage de mots (même si vous n'avez jamais vu une ligne de code Scala avant, je suis prêt à parier que vous comprendrez instantanément comment implémenter le nombre de mots dans Spark) :

val wordCounts = textFile.flatMap(line => line.split(" ")).map(word => (word,1))  
  .reduceByKey((a, b) => a + b)

Figure 1 dirigées vers le graphique acyclique (DAG) pour le comptage de mots

La deuxième raison que Spark est très répandu est en raison de son modèle de programmation. L'implémentation de comptage de mots dans Spark (code Scala) est beaucoup plus simple que l'implémentation de comptage de mots dans Hadoop MapReduce. En plus de Scala, vous pouvez créer les applications Spark en Java et Python, qui est la langue que j'utilise dans cet article. Avant Spark, avec Hadoop MapReduce, données scientifiques/programmeurs devaient utiliser un paradigme de décomposer une tâche complexe en un ensemble de mappages non naturels et de réduire les opérations. Avec Spark, une approche fonctionnelle de programmation familier pour les développeurs .NET avec les fonctions LINQ et lambda est utilisée pour transformer et analyser les données.

Bientôt, vous verrez comment facile, mais puissants, le modèle de programmation de Spark. Mais avant que vous pouvez écrire le code fonctionnel awesome fonctionne tout aussi bien sur les jeux de données petits et grands, vous devez créer un cluster distribué des ordinateurs que vous avez tous les composants nécessaires de Spark installé et prêt à accepter des tâches de programmation vous présente. La création d'un cluster Spark serait absolument fastidieuse si vous deviez créer et configurer le cluster Heureusement, Microsoft Cloud vous permet d'accomplir la mise en service en quelques clics. Dans la section suivante, je montrerai simplement comment procéder.

Déploiement d'un Cluster Spark

À présent, nous allons créer un cluster HDInsight sur Azure. Considérez les « HDInsight » comme un terme général qui inclut les technologies Hadoop et Spark. Hadoop HDInsight et HDInsight Spark sont deux exemples de services gérés de données volumineuses dans Azure.

Pour configurer un cluster Spark, connectez-vous au portail Azure (portal.azure.com) et cliquez sur Nouveau | Données + analyse | HDInsight | Créer. Spécifier les propriétés du HDInsight Cluster, en spécifiant le nom et le Type de Cluster = Spark, système d'exploitation de Cluster sous Linux (car Spark est en cours de développement sous Linux) et si le champ version inchangé, comme indiqué dans Figure 2. Complétez le reste des informations requises, notamment les informations d'identification pour ouvrir une session sur le nom du compte/conteneur cluster et stockage. Appuyez sur le bouton Créer. Le processus de création d'un cluster prend 15 à 30 minutes.

Figure 2 Création d'un Cluster Spark dans Azure

Une fois le processus de création terminée, vous aurez une vignette dans le portail Azure, qui représente le cluster HDInsight nouvellement créé. Enfin, vous devez examiner en détail le code ! Avant d'entrer dans le code, toutefois, examinons l'environnement de programmation et les langues disponibles avec Spark.

Il existe plusieurs façons de programme dans l'environnement Spark. Tout d'abord, vous pouvez accéder à l'interpréteur de commandes Spark via, intuitivement suffisante, la commande spark-shell, expliqué au bit.ly/1ON5Vy4, où, après l'établissement d'une session SSH vers le nœud principal du cluster Spark, vous pouvez écrire Scala programmes de manière similaire à REPL et envoyer des constructions de programmation à la fois (ne vous inquiétez pas si cette phrase bien comme il a été écrit dans une langue étrangère, passez simplement directement à l'Option 3). Ensuite, vous pouvez exécuter des applications Scala complètes sur Spark (les soumettre via la commande expliqué à spark-submit bit.ly/1fqgZHY). Enfin, il existe également une option pour utiliser des blocs-notes Jupyter (jupyter.org) sur Spark. Si vous n'êtes pas familiarisé avec le projet Jupyter, blocs-notes Jupyter fournissent un environnement d'interactif visual, basée sur le Web dans lequel exécuter les scripts d'analyse de données. Ces ordinateurs portables sont ma méthode préférée de l'analyse de données et je suis convaincu que, une fois que vous les essayez, ils amèneront devenir votre méthode préférée de programmation sur Spark, trop. Azure HDInsight installe l'environnement de bloc-notes Jupyter sur le cluster pour vous, facilitant ainsi l'utiliser.

Pour accéder à des blocs-notes Jupyter, cliquez sur la vignette de tableaux de bord de Cluster comme l'illustre Figure 3, puis cliquez sur la vignette de bloc-notes Jupyter dans la fenêtre coulissant. Connectez-vous en utilisant les informations d'identification que vous avez spécifié lors de la création du cluster, et vous devez voir l'environnement Jupyter prêt à accepter de nouvelles ou modifier les anciens ordinateurs portables. Maintenant, cliquez sur le bouton Nouveau dans le coin supérieur droit et sélectionnez Python 2. Pourquoi Python 2 ? Étant donné que Spark lui-même est écrit dans Scala et un grand nombre de Spark de programmation s'effectue dans Scala, il existe également un pont Python via Pyspark. Par ailleurs, il est un débat raging si vous devez coder dans Scala ou Python. Chaque langage a ses avantages clairs, avec Scala est potentiellement plus rapide, tandis que Python est sans doute plus expressif et les plus couramment utilisées de langage pour la science des données (voir bit.ly/1WTSemP). Cela vous permet d'utiliser un Python expressive encore concise lorsque vous programmez sur le cluster Spark. Python est également ma langue préférée pour l'analyse de données (avec R) et je peux utiliser toutes les bibliothèques Python puissants que je suis habitué.

Figure 3 l'accès à des blocs-notes Jupyter dans Azure HDInsight Via des tableaux de bord de Cluster

Vous êtes enfin prêt à approfondir et effectuer des tâches d'analyse ML et les données dans les bloc-notes Jupyter.

Apprentissage automatique avec Spark

Pour illustrer ML dans Spark, je vais utiliser un exemple de données « mineures » sous la forme de problèmes classiques dans ML: reconnaître les chiffres manuscrits, telles que celles qui apparaissent dans les codes postaux sur des enveloppes. Bien que ce jeu de données n'est pas grand par tout moyen, l'avantage de cette solution est que, les données augmentez - mille pli, vous pouvez ajouter d'autres ordinateurs au cluster et toujours effectuer l'analyse des données dans un délai raisonnable. Aucune modification au code illustré ici ne sera nécessaire, le framework Spark se chargera de distribuer les charges de travail des ordinateurs individuels dans le cluster. Le fichier de données que vous allez utiliser est également classique, il est souvent appelé groupe de données MNIST, et il contient 50 000 chiffres manuscrits, vous pouvez analyser. Bien qu'il existe de nombreux emplacements en ligne pour obtenir le jeu de données MNIST, le site Web de Kaggle vous donne un accès aisé aux données (voir bit.ly/1QJN20c).

Notez que, si vous n'êtes pas familier avec kaggle.com, qu'il héberge des compétitions ML en ligne, où scientifiques presque 500 000 dans le monde en concurrence pour les prix monétaires ou la possibilité d'interroger à une des principales sociétés de ML. J'ai fait entraînés dans cinq Kaggle compétitions et, si vous êtes une personne sur la concurrence, il s'agit d'une expérience extrêmement ADDICTION. Et le site Kaggle lui-même s'exécute dans Azure !

Prenons un moment pour comprendre le contenu de train.csv. Chaque ligne du fichier représente une représentation en pixels d'une image de 28 x 28 contenant un chiffre manuscrit, tel que celui illustré Figure 4 (la figure illustre une représentation agrandie). La première colonne contient le chiffre vraiment Nouveautés ; les autres colonnes contiennent intensité pixels, comprise entre 0 et 255, de tous les 784 pixels (28 x 28).

Figure 4 un zoom dans l'exemple du chiffre « 7 » est représenté dans le jeu de données MNIST

Ouvrez le bloc-notes Jupyter, collez le code suivant dans la première cellule :

from pyspark import SparkContext
from pyspark.mllib.regression import LabeledPoint
from pyspark.mllib.tree import RandomForest
import time
sc = SparkContext(appName="MNISTDigitsDT")
#TODO: provide your own path to the train.csv in the line(s) below, 
# you can use Azure Storage 
#Explorer to upload files into the cloud and to read their full path
fileNameTrain = 'wasb://datasets@chuvyrov.blob.core.windows.net/trainingsample.csv'
fileNameTest = 'wasb://datasets@chuvyrov.blob.core.windows.net/validationsample.csv'
mnist_train = sc.textFile(fileNameTrain)
mnist_test = sc.textFile(fileNameTest)

Ce code importe les bibliothèques nécessaires pour faire ML dans Spark, puis spécifie l'emplacement des fichiers de données que vous voulez utiliser pour la formation et de test du modèle (Notez que ces fichiers doivent résider dans votre compte de stockage accessible à partir de Spark sur Microsoft Cloud via la syntaxe wasb: / / reference). Enfin, les deux dernières lignes est où la RDD sont créés à partir des fichiers texte. RDDs sont la magie d'allumage, leur distribution des structures de données, mais la complexité de leur implémentation est généralement masqué pour l'utilisateur ou le programmeur. En outre, ces RDDs sont évaluées tardivement et sont conservées, au cas où vous avez besoin de réutiliser ce RDD, elle est immédiatement disponible sans ré-computation / l'extraction. Lorsque vous manipulez RDDs, il déclenche la génération des groupes et l'exécution de tâches nouvellement créés dans le cluster Spark, comme je touchées à.

Appuyez sur MAJ + ENTRÉE dans la cellule Jupyter pour exécuter le code que vous avez collé. Aucune nouvelle ne doit être une bonne nouvelle (si vous n'obtenez pas un message d'erreur, vous êtes), et vous devez maintenant avoir RDDs disponibles pour l'interrogation et la manipulation. Ces RDDs contiennent des lignes de texte séparées par des virgules pour le moment, parce que c'est comment vos données MNIST traversé.

La prochaine étape, que vous allez faire est de définir une fonction simple qui vous aidera à convertir ces lignes de texte dans un objet LabeledPoint personnalisé. Cet objet est requis pour l'algorithme ML que vous utiliserez pour former et d'effectuer des prévisions. En résumé, cet objet contient un tableau de « fonctionnalités » (parfois, il est pratique de considérer de fonctionnalités sous forme de colonnes dans une table de base de données) ou les caractéristiques d'un point de données, ainsi que son « label » ou la valeur que vous essayez d'apprennent à prédire. Si cela semble un peu vague dès maintenant, peut-être examiner le fichier train.csv MNIST peut-être vous aider. Vous remarquerez que chaque ligne dans train.csv comporte un nombre dans la première colonne et un ensemble de nombres, de 0 à 255, dans toutes les autres colonnes. La première colonne est appelée « label », étant donné que nous essayons d'apprendre à prédire ce nombre. Toutes les autres colonnes sont « fonctionnalités » et les fonctionnalités prises ensemble sont appelés « vecteur de fonctionnalité ». Ces fonctions sont l'intensité de chaque pixel dans l'image d'un chiffre numérique, 0 étant noir et 255 blanc, avec de nombreuses valeurs entre les deux. Les images sont tous les 28 pixels haute 28 pixels de large, constituant 784 colonnes contenant l'intensité de pixel dans le fichier train.csv (28 x 28 = 784).

Copiez et collez la fonction suivante dans la nouvelle cellule de votre bloc-notes Jupyter :

def parsePoint(line):
  #Parse a line of text into an MLlib LabeledPoint object
  values = line.split(',')
  values = [0 if e == '' else int(e) for e in values]
  return LabeledPoint(int(values[0]), values[1:])

Appuyez sur MAJ + ENTRÉE pour exécuter le code. Vous avez défini la fonction parsePoint, qui a été évaluée par Spark et il est disponible, vous pouvez utiliser avec le jeu de données que vous venez de lire dans. Cette fonction prend une seule ligne de texte séparé par des virgules, divise en valeurs individuelles et convertit ces valeurs dans l'objet LabeledPoint.

Ensuite, vous effectuez certaines données de base de nettoyage pour préparer l'algorithme d'apprentissage ; Malheureusement, l'algorithme d'apprentissage n'est pas encore suffisamment intelligent pour savoir quelle partie des données a la valeur de prévision. Par conséquent, passez l'en-tête du fichier train.csv à l'aide d'un piratage provenant de stackoverflow.com; ensuite, vous allez imprimer la première ligne de la RDD résultant pour vous assurer qu'il est dans l'état comme prévu dans :

#skip header
header = mnist_train.first() #extract header
mnist_train = mnist_train.filter(lambda x:x !=header) 
#filter out header using a lambda
print mnist_train.first()

À présent, vous êtes prêt à appliquer une approche de programmation fonctionnelle avec l'opérateur .map(parsepoint) dans la section suivante pour transformer la RDD en format ready for algorithmes ML dans Spark. Cette transformation essentiellement analysera chaque ligne à l'intérieur de la RDD mnist_train et convertir cette RDD à un ensemble d'objets de LabeledPoint.

RDDs et interactivité : Principaux piliers de l'alimentation, Spark

Il existe plusieurs problèmes importants. Tout d'abord, vous travaillez avec une structure de données distribuée sur le cluster de machines virtuelles (RDD), mais la complexité de l'informatique distribuée est presque entièrement masquée. Vous appliquez des transformations fonctionnelles pour RDD et Spark optimise tout le traitement et essentiel au sein du cluster de machines virtuelles disponibles dans les coulisses pour vous :

labeledPoints = mnist_train.map(parsePoint)
#Split the data into training and test sets (30% held out for testing)
(trainingData, testData) = labeledPoints.randomSplit([0.7, 0.3])
print mnist_train.first()

Bien que la dernière ligne (avec l'instruction print) peut sembler futile, la possibilité d'interroger interactivement des jeux de données volumineux est très puissante et était pratiquement absente dans le monde des jeux de données volumineux avant Spark. Dans votre science des données et les projets de manipulation de données de grande taille, il s'agit d'une technique très utile pour vérifier que les transformations que vous pensez sont appliquées sont effectivement appliquées. Ce traitement interactif puissant n'est encore un autre avantage de Spark sur les autres infrastructures de traitement des données volumineuses.

Également, notez que le fractionnement des données dans la formation et de test à l'aide de la fonction randomSplit. L'idée est pour créer un modèle ML avec les données de trainingData RDD et tester le modèle avec les données de test du RDD, comme vous le verrez dans le code bientôt.

Vous êtes maintenant prêt à appliquer un algorithme ML dans le jeu de données distribuée que vous venez de créer (mnist_train). En bref, n'oubliez pas que des problèmes ML, presque dans tous les cas il existe deux ensembles d'étapes qui se produisent : Tout d'abord, vous formez le modèle avec le jeu de données connu avec les conclusions connues ; Ensuite, vous faire des prédictions basées sur le modèle que vous avez créé ou appris, dans la première étape. Dans le code suivant, vous utilisez un algorithme RandomForest disponible dans le cadre d'apprentissage Spark (Spark MLLib) pour former le modèle. RandomForest est un algorithme distribué disponible dans Spark MLLib et c'est un des plus puissants. Collez le contenu suivant dans la nouvelle cellule :

depthLevel = 4
treeLevel = 3
#start timer
start_time = time.time()
#this is building a model using the Random Forest algorithm from Spark MLLib
model = RandomForest.trainClassifier(trainingData, numClasses=10, 
  categoricalFeaturesInfo={},
  numTrees=treeLevel, featureSubsetStrategy="auto",
  impurity='gini', maxDepth=depthLevel, maxBins=32) 
print("Training time --- %s seconds ---" % (time.time() - start_time))

Notez comment ce code commence à mesurer le temps d'exécution des algorithmes, définit ensuite les valeurs initiales pour certains des paramètres attendus par l'algorithme RandomForest, à savoir maxDepth et numTrees. Exécuter ce code en appuyant sur MAJ + ENTRÉE. Vous vous demandez peut-être qu'est ce que l'on RandomForest et comment cela fonctionne-t-il ? RandomForest est un algorithme ML qui, à un niveau très élevé, fonctionne en créant plusieurs arbres de décision sur les données en sélectionnant de manière aléatoire une variable fractionner un arbre de décision à (autrement dit, une arborescence peut être aussi simple comme, « si le pixel dans le coin inférieur droit est blanc, il est probablement n° 2 »), puis effectuez la décision finale après avoir interrogé toutes les arborescences de construction. Heureusement, il existe déjà une version distribuée de l'algorithme disponibles dans Spark. Toutefois, rien ne vous empêche d'écrire vos propres algorithmes si vous décidez de le faire ; distribuée algorithme k plus proches voisins (kNN) n'est pas toujours présent dans le cadre de Spark.

Revenons maintenant à la tâche de reconnaissance de chiffres MNIST. Si vous avez un environnement similaire à analyser, vous devez obtenir les temps d'exécution de l'apprentissage de l'algorithme d'environ 21 secondes. Cela signifie que dans les 21 secondes, vous avez appris, à l'aide de l'algorithme RandomForest : un modèle que vous pouvez utiliser pour prédire les chiffres que vous voyez étant donné les fonctionnalités que vous avez analysé. Vous êtes maintenant prêt pour la partie la plus importante de la tâche de ML: élaboration de prédictions basées sur le modèle que vous avez créé. En outre, vous pouvez également évaluer la précision de ces prédictions, comme indiqué dans Figure 5.

Figure 5 l'évaluation de la précision de vos prévisions

# Evaluate model on test instances and compute test error
1 #start timer
2 start_time = time.time()
3 #make predictions using the Machine Learning created prior
4 predictions = model.predict(testData.map(lambda x: x.features))
5 #validate predictions using the training set
6 labelsAndPredictions = testData.map(lambda lp: lp.label).zip(predictions)
7 testErr = labelsAndPredictions.filter(lambda (v, p): v != p).count() /
8   float(testData.count())
9 print('Test Error = ' + str(testErr))
10 print("Prediction time --- %s seconds ---" % (time.time() - start_time))
11 #print('Learned classification tree model:')
12 #print(model.toDebugString())

Notez la construction model.predict sur la ligne 4 du Figure 5. Il s'agit de la ligne qui effectue la prédiction réelle basée sur le modèle que vous avez créés précédemment. Les lignes après la prédiction (lignes 5 à 7), vous utilisez certaines manipulations de la base de données temporaire des stratégies sont liées, via la fonction zip, vos valeurs prédites pour les valeurs réelles disponibles dans le cadre du téléchargement. Vous simplement calculer le pourcentage de prédictions correctes en fonction de ces données, puis imprimez le temps d'exécution.

Le résultat de cette classification initiale avec l'erreur est très élevée est légèrement déconcertant (autrement dit, fonctionne votre modèle tout avec un taux d'erreur approche 43 %?). Vous pouvez améliorer le modèle en utilisant le concept appelé « recherche d'hyperparamètres grille » lorsque vous essayez d'une série de valeurs lors de la création du modèle, il immédiatement et finalement converger sur les valeurs d'hyperparamètres qui vous offrent les meilleures performances globales de test. En d'autres termes, essayez de nombreuses expériences systématiques pour déterminer les paramètres du modèle ont la valeur prédictive de.

Le hyperparamètres que vous devez appliquer à la grille recherche sera numTrees et maxDepth ; Collez le code indiqué dans Figure 6 dans la nouvelle cellule dans le bloc-notes.

Figure 6 itératif « Recherche de grille » pour les paramètres optimaux dans l'algorithme RandomForest Spark

1 bestModel = None
2 bestTestErr = 100
3 #Define a range of hyperparameters to try
4 maxDepths = range(4,10)
5 maxTrees = range(3,10)
6
7 #Loop over parameters for depth and tree level(s)
8 for depthLevel in maxDepths:
9 for treeLevel in maxTrees:
10       
11   #start timer
12   start_time = time.time()
13   #Train RandomForest machine learning classifier
14   model = RandomForest.trainClassifier(trainingData,
15     numClasses=10, categoricalFeaturesInfo={},
16     numTrees=treeLevel, featureSubsetStrategy="auto",
17     impurity='gini', maxDepth=depthLevel, maxBins=32)       
18              
19   #Make predictions using the model created above
20   predictions = model.predict(testData.map(lambda x: x.features))
21   #Join predictions with actual values from the data and determine the error rate
22   labelsAndPredictions = testData.map(lambda lp: lp.label).zip(predictions)
23   testErr = labelsAndPredictions.filter(lambda (v, p): v != p)
24     .count() / float(testData.count())
25       
26   #Print information about the model as we proceed with each iteration of the loop
27   print ('\maxDepth = {0:.1f}, trees = {1:.1f}: trainErr = {2:.5f}'
28          .format(depthLevel, treeLevel, testErr))
29   print("Prediction time --- %s seconds ---" % (time.time() - start_time))
30   if (testErr < bestTestErr):
31       bestModel = model
32       bestTestErr = testErr
33           
34 print ('Best Test Error: = {0:.3f}\n'.format(bestTestErr))

Remarquez comment dans les lignes 8 et 14, vous parcourez un jeu de paramètres numTrees pour l'algorithme de forêt aléatoire entre 3 et 10, création de modèles et d'évaluer leurs performances. Ensuite, dans les lignes 30-32, vous capturez le modèle si elle vous obtenez de meilleurs résultats que tous les modèles précédentes que vous avez essayé d'ou rejeter le modèle dans le cas contraire. Laissez cette boucle de temps à s'exécuter ; à la fin de l'exécution, vous devez voir les valeurs d'erreur prédiction inférieures à 10 pour cent.

Synthèse

Lorsque j'ai commencé à écrire cet article, mon objectif était de montrer à travers des exemples combien il est facile à programmer avec Spark, en particulier si vous êtes un fan de la programmation fonctionnelle et Azure. Mon objectif secondaire a été pour montrer comment vous pouvez effectuer des tâches de ML sur les grands et petits à l'aide de la bibliothèque Spark MLLib des jeux de données. Tout au long du processus, je veux expliquer pourquoi Spark exécute plus vite sur les données distribuées, que ses prédécesseurs et partager des bits de la nature de la façon dont nous sommes parvenus à où nous en sommes aujourd'hui dans l'espace d'analyse de données distribuées.

Microsoft investit lourdement dans le futur des données volumineuses, ML, analyse et, en particulier, Spark. Ceci est le bon moment pour découvrir ces technologies pour véritablement tirer parti des possibilités d'analyse de calcul et de données « Hyper-extensibilité » fournie par Microsoft Cloud. Azure facilite l'obtention de l'adoption de Spark rapide, facile et prêt à évoluer vers des grands ensembles de données, toutes assorties de garanties de niveau de service que s'attendre pour seulement les fournisseurs de nuage enterprise meilleures.

Maintenant que vous avez créé un modèle ML et effectué des prédictions sur les données connues, vous pouvez également effectuer des prévisions sur les données qui n'incluent pas son étiquette true ; à savoir, sur le fichier test.csv Kaggle.com. Vous pouvez ensuite effectuer un envoi à Kaggle.com dans le cadre de la concurrence de module de reconnaissance de chiffre sur cette plateforme. Tout le code de cet article, ainsi que le code pour écrire un fichier de demande est disponible à l'adresse GitHub.com/echuvyrov/SparkOnAzure. J'aimerais en savoir plus sur les scores que vous obtenez. Envoyez-moi un message électronique avec des questions, commentaires et suggestions primes ML à eugene.chuvyrov@microsoft.com.

---

Eugene Chuvyrovest un architecte de solutions de cloud de Microsoft dans l'équipe de promotion technique et de développement où il aide les entreprises autour de la zone de la baie de San Francisco tirer pleinement parti de l'évolutivité offerte par Microsoft Cloud. Bien qu'il travaille actuellement sur vos partenaires commerciaux à grande échelle, il n'a pas oublié son racines en tant qu'ingénieur logiciel et bénéficie d'écrire du code de prête pour le cloud en c#, JavaScript et Python. Vous pouvez le suivre sur Twitter : @EugeneChuvyrov.

Merci à l'experte technique Microsoft suivante d'avoir relu cet article : Bruno Terkaly
Bruno Terkaly est un ingénieur logiciel principal chez Microsoft dans le but de l'activation du développement d'applications et services de pointe sur les périphériques. Il est responsable le cloud supérieur et opportunités mobiles États-Unis et au-delà du point de vue activation de la technologie. Il aide les partenaires à mettre leurs applications sur le marché en fournissant des conseils architecturaux et engagement technique approfondie lors de l'éditeur de logiciels d'évaluation, développement et déploiement. Terkaly également travaille en étroite collaboration avec le cloud et les groupes ingénieries mobile, commentaires et influencer la feuille de route.