Big Data France

La machine apprend et vous recommande des choses

Philippe Beraud - MSFT — Wed, 15 May 2013 14:47:00 GMT

Benjamin Guinebertière, évangéliste Microsoft et co-administrateur de ce blog, nous propose un article sur l’apprentissage automatique avec Mahout qui vient compléter notre première incursion dans le domaine du Machine Learning.

Cet article paru dans le Magazine Programmez n°160 est reproduit ici avec l’aimable autorisation de Programmez que nous remercions au passage. (L’article a été légèrement amendé de façon à prendre en compte la version Bêta publique courante de Windows Azure HDInsight.)

Pour celles et ceux qui ne connaitraient pas encore Programmez, ce dernier propose un nouveau magazine tous les mois traitant de l’univers du développement informatique, abordant toutes technologies sous forme de dossiers, articles, et tutoriels. Sa renommée s’est établie sur des articles de qualités et traitant de sujets d’actualités ou en avance de phase.

Dans le contexte de ce blog, nous vous invitons tout particulièrement à consulter le sommaire de ce numéro (160) dans lequel se trouvent trois articles abordant différents aspects d’Hadoop.

Si vous avez besoin d’une explication sur ce qu’est le l’apprentissage automatique, le billet Apprentissage automatique (Machine Learning) explique les principes fondamentaux de cette approche.

Je vous souhaite une bonne lecture de cet article et de Programmez.

--Philippe

_____________________________________________________________________________

Parmi les nouveautés qu’apporte « Big Data », il y a une inversion de contrôle si on peut dire, à savoir que l’utilisateur ne fait pas que chercher ; la machine lui propose des données également.

Pour faire cela, la machine apprend en fonction des données qu’elle a déjà en sa possession avant d’utiliser ce qu’elle a appris pour extrapoler et restituer par exemple des recommandations. Cela est un des types d’algorithmes classiques de type « Machine Learning ». Quand on parle ici de la machine dans le domaine des « Big Data », il s’agit en fait d’un cluster de machines. Il peut y en avoir des centaines, voire des milliers.

Mahout fait partie de l’écosystème Hadoop. C’est la traduction de Cornac qui est un conducteur d’éléphant, l’éléphant étant le symbole de Hadoop. Mahout regroupe des algorithmes de type « Machine Learning » et ils ont la caractéristique de pouvoir fonctionner de façon distribuée, typiquement sur des jeux de données qui ne tiennent pas sur une seule machine.

Mahout ne fait pas que recommander. Il existe aussi des algorithmes de classification, et de regroupement (« clustering »), qui avec les recommandations ou filtrage collectif représentent les principales catégories. La classification est souvent illustrée par l’exemple des newsgroups. Après avoir appris sur un certain nombre d’articles classés dans des groupes, la machine peut proposer un groupe ou classer un texte qu’elle n’avait pas encore rencontré. Le regroupement quant à lui consiste à passer d’un grand nombre de données à un petit nombre de groupes de données similaires, ce qui rend le tout humainement manipulable.

Mais revenons à la recommandation, et voyons comment tester cela concrètement, avec comme exemple des recommandations de chansons. L’idée est que plus une personne a écouté un morceau de musique plus elle l’aime. En fonction du comportement d’un grand nombre de personnes, on peut recommander à quelqu’un qui aime un certain nombre de morceaux les chansons qu’il risque d’aimer aussi, et qu’il n’a pas encore écoutées. Pour que ce genre d’algorithme fonctionne, il est nécessaire de disposer d’un jeu de données réel puisqu’on parle d’intelligence collective. Partir d’un jeu de données généré aléatoirement ne donnerait que des résultats aléatoires et sans intérêt en sortie. Pour cet exemple, on s’appuie sur le jeu de données appelé « Million Song Dataset » qu’on abrège en MSD. Ce jeu de données comporte un peu plus d’un million d’utilisateurs, un peu moins de quatre cent mille chansons, et presque cinquante millions de triplets (utilisateur, chanson, nombre d’écoutes). Ces informations et d’autres sont disponibles sur le site de l’université de Columbia.

Le job de recommandations de Mahout qu’on va utiliser ne prend que des entiers en entrée, alors que le MSD identifie les utilisateurs et les chansons par des identifiants. Il est donc nécessaire de faire une transformation pour passer de ce type de jeu de données :

b80344d063b5ccb3212f76538f3d9e43d87dca9eSOYHEPA12A8C13097F 8

b80344d063b5ccb3212f76538f3d9e43d87dca9eSOYYWMD12A58A7BCC9 1

b80344d063b5ccb3212f76538f3d9e43d87dca9eSOZGCUB12A8C133997 1

b80344d063b5ccb3212f76538f3d9e43d87dca9eSOZOBWN12A8C130999 1

b80344d063b5ccb3212f76538f3d9e43d87dca9eSOZZHXI12A8C13BF7D 1

85c1f87fea955d09b4bec2e36aee110927aedf9aSOACWYB12AF729E581 2

85c1f87fea955d09b4bec2e36aee110927aedf9aSOAUSXX12A8C136188 1

85c1f87fea955d09b4bec2e36aee110927aedf9aSOBVAHM12A8C13C4CB 1

85c1f87fea955d09b4bec2e36aee110927aedf9aSODJTHN12AF72A8FCD 2

85c1f87fea955d09b4bec2e36aee110927aedf9aSOELXOV12A8C13616B 2

85c1f87fea955d09b4bec2e36aee110927aedf9aSOGGLLR12A8C13C471 2

A ce type de jeu de données :

1,100,8

1,101,1

1,102,1

1,103,1

1,104,1

2,105,2

2,106,1

2,107,1

2,108,2

2,109,2

2,110,2

C’est le jeu de données d’apprentissage.

On conserve par ailleurs (par exemple dans un table non relationnelle du stockage Windows Azure) les correspondances. Les correspondances pour les utilisateurs sont utiles uniquement lors de la création du fichier pour retrouver un utilisateur. En effet, ils sont anonymisés et 85c1f87fea955d09b4bec2e36aee110927aedf9a ne signifie pas grand-chose de plus que 2 par exemple. En revanche, conserver les correspondances entre les chansons et les morceaux de musique a un intérêt car cela permet de faire appel à des API qui connaissent SOZZHXI12A8C13BF7D et pas 104. On trouvera à http://morceau.azurewebsites.net un site qui permet à partir du numéro (ex : 104) de retrouver les informations sur le morceau quand ses dernières sont disponibles. Cela s’appuie sur l’API disponible à http://developer.echonest.com. Le site echonest.com ne recense qu’une partie des morceaux du MSD ; c’est pourquoi on peut ne pas obtenir de renseignements à partir d’un identifiant MSD de chanson.

En entrée de l’algorithme, on aura besoin également d’un fichier users.txt qui donne la liste des numéros d’utilisateurs pour lesquels on veut des recommandations. Par exemple, si on veut des recommandations pour les utilisateurs 1, 5 et 6, le fichier users.txt contient :

Maintenant qu’on dispose du jeu de données voyons comment on peut exécuter l’algorithme.

On utilisera HDInsight Service, qui est une distribution d’Hadoop sur Windows Azure. Un de ses avantages est qu’on n’a pas besoin d’installer le cluster Hadoop, il est disponible à la demande. Pour savoir comment vous procurer un compte (gratuit ou premium), nous en parlons dans ce billet.

NB : Il est aussi possible d’installer une version mono serveur depuis le Web Platform Installer de Windows et en cherchant « Hadoop ». La démarche est décrite ici.

Une fois le cluster HDInisght Service créé, il est possible de se connecter sur le nœud principal du cluster avec le bureau à distance (« remote desktop »). Il faut copier le jeu de données sur HDFS ou un autre système de fichiers compatible tel qu’ASV (Azure Storage Vault, autrement dit les blobs Windows Azure). Ici, on s’appuie sur HDFS. Si les données sont assez petites, par exemple si les données d’apprentissage tiennent dans un fichier mInput.txt, on peut alors copier les fichiers sur C:\ sur le nœud principal du cluster puis les envoyer sur HDFS de la façon suivante. Ouvrir l’invite de commande qui est sur le bureau et entrer les commandes suivantes :

Hadoop fs –mkdir /hwork

Hadoop fs –mkdir /hwork/input1

Hadoop fs –mkdir /hwork/input2

hadoop fs -copyFromLocal c:\mInput.txt /hwork/input1/mInput.txt

hadoop fs -copyFromLocal c:\users.txt /hwork/input2/users.txt

Dans le cas où on utilise l’intégralité des données du MSD, il est plus réaliste de découper les données d’apprentissage par exemple en fichiers d’un million d’enregistrements chacun, de les compresser avec un algorithme tel que BIZP2, et de les mettre dans un répertoire. La décompression, et la lecture de tous les fichiers est prise en compte automatiquement par Hadoop ; on précise uniquement /hwork/input1/ comme source de données. Dans la copie d’écran suivante, on montre les données d’apprentissage complètes :

(…)

Il suffit ensuite de lancer la commande suivante :

hadoop jar c:\apps\dist\mahout-0.5\mahout-core-0.5-job.jar org.apache.mahout.cf.taste.hadoop.item.RecommenderJob --input=/hwork/input1/ --output=/work/output --usersFile=/hwork/input2/users.txt

Cela déclenche un batch qui peut durer plusieurs dizaines de minutes, voire plusieurs heures. En sortie, on a un fichier comprenant les recommandations pour les utilisateurs demandés :

1 [95:4.7,101:4.375,94:4.375,87:4.375,81:4.2,15:4.2,82:4.2,77:4.2,19:4.2,98:4.111111]

5 [2639:6.0,167:5.6923075,169:5.6923075,182:5.6923075,180:5.6923075,179:5.6923075,178:5.6923075,181:5.6923075,174:5.6923075,172:5.6923075]

6 [13:10.5,1719:10.5,1726:10.5,1736:9.666667,1482:9.666667,1731:9.666667,1738:9.666667,1242:9.5,1277:9.5,1247:9.5]

Cela se lit de la façon suivante :

On recommande à l’utilisateur 1 la chanson 95, avec un indice de 4,7, la chanson 101 avec un indice de 4,375, …, à l’utilisateur 6 la chanson 1247 avec un indice de 9.5. Plus l’indice est élevé, plus la recommandation est forte.

Le détail du mode opératoire sur un sous ensemble des données est documenté en anglais à http://www.windowsazure.com/en-us/develop/net/tutorials/hadoop-recommendation-engine/

Voyons maintenant la pertinence de ce qui est proposé par l’algorithme. Pour cela, on s’appuie sur l’exemple de l’utilisateur 35. Si l’on entre la liste de ce qu’il a écouté à http://morceau.azurewebsites.net, à savoir :

1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 206 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 509 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 214 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1768 1935 1936 1937 1938 1939 1940 1941 532 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1482 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986

On obtient une liste avec la possibilité d’écouter des échantillons d’une partie des morceaux. On voit qu’il y a une bonne proportion de morceaux de l’artiste Sade.

Les recommandations sur un jeu d’apprentissage moyen sont :

35 [8192:53.5,1825:53.5,1748:53.2,411:46.833332,1950:43.333332,335:42.75,1893:42.5,1880:42.333332,3511:40.090908,1979:39.333332]

Le morceau 1950 (SOVBAPB12A8AE48D82) est “Your Love Is King” de Sade.

Pour se faire une idée intuitive plus complète de ce que cela donne, il est préférable d’écouter des extraits de ce qui a été choisi et de ce qui est proposé. Pour cela, les données des premiers utilisateurs (écoute et recommandations) sont disponibles sur le site http://morceau.azurewebsites.net.

Les résultats d’exécution se trouvent dans l’archive test.zip, vous trouverez les logs d’Hadoop dans le fichier résultat-exécution.txt ainsi que les données d’entrée et de sortie dans le dossier mahout. De plus, un exemple de jeu de données est fourni à l’intérieur de l’archive SampleData.zip.

Toute ces archives sont proposées dans l’archive Mahout.zip disponible en pièce jointe ci-dessous.

Bon test !

StreamInsight et le modèle de conception Observateur

Philippe Beraud - MSFT — Wed, 15 May 2013 13:23:00 GMT

Depuis l’ouverture de ce blog, nous avons au travers d’un certain nombre de billets quelque peu « débroussaillé » l’écosystème Hadoop et tous les projets et outils qui gravitent autour, ainsi que les usages qui peuvent en être fait autour des domaines Volume et Variété tels que caractérisés par le principe des 3V (Volume, Vitesse, Variété) du Gartner de plus en plus démocratisé. (Ces 3 domaines clés permettent de définir ce que sont les Big Data et vous serez amenés très probablement à faire face à chacun des Vs à un degré ou un autre si ce n’est d’ores et déjà le cas.)

Dans le cas présent, on parle de l’écosystème Hadoop pour l’analyse sur des données aussi bien structurées que non-structurées. Mais ici, le terme « non-structuré » désigne une donnée sans relation/contexte. Typiquement, une base de données relationnelle (Microsoft SQL Server par exemple) décrit une forte intégrité aux données qu’elle contient par le biais de relations. Cependant, la non-structure de la donnée ne veut pas dire que la donnée soit désorganisée. Au contraire, avec l’expérience, on se rend compte qu’il nous faudra organiser la donnée avant de procéder à tout traitement Map/Reduce. Dans le cas opposé, l’automatisation du processus de traitement Map/Reduce sera difficile.

Beaucoup de demandes sont exprimées aujourd’hui vis-à-vis de ce type d’usage envisagé ici, demandes qui permettent notamment au décisionnel de prendre la vague des Big Data comme illustré ici.

Mais une fois la décision prise d’investir dans cette direction, plusieurs questions se posent comme typiquement :

Est-ce que mes données sont suffisantes ?
Si non, comment se constitue-t-on un jeu de données suffisant ?
Comment doit-on les organiser ?

Constitution d’un jeu de données exploitables

Si, dans ce contexte, nous connaissons les techniques de traitement (Map/Reduce avec Hadoop), une des grandes problématiques résulte dans la possession de données exploitables.

Pour répondre à cette problématique, nous allons nous appuyer sur la technologie Microsoft StreamInsight. L’architecture de StreamInsight est conçue pour absorber et agréger de nombreuses données, provenant de flux différents. Son utilité première, vous l’aurez donc deviné, est l’analyse en temps réel de données et donc de prendre en considération les domaines Vitesse et Variété du principe des 3V précédent.

Dans ce billet, nous allons en détourner l’usage pour en faire un « d’aspirateur de données ». Une fois une quantité conséquente de données entreposées, nous l’analyserons avec les méthodes Big Data que propose Hadoop.

StreamInsight va nous permettre de constituer notre jeu de données exploitable sur lequel nous pourrons ensuite faire nos analyses, et il le fera de façon automatique, avec un minimum de programmation. Ce cas d’usage de StreamInsight diffère quelque peu de celui illustré dans le cadre des après-midi du dev consacrées aux Big Data : Et la vélocité? StreamInsight (avec du code LINQ).

Dans un cas d’usage réel, l’approche nous permettrait de placer toutes sortes de capteurs/traceurs à différents endroits sur la plateforme de production à exploiter pour la circonstance, enregistrant les actions des utilisateurs. Dans le cadre du tutoriel que nous vous proposons ici, et en l’absence d’une telle plateforme, nous allons simplement utiliser une source régulièrement sollicitée dans les tutoriels sur les Big Data, en l’occurrence Twitter.

Twitter a l’avantage de fournir beaucoup de données, rapidement, et de façon gratuite. Il vous reviendra la tâche d’adapter ensuite ce tutoriel à votre propre utilisation ;)

Présentation de Twitter API

Twitter API est un groupement d’interface fournie aux développeurs donnant accès aux tweets hébergés par le réseau social. Si plusieurs possibilités existent, celle qui nous intéresse s’appelle la Streaming API. L’idée derrière cette fonction offerte par Twitter de façon publique est de donner accès au flux global Twitter sans passer par une boucle envoyant une nouvelle requête HTTP à Twitter.

Cette interface diffère de l’API REST par le fait qu’elle demande une connexion HTTP constamment ouverte. On évite ainsi un renvoie de l’entête HTTP qui consomme de la bande passante. On se représente le flux comme une requête infinie.

Twitter propose plusieurs points de terminaison, correspondant à des cas d’utilisations différents :

Public streams : le flux de données publiques, c’est-à-dire l’arrivée en continu des Tweets de comptes publiques.
User streams : le flux de Tweets d’un utilisateur en particulier.
Site streams : une version multi-utilisateurs du point de terminaison User streams.

Nous utiliserons le premier, Public streams. En ouvrant ce lien proposé par Twitter depuis un browser, vous pouvez apercevoir un texte qui défile au fur-et-à-mesure, ne s’arrêtant jamais. Une ligne équivaut à un nouveau tweet au format JSON (JavaScript Object Notation).

La structure JSON d’un tweet est décrite dans la documentation Twitter ici. Pour notre cas de test, nous ne garderons que certains attributs du tweet :

user.screen_name : le nom d’utilisateur postant le tweet.
id_str : l’id du tweet.
created_at : la date de création.
text : le contenu du tweet.
lang : la langue de l’utilisateur.

Concepts de base de StreamInsight

StreamInsight est une plate-forme permettant de traiter des événements complexes et d’analyser leurs résultats en temps réels. On parle en anglais de Complex Event Processing (CEP).

CEP est une méthode dite « in-memory » pour l’analyse de flux de données en continu, ceux-ci provenant de sources multiples, basé sur un langage de requête déclaratif - LINQ (.NET Language-Integrated Query) en l’occurrence avec .NET – avec une latence faible sur un grand nombre d’évènements.

Si vous vous demandez quels sont les cas d’usage, imaginez que nous recevions les données de géolocalisations de milliers de téléphones et ce, toutes les secondes. Si vous développez un service qui réceptionne sur un serveur ces informations de géolocalisation, ce dernier sera très vite saturé car il n’est pas adapté à un nombre de requêtes aussi important, à traiter aussi rapidement. On est bien dans le domaine Vitesse. La plateforme StreamInsight ne le sera pas. Dans sa version standard, celle-ci est capable de recevoir 10 000 évènements à la seconde !

Concrètement, une bibliothèque de classes .NET est mise à notre disposition pour analyser (agréger et corréler) en temps réel les données qui arrivent en continu dans un flux. Pour revenir à notre aspirateur, objet de ce tutoriel, celui-ci doit sur cette base adapter ensuite une sortie pour un ou plusieurs programmes, et ce à des fins de stockage.

En termes de mise en œuvre, cela suppose typiquement de s’appuyer sur les éléments suivants :

Adaptateur en entrée (Input Adapter) : un objet de ce type expose une interface pour collecter les données issues de sources différentes (bases de données, services Web, capteurs, flux réseaux sociaux, etc.).
Requêtes LINQ : elles agissent comme des filtres permettant de récupérer et d’agréger les données souhaitées. Elles se situent généralement dans la méthode principale d’une application.
Adaptateur en sortie (Output Adapter) : un objet de ce type sert à adapter les données ainsi sélectionnées aux utilisations que nous souhaitons en faire : les stocker par exemple dans Windows Azure en vue d’un traitement ultérieur.

Vous trouverez sur la forge CodePlex un exemple d’application StreamInsight dûment documenté. Ce dernier met en scène une analyse de sentiments sur Twitter via une analyse des tweets en temps réel et une visualisation de leurs tendances.

Comme vous pourrez le constater, le concept est très puissant, mais il impose une relative complexité : il est en effet nécessaire de construire pour un adaptateur une classe Factory associée.

A partir de la version 1.1 de StreamInsight, l’équipe en charge du projet StreamInsight au sein du groupe produit SQL Server propose en parallèle une nouvelle façon d’aborder les choses, plus simple, à savoir l’utilisation du pattern (modèle de conception) Observateur (observer), bien connu dans la programmation orientée objet. (L’approche initiale succinctement décrite ci-avant reste toujours prise en charge.)

Modèle de conception Observateur

Ce modèle de conception fait partie des principaux énoncés dans l’ouvrage Design Patterns : Elements of Reusable Object-Oriented Software - l’un des ouvrage de référence sur les patrons de conceptions. Il s’avère particulièrement utile dans une application lorsque l’on a besoin d’ajouter un couplage entre deux objets lors de l’exécution (at runtime). Il agit donc sur le comportement d’un objet, c’est ce que l’on appelle un patron de conception de type comportemental.

Ainsi un objet nommé observable est simplement observé par d’autres objets appelés observateurs. Pour prendre un exemple, on l’utilise fréquemment pour faire de la programmation évènementielle, afin de séparer l’affichage du comportement qui est lié à celle-ci (si on clique sur le bouton Valider, un objet est notifié et se charge de l’enregistrement du formulaire).

On évite grâce à ce procédé de passer par une attente active sur l’objet produisant l’évènement (ce qui se traduit par une boucle infinie testant à chaque tour si l’interface a changée). De plus, cela permet à l’objet observé de ne pas connaitre à l’avance ses observateurs (=suppression de dépendances).

Le schéma ci-dessous explique le déroulement :

L’observable, en réalité, possède une liste des observateurs qui se sont abonnés à lui. Ces observateurs implémentent tous une interface spécifique, IObserver, qui définit une fonction précise à appeler lorsqu’un nouvel évènement doit être diffusé.

Pour aller plus loin dans la compréhension du modèle de conception, vous pouvez consulter l’article MSDN Modèle de design observateur.

Le Framework. NET apporte sa propre implémentation du modèle de conception Observateur depuis la version 4.0, ainsi que, dans le contexte qui nous intéresse avec StreamInsight, au sein d’une bibliothèque appelée Reactive Extensions (Rx). (Cette bibliothèque a été créée de manière indépendante de StreamInsight, mais StreamInsight repose dessus). Vous y trouverez par exemple l’interface IObserver<T> ainsi que l’interface IObservable<T>.

Avec la version 2.1 de StreamInsight, des méthodes d’extensions sont disponibles, elles permettent ni plus ni moins de transformer un objet implémentant l’interface IObservable<T> en un flux (CepStream, la classe de base d’un flux StreamInsight).

A l’arrivée, l’approche autorise un bénéfice non négligeable, à savoir le fait d’écrire son application sans aucune compréhension préalable du concept de CEP, et ce simplement via l’utilisation d’un modèle de conception simple et bien connu.

StreamInsight se charge de « manager » votre code et de transformer vos classes en objets Cep (une inversion de contrôle est effectuée).

Conception de notre application AspirateurTwitter exemple

Après toutes ces explications, nous pouvons passer à la modélisation de notre propre exemple application CEP, en utilisant le modèle de conception Observateur. Le code de source de l'application est disponible en pièce jointe sous forme de fichier archive .zip en bas de ce billet. N'hésitez pas à le consulter en parallèle des explications ci-dessous.

Un peu d’UML

Voilà quelques petites précisions :

Nous définissons une classe Tweet, simple POCO (Plain Old CLR Object). Notre identifiant est un entier base 64, le reste est stocké dans des chaines de caractères. Cette classe surcharge la méthode ToString() qui sera utilisée pour remplir un blob Azure.
Notre source de données est décrite dans la classe SourceTwitter. Cette classe implémente l’interface IObservable<T> qui définit une seule méthode : Subscribe(). Elle est appelée lorsqu’un observateur veut s’abonner (=souscrire) à la source. Dès lors, on ajoute le nouvel arrivant dans la liste des observateurs. De plus, nous définissons ici une méthode interne, notifierObservateurs, qui a pour rôle l’appel de la méthode OnNext() de chaque observateur abonné.
Notre observateur du flux Twitter est décrit dans la classe ObservateurTwitter, qui implémente l’interface IObserver<T>. Il y a une surcharge de la méthode OnNext(), prenant un objet Tweet comme paramètre, de la méthode OnError() et OnCompleted(). Cette dernière méthode est invoquée pour désabonner l’observateur de la source.

Souscription

Dans notre proposition de mise en œuvre, la classe Souscription est un peu à part. Ce qu’il faut en savoir est qu’elle est nécessaire pour désabonner convenablement l’observateur de l’observable. Lorsqu’un objet de type IObserver veut quitter la liste des notifiés, il déclenche sa méthode IObserver.OnCompleted() qui invoque la méthode Souscription.Dispose().

Avant cela, une instance de Souscription est retournée par la méthode SourceTwitter.Subscribe() au moment où un nouvel observateur veut s’abonner. Elle est composée de l’observateur et de l’observable.

Pourquoi cette classe est-elle nécessaire ? Elle découple l’observateur de l’observable tout simplement. Dans notre application AspirateurTwitter, vous la trouverez comme classe interne à SourceTwitter.

Invocation de l’API Twitter Streaming

Notre invocation se situe dans le constructeur de la classe SourceTwitter. Notre exemple est simple et n’a pas la prétention d’une application de production.

Dans ce constructeur, on peut voir une création de tâche via la bibliothèque parallèle de tâches TPL (Task Parallel Library) qui s’exécutera donc sur un thread différent, pour ne pas bloquer le programme. A l’intérieur, une boucle infinie est faite sur un flux (au travers d’un StreamReader) provenant d’une requête HTTP (sur Twitter Streaming). Pour chaque itération, on récupère la nouvelle ligne dans une chaine de caractères, puis on lance la phase de notification de tous les observateurs (grâce à la méthode notifierObservateurs).

Le fichier App.config contient les définitions de deux paramètres Twitter que vous aurez à remplacer pour tester le code proposé pour l’illustration :

twitterAccount : le nom du compte de stockage Windows Azure.
twitterPass : la clef associée au compte ci-dessus.

L’utilisation de ces paramètres s’appuie sur la classe ConfigurationManager proposé par le Framework .NET. (Vous pouvez consulter un tutoriel ici à ce sujet pour plus d’information).

Filtrage avec LINQ

Dans la classe Program, puis la méthode Main(), nous créons en premier lieu une instance d’une nouvelle source SourceTwitter, puis nous la transformons en objet CepStream grâce à la méthode d’extension ToPointStream(). Vient ensuite ce qui nous intéresse, à savoir le filtre LINQ. Il s’agit d’une simple requête LINQ comme on a l’habitude d’en faire sur le CepStream récupéré précédemment :

var filtre = from tweet where tweet.Lang == “fr” in source select tweet;

Cette simple ligne permet de sélectionner les tweets de langue française. A vous de modifier selon votre besoin ;)

Passons à la suite de la méthode Main(), nous transformons cet objet filtre en un objet Observable avec la méthode d’extension ToPointObservable(). Nous souscrivons notre objet ObservateurTwitter à cet objet Observable qui le notifiera à son tour pour chaque nouveau tweet de langue française !

Bien sûr il vous est possible d’ajouter un deuxième voir même - soyons fous ;) - un troisième observateur de cette requête. Il y aurait par exemple un observateur qui se charge de stocker les données sur un compte de stockage Windows Azure dans le Cloud, un autre alimentant une interface de visualisation sur un site Web, proposant ainsi un affichage temps réel d’un graphique, etc.

Stockage des tweets sur Windows Azure

Si vous êtes attentifs, la classe ObservateurTwitter possède des méthodes privées ajouterAuBuffer() et telechargerSurAzure(). En effet, nous avons décidé de mettre directement dans notre observateur la logique de téléchargement de nos tweets sur un compte de stockage Windows Azure. Un attribut buffer - tableau de bytes - stocke les tweets au fur et à mesure. Un index est incrémenté pour remplir le buffer, et lorsque celui-ci arrive à équivalence de la taille totale du buffer, la méthode telechargerSurAzure() est appelée. Cette méthode se charge de récupérer le buffer pour le télécharger comme objet blob sur un conteneur Azure en particulier.

Le fichier App.config contient les définitions de trois paramètres Windows Azure que vous aurez à remplacer pour tester le code :

accountName : le nom du compte de stockage Windows Azure.
accountKey : la clef associée au compte ci-dessus.
containerRef : le nom du conteneur principal sur lequel vous voulez stocker les blobs.

Déploiement de notre application AspirateurTwitter

Passons maintenant au déploiement de notre solution nommée « AspirateurTwitter ».

Installation de StreamInsight Server 2.1

Vous trouverez le guide pas à pas d’installation en français ici. Suivez les instructions, mais faites attention à la version de StreamInsight qui est indiquée dans un lien pour le télécharger. A l’heure actuelle, ce lien pointe sur une version antérieure à la 2.1, néanmoins vous pouvez retrouver la version 2.1 sur la page suivante : Microsoft SQL Server StreamInsight 2.1.

Note : la version dite « client » ne nous servira pas vis-à-vis de ce tutoriel.

Une fois l’installation terminée, veuillez garder en mémoire le nom du serveur d’instance StreamInsight que vous avez ajouté lors de l’installation. Il nous servira par la suite.

Configuration de l’application AspirateurTwitter

Le code source de l’application est proposé en pièce jointe de ce billet. Ouvrez la solution dans Visual Studio ; de notre côté, nous avons utilisé la version 2012.

Le projet utilise trois bibliothèques :

Microsoft CEP, installé avec StreamInsight. Vous pouvez y accéder dans l’onglet Extensions du Reference Manager. Une bibliothèque de méthodes d’extensions est aussi installée automatiquement et utilisée pour le modèle de conception Observateur : Reactive Extensions (Rx).
Newtonsoft.Json, qui est ajoutée avec NuGet.
Microsoft Windows Azure SDK que vous pouvez aussi récupérer avec NuGet, ou bien installer la plateforme Windows Azure.

Si vous ne connaissez pas NuGet, pas de panique car il est intégré à Visual Studio 2012. (Pour les versions antérieures, il vous faudra installer une extension.) NuGet un gestionnaire de paquets qui télécharge automatiquement les bibliothèques externes dont vous avez besoin dans votre projet, celles-ci étant ensuite mises à jour automatiquement. Vous trouverez un tutoriel sur l’utilisation de NuGet ici.

Code Source de l’application AspirateurTwitter

Le projet proposé contient un fichier de configuration (« .config ») et 4 fichiers sources (« .cs ») :

App.config est un fichier XML que vous devez éditer pour modifier les variables de configuration Twitter, Windows Azure et StreamInsight :

- <appSettings>

-

- <add key="accountName" value="votre_compte_stockage_azure"/>

- <add key="accountKey" value="votre_clef_de_stockage_azure"/>

- <add key="containerRef" value="votre_conteneur_principal_azure"/>

- <add key="twitterAccount" value="votre_identifiant_twitter"/>

- <add key="twitterPass" value="votre_mot_de_passe_twitter"/>

- <add key="serveurStreamInsight" value="nom_du_serveur_stream_insight"/>

</appSettings>

Program.cs est la classe principale de notre application. La fonction Main() est exécutée et contient les instructions d’instanciation de nos classe Observable et Observateur.
SourceTwitter.cs est la classe implémentant IObservable<T>. La méthode Subscribe() est la seule surcharge nécessaire à réaliser pour répondre au contrat de IObservable<T>. Dans cette classe, on écoute l’API Streaming de Twitter, on parse le texte au format JSON renvoyé, puis on le stocke dans un objet de type Tweet.cs et enfin, on notifie les observateurs.
ObservateurTwitter.cs est la classe implémentant IObserver<T>. Les méthodes OnNext(), OnCompleted() et OnError() sont nécessaire à la validation du contrat.
Tweet.cs est la classe de base stockant un tweet sous forme d’objet. La méthode ToString() retourne une chaine de caractères formatée de la manière suivant :

<id>[tabulation]<createdAt>[tabulation]<userName>[tabulation]<text>

Le schéma ci-dessous indique le cheminent d’un tweet dans notre application AspirateurTwitter:

Pourquoi une taille de 255 Mo (267386880 octets) ? Par expérience, le traitement Map/Reduce d’une (possible future) application Big Data sur Windows Azure HDInsight lit de manière distribuée les données contenues dans un seul conteneur par block de 255 Mo. Avec cette astuce, nous optimisons le traitement futur et évitons ainsi une baisse de performance. Maintenant, vous pouvez tester avec une valeur inférieure - modifiez la constante dans ObservateurTwitter tailleBuffer - sinon cela risque d’être long avant que vous puissiez voir un résultat.

Une dernière chose à préciser, le stockage dans Windows Azure d’un blob s’effectue dans un dossier « input » (en partant de racine du conteneur), puis est répertorié par date de téléchargement. Le fichier possède un nom unique, en réalité un nombre représentant le TimeStamp du système d’exploitation lors de l’enregistrement du fichier.

En guise de conclusion

Ce tutoriel tire à sa fin. Ce dernier a illustré comment écrire une application CEP sur StreamInsight 2.1 avec le modèle de conception Observateur, et ce, avec un minimum de code. Comme indiqué précédemment, le code source est accessible dans le projet AspirateurTwitter proposé en pièce jointe de ce billet.

Si vous avez envie de pousser plus loin vos investigations sur cette technologie StreamInsight, voici quelques ressources utiles :

Le sommaire de la documentation, un classique qui plus est disponible en français.
Le Guide de démarrage (getting started) de StreamInsight qui vous apportera les notions de bases.
Un workshop sur l’architecture Event Processing et LINQ sur Channel 9, le site de vidéos didactiques pour la communauté.

Pour vous tenir informé(e) des nouveautés et exemples, n’hésitez pas à consulter le blog MSDN dédié. Mentionnons enfin un billet sur les macros LINQ qui détaille quelques cas d’utilisation.

Merci de votre lecture et à très bientôt pour de nouvelles découvertes !

Big Data et Data Explorer

Philippe Beraud - MSFT — Mon, 13 May 2013 14:56:04 GMT

Comme nous avons pu déjà le souligner, ce blog se veut un cadre d’échanges et de partage avec la mise en avant de problématiques données assorties de la proposition de scénarios/solutions type prêts à l’usage. Ainsi, pour rentrer de façon pragmatique dans le monde du #BigData, l’objectif que nous nous sommes fixé consiste notamment à partager des focus particuliers sur la mise en œuvre concrète d’une technologie particulière ou d’un ensemble de technologies dans le contexte des solutions Microsoft pour le Big Data.

A ce propos, J’ai aujourd’hui le plaisir de publier dans ce blog ce billet rédigé par Jean-Pierre Riehl, responsable de Practice Data & Business Intelligence de la société AZEO. Je profite de cette occasion pour remercier très sincèrement Jean-Pierre pour cette contribution.

Jean-Pierre est MVP SQL Server et fait partie du « board » du Groupe des Utilisateurs SQL Server. Très impliqué sur les usages Self-Service du décisionnel, il suit de très près le dernier outil Data Explorer, véritable Self-Service ETL embarqué dans Excel.

Je vous souhaite une bonne lecture de ce billet et n’hésitez pas à consulter sur le blog de Jean-Pierre les autres billets consacrés à Data Explorer.

--Philippe

________________________________________________________________________________________________

L'un des enjeux des Big Data est de pouvoir les utiliser. Pour reprendre un célèbre slogan, “à quoi ça sert d'avoir des data si c'est pour rien faire avec”.

Souvent associé avec le requêtage des Big Data, on a l'image d'un scientifique (Data Scientist) ou d'un geek nourri aux pizzas, les 2 écrivant des requêtes complexes dans un langage dont on reconnait des morceaux mais qu'on ne comprend jamais vraiment bien.

La réalité est bien différente ; non pas qu'il n'y ait pas de scientifiques ou de geeks, mais on trouve une boite à outil très riche pour exploiter nos données Big Data.

C'est d'autant plus vrai dans l'univers Microsoft où l'on dispose des drivers, langages et outils intégrés à un écosystème riche et existant. Grace à Hive, on peut requêter nos données avec un langage SQL depuis Excel, SSIS (SQL Server Integration Services) ou .Net. Grace à PolyBase, on peut mixer nos Big Data avec un Data Warehouse d'entreprise en faisant des jointures entre les deux.

L'objet de cet article est de présenter un petit nouveau dans cette boite à outils : Data Explorer.

Data Explorer, c’est quoi ?

Data Explorer est un add-in à Excel permettant de faire du « shaping » et du « mashup » de données. En français, on pourrait parler de façonnage (je ne parle pas de mise en forme) et de composition (au sens de mélanger). Derrière ces mots barbares, on trouve toutes les opérations qui permettent de prendre des jeux de données quelconques et de le transformer en un Dataset exploitable : exploitable pour du reporting mais également pour de l'analyse de données bien évidemment.

Les développeurs trouveront que cet outil ressemble (fonctionnellement) à un ETL comme SSIS et ils auront totalement raison, tout du moins dans sa partie flux de données. On parle d'ailleurs de Self-Service ETL.

Cet add-in Excel orienté utilisateur est gratuit et complète parfaitement l'offre de Self-Service BI de Microsoft et en particulier PowerPivot et Power View. C'est un point important ! Ce n'est pas un outil de développeur, c'est bien un outil pour l'utilisateur final. Il est d'ailleurs également important de noter qu'il fonctionne sous Excel 2013 - on s'en serait douté -, mais également sous Excel 2010, comme PowerPivot ; ce qui lui donne une cible d'utilisateurs très large.

Mais le lien avec les Big Data ?

C'est simple, parmi la multitude de sources que prend en entrée Data Explorer, il y a des sources HDInsight que ce soit Windows Azure HDInsight ou HDInsight Server.

Si je rapproche cela du fait qu'on est sur un outil pour les utilisateurs métiers - ou finaux, appelez les comme vous voulez -, on voit tout de suite l'intérêt.

Nos Big Data ne sont plus réservées aux seuls développeurs mais sont utilisables par tous et surtout par les consommateurs les plus intéressés.

Regardons un peu plus tout cela dans le détail. Mettons-nous à la place de notre utilisateur métier. Et sa première question sera "mais quelle source dois-je prendre" ?

Source

Usage

Hadoop File (HDFS)

On requête l'endroit où sont stockées nos données Big Data, c’est-à-dire un stockage HDFS et donc orienté fichiers.

Qu'importe ce qu'il y a derrière, un serveur unique ou des centaines de machines, on donne juste l'adresse du cluster HDFS sous la forme : hdfs://monclusterHDFS

Windows Azure HDInsight

Windows Azure HDInsight est un service Azure qui va gérer le stockage HDFS. HDInsight va nous offrir la puissance de calcul d'un cluster Hadoop (Map/Reduce, Hive, Pig, etc.).

Toutefois, Data Explorer va se brancher sur les données brutes à savoir le Blob Storage qui contient les données. On ne pourra donc pas utiliser la puissance de calcul du Cloud.

Pour cela, on va renseigner notre compte Blob Storage et on va pouvoir requêter les Containers qui s'y trouvent.

Ici, j'ai téléchargé un fichier contenant un flux Twitter.

Côté Excel, je m'y connecte via Data Explorer en précisant mon compte ainsi que la clé d'accès (en effet, ces données ne sont pas publiques).

Dans l'interface de Data Explorer, on voit les Containers de mon BlobStorage dans la zone de navigation de la source de données. On notera aussi que dans la barre de formule (Settings –> Show Formula Bar), la source se requête de la façon suivante :

=HDInsight.Contents("BlobStorageName")

Et on en fait quoi ?

Mais replaçons-nous au niveau d'un utilisateur métier. Ce dernier va naviguer pour arriver jusqu'aux données « finales » et ce d'abord au niveau fichier - ici il n'y en a qu'un dans le container.

Puis on va pouvoir descendre dans le contenu en cliquant sur les 2 petites flèches de la colonne Content.

On a maintenant la liste de tous nos Tweets au format JSON, format riche mais compliqué à exploiter. Ça tombe bien car Data Explorer sait l'interpréter :

On transforme les données sous la forme d’une table pour pouvoir les exploiter
On supprime la première ligne d'entête
On transforme la colonne en JSON et on obtient une table contenant le type Record qui représente les objets à manipuler

On va dé-normaliser chaque Record en récupérer les clés/valeurs. Cela se fait avec l'icône en haut à droite de la colonne. La liste des champs trouvés s'affiche et on peut même rechercher parmi eux via la textbox du haut.

On récupère la date, le texte et l'utilisateur. Ce dernier est de nouveau de type Record (c'est la force du format JSON) et donc on réitère l'opération pour récupérer son nom
On termine notre shaping en renommant les colonnes et en mettant les bons types (la date en particulier).

Une fois tout cela effectué nous disposons d'un Dataset prêt à être exploité dans Excel, PowerPivot, Power View ou encore Geoflow. D’ailleurs, Data Explorer permet justement de charger le résultat directement dans le Data Model de PowerPivot.

Evidemment Data Explorer ne nous sert pas qu'à renommer des colonnes ou simplement sélectionner des données. On peut croiser ces données avec d'autres jeux de données (jointure, union, etc.), les transformer, les pivoter, etc. On peut même étendre les fonctions de base en développant des fonctions avancées (ex : géocoding avec Bing Maps, API de qualification du texte, etc.) comme illustré notamment ici.

On récapitule

Data Explorer permet de récupérer et transformer des données Big Data comme n'importe quelle autre source. On se connecte sur nos Blob Azure (ou bien sur notre cluster HDFS) et nous avons accès à toutes les fonctions de manipulation des données de l'outil.

En sortie, on obtient un Dataset "propre", directement utilisable dans Excel, comme n'importe quelle autre table.

On est dans un scénario BI (Business Intelligence) typique : transformer des données brutes en information.

Mais comment positionne-t-on l'usage exactement ?

En effet, l'outil est simple, séduisant mais comment le place-t-on dans notre Système d'Information ?

Je vois 2 usages principaux :

Le premier est évidemment la mise à disposition d'un "requêteur" permettant de faire des analyses sur des données en provenance de notre système Big Data.
C'est trivial mais un nouvel outil pour manipuler du Big Data n'est pas de trop étant donné l'outillage actuel, surtout quand il est aussi simple et vise une large population de l'entreprise.
Le second usage identifié est très intéressant ; c'est un usage de prototypage. Avant de mettre en place un projet plus ou moins complexe de Big Data, que ce soit au niveau du stockage des données ou des services de requêtage, il est peut-être pertinent d'en valider l'utilisation "Business".
Avant de monter sa solution de Big Data, avant s'y déverser des « tombereaux » de données Twitter, Facebook, logs web et consorts, avant de lancer les équipes dans des algorithmes MapR et dans du requêtage Pig, Hive ou autre ; avant d'activer ces moyens, n'est-il pas pertinent de valider que l'aiguille se trouve bien dans la botte de foin ?

Comment Démarrer ?

Convaincu ? L'avantage, c'est que vous pouvez démarrer tout de suite : :)

Télécharger Data Explorer.
Tester le Blob Storage d'Azure.
Tester Windows Azure HDInsight.
Récupérer des données Twitter.

Le Microsoft Research Machine Learning Summit en webcasts à la demande !

Philippe Beraud - MSFT — Thu, 25 Apr 2013 08:31:01 GMT

Nous l’évoquions brièvement dans le billet précédent, Microsoft France a accueilli au Centre de conférence ces 23 et 24 avril Rick Rashid, Chief Research Officer de Microsoft, ainsi que les meilleurs chercheurs de nos laboratoires de Redmond, Silicon Valley, Bangalore, Cambridge, etc. pour le Microsoft Research Machine Learning Summit, une conférence au sommet autour du Big Data et du « Machine Learning », à destination d’un public de chercheurs et universitaires venus de toute l’Europe.

Vous pouvez visionner le « teaser » de la conférence ici.

Lors de l’édition 2013 des Microsoft TechDays, et en particulier lors de la plénière Bienvenue dans l'océan numérique (KEY203), nous explorions déjà les perspectives et opportunités d’un monde dans lequel Big Data et « Machine Learning » sont à l’œuvre pour transformer notre vie et celle de nos entreprises.

L’objet du Machine Learning Summit est de faire le point avec les plus grands experts du domaine, chez Microsoft mais aussi ceux des meilleurs laboratoires américains ou européens - dont l’Inria (Institut national de recherche en informatique et en automatique) - sur l’état de l’art et ses applications à des domaines aussi variés que social data, vidéo, médecine, etc. Le programme détaillé de la conférence est précisé ici.

Le « Machine Learning » est une vraie révolution dans le logiciel : probabilités et statistiques sur les masses de données permettent au logiciel « d’apprendre » et non seulement calculer. Nouvelle frontière, nouvelle façon de penser le logiciel et de le programmer, c’est une révolution qui replace la « Big Science » au cœur de l’innovation.

Microsoft est à la pointe dans ce domaine : le moteur de Kinect en est le meilleur exemple, il est issu de recherches en Machine Learning menées à Microsoft Research Cambridge et ses « concepteurs » étaient présents à la conférence. Vous pouvez retrouver les différents travaux, projets et publications ici.

Notre laboratoire commun Inria-Microsoft Research se mobilise également sur ce sujet.

Enfin, la recherche française a des atouts uniques pour exceller en « Machine Learning » : une « école » statistique reconnue mondialement, des Grandes Ecoles comme l’ENS (Ecole Normale Supérieure) ou les Mines qui forment les meilleurs étudiants au contact de chercheurs émérites (notamment de l’Inria) ou nos Universités qui comptent des lauréats de la médaille Fields et des prix Nobel de physique !

Au-delà du discours d’ouverture de la conférence, les plénières ainsi que les principales sessions sont désormais accessibles (ou sur le point de l’être) sous forme de webcasts à la demande ici, à l’image de :

Plenary 1 Keynote: Machines that (Learn to) See avec, comme speaker, Andrew Blake, Distinguished Scientist et directeur de Microsoft Research Cambridge, United Kingdom. Andrew Blake est un spécialiste du traitement d’image et de vidéo. Il était le leader côté Microsoft Research de « Project Natal » qui a donné Kinect tel que nous le connaissons aujourd’hui.

Plenary 2 Keynote: The Mathematics of Causal Inference: with Reflections on Machine Learning avec, comme, speaker, Judea Pearl, Professeur d’informatique et de statistiques, directeur du « Cognitive Systems Laboratory » à UCLA (University of California, Los Angeles), et également Turing Award 2011, c.à.d. le « prix Nobel de l’informatique » pour sa contribution à la recherche en intelligence artificielle.

Research in Focus – Teaching Machines to See avec notamment comme speaker Fei-Fei Li, professeur associé et directeur du laboratoire de « Computer Vision » de l’université de Stanford.

Etc.

Bon visionnage !

Apprentissage automatique (Machine Learning)

Philippe Beraud - MSFT — Wed, 24 Apr 2013 08:41:55 GMT

L’apprentissage automatique, c’est la capacité d’un ordinateur à apprendre sans avoir été explicitement programmé.

Arthur Samuel

Hier matin, en me rendant dans les locaux de Microsoft France où se déroule au Centre de conférence ces 23 et 24 avril le Microsoft Research Machine Learning Summit - une conférence au sommet autour du Big Data et du « Machine Learning » à destination d’un public de chercheurs et universitaires venus de toute l’Europe -, un panneau au pied du pont du Garigliano indiquait :

Périphérique intérieur => fluide
Périphérique extérieur => 6 min Porte d’Orléans

De là est partie la (petite) réflexion suivante : si nous changeons le second affichage (c.à.d. Périphérique extérieur) par ceci :

Périphérique intérieur => fluide
L’autre : 6min Porte d’Orléans

Nous comprenons que l’affichage, « l’autre » en l’occurrence, correspond au périphérique extérieur. Cette relation, nous la faisons naturellement et sans réfléchir au préalable.

Des associations comme celle-ci nous en faisons régulièrement et si, par exemple, nous changeons le sujet en prenant comme phrase « La voiture est en panne, je prends l’autre », l’autre correspond cette fois à une deuxième voiture implicite.

Le mot « autre » est associé dans ces deux exemples à des entités complètement différentes. Pourtant notre cerveau arrive à faire la déduction naturellement grâce au contexte.

Le premier exemple sur le périphérique décrit deux types : intérieur et extérieur. Ce sont des termes opposés c’est-à-dire que l’alternative à intérieur est extérieur.

Comment le sait-on ? Cela fait partie de notre cadre de référence qui est constitué d’informations et d’expériences dépendantes de l’environnement dans lequel nous évoluons et de l’apprentissage que nous avons reçu.

Nous possédons donc déjà un cadre de référence qui nous permet de faire des déductions, de prendre des décisions en fonction du contexte. Par contre, si nous prenons le cas d’un enfant, plus il sera jeune, moins il déduira le déroulement d’actions car sa phase d’apprentissage sera moindre.

Principes de fonctionnement

Pour une machine, le fonctionnement est similaire. Il faut partir du principe qu’elle n’a pas encore de cadre de référence et qu’il va falloir qu’elle apprenne pour se constituer une mémoire qui, à son tour, l’aidera à faire un choix sur une situation avec un contexte particulier. Plus la machine possédera de comportements différents en fonction des contextes, plus elle répondra avec pertinence.

Le temps de réflexion augmentera en fonction du nombre de situations vécues et des comportements effectués ce qui n’est pas toujours amusant. En effet, si l’ordinateur prend trois jours à se décider pour déplacer le cavalier droit aux échecs, l’utilisateur aura déjà fermé le programme.

Quand l’ensemble de tous les comportements devient trop important, il augmente au fil du temps pour affiner la pertinence de l’algorithme. Pour pallier à ce problème complexe, il est nécessaire de séparer les rôles. On va donc créer un modèle qui sera mis à jour par un programme indépendant. Ce modèle simplifie la complexité précédente car il ne s’agrandit pas, il s’ajuste simplement. Vient ensuite, l’algorithme principal qui est de type adaptif et utilise le modèle pour s’auto-améliorer.

Comment est constitué un modèle ?

Il est bien souvent composé de probabilités Ainsi, dans le cas d’algorithmes de prédiction, une action donne un état, auquel correspondent plusieurs actions nouvelles possibles. Chaque action possède une probabilité de se produire, associée à l’état courant. Un des modèles régulièrement utilisé est la « chaîne de Markove ».

Vous avez dit chaîne de Markov ?

Une définition simpliste nous suffira pour aborder ici ce modèle : il s’agit de décrire sous forme d’un graphe une série d’états (représentées par des nœuds) et reliées par des probabilités (qui sont les arrêtes). Lorsque nous sommes dans un état, il existe une certaine probabilité pour être dans un deuxième état ou un troisième. A partir de ce constat, nous pouvons écrire une équation prédisant l’état du système dans 5 minutes.

A titre d’illustration, la chaîne de Markov ci-dessous indique que nous avons 9 chances sur 10 de faire l’activité « Autre activité » lorsque nous sommes dans l’état de départ, alors qu’il y a 1 chance sur 10 pour que nous soyons directement amenés à « l’activité de fin ». La somme de toutes les probabilités étant égale à 1.

Pour le cas où nous sommes en train de faire l’autre activité, nous pouvons finir par l’activité de fin (7/10), ou bien recommencer au départ (3/10).

Un exemple plus détaillé et bien expliqué - enfin je trouve – est disponible sur la page Wikipédia dédiée à la chaîne de Markov, à savoir Doudou le hamster.

Une autre variante consiste à ajouter un facteur décisionnel à chaque état ; on appelle cela un processus de Markove décisionnel (MDP). On l’utilise pour que l’algorithme ait la capacité de faire un choix. Par la suite, une fois le graphe construit, on peut aisément en déduire des équations transformées en calcules matriciels. Et les matrices, les ordinateurs savent très bien les manipuler ;)

Revenons à nos hamsters. Nous parlions de constitutions de modèle. Il peut aussi se trouver sous forme d’arbre (binaire, quelconque, etc.) ou encore de courbe, pertinent lorsque l’analyse se fonde sur des données temporelles.

Une fois que notre algorithme a appris à apprendre, il fonctionne en autonomie.

Apprentissages et élaboration du modèle

La première phase pour nos algorithmes d’apprentissage automatique doit donc être la classification des données d’apprentissage. Cette phase est un « pré mâchage » de l’information qui sera utilisée pour constituer le modèle. Elle est étiquetée pour être associée à une classe précise. Il existe plusieurs systèmes pour la phase d’apprentissage.

Apprentissage supervisé

Un modèle de classement est soumis par une personne, puis l’information du jeu de données est classée suivant celui-ci. Un expert est en charge de construire le modèle de classement qui contient des étiquettes (tag) à placer sur la donnée. Le professeur de l’université de Stanford Andrew Ng l’explique dans son cours Machine Learning (CS 229) avec l’exemple suivant (Module 1).

Supposons que nous collections des statistiques sur la taille de maisons au mètre carré et le prix correspondant. Nous avons donc spécifié que, dans notre jeu de données, il y a des maisons avec un attribut « surface » et un autre « prix ». Nous créons le graphique ci-dessous :

Les points bleus correspondent aux maisons, la ligne rouge représente la moyenne. Si nous voulons connaitre le prix pour une maison de surface 80 m², l’algorithme va en déduire grâce au jeu de données que le prix sera de l’ordre de 115 000 €. (Vous l’aurez deviné, ces prix de l’immobilier ne correspondent pas à ceux pratiqués sur Paris…)

Il est possible de définir plus de deux critères (la surface et le prix) ; ce qui conduit à faire évoluer le graphique ci-dessus vers un graphique multidimensionnel. Le graphique ci-dessus modélise un problème connu sous le nom de problème de régression (faisant référence au modèle de régression linéaire en statistique).

Apprentissage non-supervisé

Comme son nom l’indique, il est l’opposé du premier. Dans le premier, l’apprentissage s’effectue de manière subjective c’est-à-dire qu’une personne décrit au préalable quels critères existent dans son jeu de données à analyser et classer. Dans cet apprentissage ci, l’algorithme ne possède pas d’étiquette : il est autodidacte. Il va procéder par regroupement en cherchant les données similaires. Il est très intéressant d’utiliser cette technique lorsque vous ne savez pas ce que vous cherchez. Typiquement quand vous voulez faire éclore quelque chose qui ne vous viendrait pas à l’esprit. Ce type d’apprentissage est aussi appelé « clustering », qui signifie « groupement ».

Pour l’exemple, on l’utilise dans un traitement d’image particulier, qui sélectionne les pixels similaires et en déduit qu’ils sont liés à un objet précis. Une reconstitution 3D à partir d’une photo peut être réalisée ensuite par ce biais (on appelle ce domaine la « Computer Vision »).

Dans l’illustration ci-dessous, un algorithme de clustering a permis de regrouper les pixels par région et d’en séparer les différents composants. D’autres algorithmes sont ensuite utilisés pour recréer une projection en trois dimensions.

Une des bibliothèques couramment utilisée dans ce domaine (à savoir le computer vision) est OPenCV (Open Source Computer Vision) disponible sur la forge GitHub. (Un tutoriel est disponible ici pour une utilisation avec Visual Studio 2012).

Apprentissage par renforcement

Dans le cas présent, l’algorithme apprend de l’environnement dans lequel il évolue. Ce type d’apprentissage tente de concevoir une stratégie la plus optimisée possible. Le système fonctionne avec des récompenses que renvoie l’environnement à celui-ci. Ces récompenses peuvent être encourageantes, ou punitives.

Un autre exemple que donne le professeur Andrew Ng dans son cours Machine Learning (CS 229) est le dressage d’un chien. Lorsque notre chien est en phase de dressage, nous allons lui apprendre ce que nous voulons de lui quand nous lui disons « couché ! ». S’il ne le fait pas correctement, on lui dit « mauvais chien », s’il le fait correctement c’est un « bon chien ». ;)

Le principe de fonctionnement pour l’algorithme de type renforcement est le même que pour le chien. Il va donc s’améliorer au fur et à mesure que l’environnement lui donne des récompenses.

Domaines d’application

L’apprentissage automatique est très utilisé, beaucoup plus qu’on ne le croit de prime abord :

Par exemple avec l’utilisation de notre mobile favori pour taper du texte, les suggestions de mots sont produites par des algorithmes utilisant principalement des chaines de Markov avec un graphe de type N-Gramme.
La reconnaissance manuscrite utilise un algorithme de reconnaissance de forme et un processus Markovien pour la reconnaissance de langage naturel. Les deux algorithmes combinés contribuent à améliorent fortement les performances et l’efficacité.
La reconnaissance vocale, en particulier l’isolation de la voix par rapport à un environnement bruyant, utilise un algorithme d’apprentissage non-supervisé constitué de réseaux neuronaux (un modèle conçu à la manière d’un cerveau humain).

Ce ne n’est qu’un rapide aperçu de ce qui existe déjà grâce au domaine de l’apprentissage automatique. Toutes ces fonctions se trouvent maintenant dans nos téléphones intelligents (smartphone).

Mais aujourd’hui, avec des architectures de type Big Data, un nouvel horizon s’ouvre au « Machine Learning » comme cela a été évoqué lors de l’édition 2013 des Microsoft TechDays : Bienvenue dans l'océan numérique (KEY203).

Le « Machine Learning » constitue donc une vraie révolution dans le logiciel : probabilités et statistiques sur les masses de données permettent au logiciel « d’apprendre » et non seulement calculer. Nouvelle frontière, nouvelle façon de penser le logiciel et de le programmer, c’est une révolution qui replace la « Big Science » au cœur de l’innovation. Nous aurons très prochainement l’occasion de revenir sur la conférence Microsoft Research Machine Learning Summit .

Big Data et « Machine Learning »

Avec l’arrivée de Hadoop, nous l’avons vu à l’occasion de précédents billets, fidèles lectrices et lecteurs de ce blog, un écosystème de Frameworks en sus s’est rapidement constitué. Et donc rapidement, l’apprentissage automatique a fait son apparition dans cet écosystème comme la puissance offerte par Hadoop crée une opportunité au domaine sans précédent.

En effet, les algorithmes de « Machine Learning » et d’intelligence artificielle en général sont bien souvent très gourmands en ressources de calcul et prennent dès lors beaucoup de temps à s’exécuter. Néanmoins des optimisations sont régulièrement apportées sur ces algorithmes, mais elles sacrifient la précision contre le temps.

Apache Mahout est la réponse à la question (celle que vous vous êtes posée intérieurement). C’est un projet Apache, comme Hadoop, à ceci près qu’il n’est pas encore en version finale. Le projet consiste en un entrepôt d’algorithmes d’apprentissage automatique, tous portés afin de s’exécuter sur Map/Reduce. Une vingtaine d’algorithmes sont déjà portés sur le paradigme ; ce qui suffit pour la très grande majorité des problèmes.

En voici quelques-uns.

Pour ce qui est du contexte d’apprentissage supervisé :

Régression logistique (SGV). Son domaine de prédilection est celui de la prédiction de probabilité d’apparition d’évènements comme par exemple dans le domaine de la fraude bancaire ou encore dans celui de la publicité pour le ciblage de clients fidélisables.
Classification Bayésienne. Une utilisation courante de notre boîte aux lettres électronique nous amène à utiliser un programme basé sur cet algorithme. Les filtres de spam sont en fait des règles de classification qui servent à l’algorithme bayésien contenu dans l’agent anti-spam pour séparer les « bons courriels des mauvais ».
Machine à vecteurs de support (SVM). Il s’agit d’un ensemble de techniques destinées à résoudre des problèmes de discrimination (prédiction d’appartenance à des groupes prédéfinis)et de régression (analyse de la relation d’une variable par rapport à d’autres).
Réseau neuronaux. A l’inverse des algorithmes de déduction, ce dernier est un algorithme de type induction c’est-à-dire que, par le biais d’observations limitées, il essaie de tirer des généralisations plausibles. C’est un système basé sur l’expérience : il se constitue une mémoire lors de sa phase d’apprentissage (qui peut être aussi non-supervisée) que l’on appelle entrainement.
Forêts d’arbres décisionnels (Random Forest). C’est une application de graphe en arbres de décision permettant ainsi la modélisation de chaque résultat sur une branche en fonction de choix précédents. On prend ensuite la meilleure décision en fonction des résultats qui suivront. On peut considérer cela comme une forme d’anticipation.
Le Boosting. Il s’agit d’une méthode de classification émettant des hypothèses qui sont au départ de moindre importance. Plus une hypothèse est vérifiée, et plus son indice de confiance augmente et donc elle prend plus d’importance dans la classification.

Et pour le contexte d’apprentissage non-supervisé :

K-moyennes (KMeans). KMeans est un algorithme de partitionnement des données en K nombre de groupes. Il est utilisé notamment dans la bibliothèque OpenCV précédemment mentionnée vis-à-vis du domaine de la « computer vision ». Dans Mahout, on l’utilise typiquement afin de déterminer quelle suggestion peut être faite à un utilisateur en fonction des préférences que d’autres utilisateurs similaires ont eues (utilisateurs du même groupe).
Fuzzy KMeans. Il s’agit d’une variante du précédent algorithme proposant qu’un objet ne soit associé qu’à un seul groupe.
Espérance-Maximisation (EM). Comme on peut le deviner, cet algorithme utilise des probabilités pour décrire qu’un objet appartient à un groupe. Le centre du groupe est ensuite recalculé par rapport à la moyenne des probabilités de chaque objet du groupe.
Regroupement hiérarchique. Deux sous-algorithmes en découlent, à savoir d’une part le « bottom up » qui a pour fonction d’agglomérer des groupes similaires, donc en réduire le nombre (plus lisible) et d’en proposer un ordre hiérarchique, et d’autre part, le « top down » qui fait le résonnement inverse en divisant le premier groupe récursivement en sous-ensembles.

Nous présentons ici les principaux algorithmes rapidement dans la mesure où ce billet a simplement vocation à introduire le sujet. Nous aurons l’occasion d’y revenir à l’occasion de prochains billet. Ceci étant, dans l’intervalle, rien ne vous empêche d’aller plus loin dans vos recherches. Nous ne serions d’ailleurs que vous encourager à le faire. Il est en effet nécessaire de regarder dans le détail les algorithmes proposés par Mahout ainsi que leurs implémentations, et ce, afin d’utiliser au mieux ceux-ci dans votre application.

Pour aller plus loin

Nous espérons vous avoir intéressé avec cette introduction qui touche un large panel de domaines scientifiques ou d’autres domaines d’ailleurs. Comme nous l’avons suggéré, nous prévoyons un prochain billet sur l’application d’un algorithme de « Machine Learning », Soyez patient.

En attendant voici quelques ressources. Pour commencer, mentionnons le site officiel du projet Mahout sur lequel vous trouverez la liste complète des algorithmes proposés aujourd’hui dans ce contexte.

Vous pouvez aussi suivre le cours Machine Learning (CS 229) du professeur Andrew Ng de l’université de Stanford (le premier module du cours commence réellement à la 32^ème minute).

Pour les plus impatients, Microsoft Research a élaboré un prototype (les données d’entrainements et les sources se trouvent sur GitHub) d’application basé sur le jeu de données 1 million song réunissant les musiques préférées d’un million d’utilisateurs. Vous retrouvez les travaux, projets et publications de Microsoft Research sur le « Machine Learning » ici.

Enfin, comme un certain nombre de billets ont été récemment consacrés à HDInsight, nous vous invitons à consulter le tutoriel de l’équipe HDInsight qui propose de créer un moteur de recommandations avec Mahout et le jeu de données 1 million song précédent.

S’agit-il de bonnes recommandations ? Vous nous le direz ;)

Bienvenue dans la version préliminaire de Windows Azure HDInsight

Philippe Beraud - MSFT — Tue, 26 Mar 2013 09:57:29 GMT

Ce billet est co-publié avec Benjamin Guinebertière qui consacre également ce mois-ci un billet à Windows Azure HDInsight sur le blog MSDN Windows Azure France suite à la disponibilité de ce service en version préliminaire (Public Preview) sur le portail de gestion de Windows Azure. Nos deux billets sont complémentaires :)

Windows Azure HDInsight se veut avec les facultés propres à l’environnement Windows Azure le moyen le plus simple de déployer, de gérer et faire passer à l’échelle des solutions basées sur Hadoop.

Une première vue d’ensemble

Fidèles lectrices ou lecteurs de ce blog, comme vous le savez, Windows Azure HDInsight a été développé en partenariat avec le développeur logiciel et distributeur Hadoop Hortonworks.

Il s’appuie sur Hortonworks Data Platform (HDP) 1.1.0 pour mettre à disposition les services Hadoop dans le nuage, et en particulier :

Apache Hadoop (en version 1.0.3),
Apache Hive (en version 0.9.0),
Apache Pig (en version 0.9.3),
Apache Sqoop (en version 1.4.3),
Apache Oozie (en version 3.2.0),
Apache HCatalog (en version 0.4.1),
Apache Templeton (également référencé sous l’appellation WebHCat)) (en version 0.1.4).

Vous pouvez consulter l’article What version of Hadoop is in Windows Azure HDInsight? pour plus de détails.

Tous ces services et outils fonctionnent « en l'état » comme attendu ; cela signifie que les investissements et les connaissances dans l'un de ces services et outils sont directement opérationnels sous HDInsight et ce tels quels. En outre, d'autres projets dans l'écosystème Hadoop tels que Mahout (Cf. cet exemple) peuvent facilement être utilisés au-dessus d’HDInsight.

Au-delà de ces composantes, Windows Azure HDInsight apporte un ensemble d’éléments additionnels comme :

Des mises à jour Hadoop qui assurent les dernières versions stables de HDFS (Hadoop Distributed File System) et Map/Reduce, Pig, Hive, Sqoop, etc. ;
Windows Azure Vault (ASV) comme système de fichier par défaut. (HDFS est toujours disponible) ;
Un pilote HIVE ODBC;
Un SDK pour écrire des « jobs » Hadoop en utilisant le Framework .NET et l’IDE Visual Studio ;
Etc.

Nous reviendrons sur ces apports dans la suite de ce billet.

Comme indiqué dans le billet Gartner BI Summit 2013: Bringing Hadoop to the Enterprise et reporté également par Hortonworks, la communauté Hadoop a voté pour passer Hadoop sur Windows dans le tronc principal (main trunc) d'Apache Hadoop. Les équipes d'ingénieurs de Microsoft et d’Hortonworks en collaboration avec la communauté Hadoop ont proposé un certain nombre d'améliorations vis-à-vis des environnements de développement et d’exécution d’Hadoop sur Windows Azure (et Windows Server), améliorations qui sont fusionnées dans le tronc Apache. Toutes ces améliorations sont également incorporées dans Windows Azure HDInsight (et HDInsight Server ainsi d’HDP pour Windows d’Hortonworks).

Le déplacement d’Hadoop sur Windows pour le tronc principal Apache Hadoop et l’investissement continu de Microsoft dans le projet Hadoop sont autant d’éléments qui contribuent à assurer que le choix d’HDInsight par les clients peut se faire en toute confiance, en sachant qu'HDInsight est 100% compatible avec Apache Hadoop, aujourd’hui et dans l'avenir.

HDInsight simplifie également Hadoop en permettant aux clients de déployer des clusters en quelques minutes au lieu de plusieurs heures ou jours. Ces clusters sont dimensionnés avec le nombre de nœuds voulus et s'intègrent avec des outils et des APIs Web simples de façon à assurer que les clients puissent facilement déployer, surveiller et arrêter leur cluster dans le Cloud. En outre, Windows Azure HDInsight s'intègre aux outils de BI (Business Intelligence) de Microsoft, pour permettre aux clients de facilement analyser et interpréter leurs données et recueillir ainsi des informations précieuses pour leur organisation. La présence, par exemple d’un pilote HIVE ODBC permet de coupler Excel avec une source de données HDFS ! Vous êtes ensuite dans Excel que vous connaissez avec ses tableaux croisés dynamiques, ses formules, etc. il convient aussi de citer l’extension Data Explorer à laquelle nous consacrerons prochainement un billet. Vous pouvez vous faire une première idée avec le billet Mashups and visualizations over Big Data and Azure HDInsight using Data Explorer.

Bien commencer avec Windows Azure HDInsight

Si vous disposez d’un compte Windows Azure – si tel n’est pas d’ores et déjà le cas, vous allez pouvoir y remédier dans la suite de ce billet - vous pouvez demander un accès à la version préliminaire publique d’HDInsight et créer alors un cluster HDInsight au sein du portail de gestion de Windows Azure.

La version préliminaire publique de Windows Azure HDInsight est un programme destiné à ce que tout un chacun puisse tester et se familiariser avec le service. Avec cette bêta publique, vous pouvez désormais avoir accès à un cluster qui, contrairement à celui que vous avez pu expérimenter avec Windows Azure HDInsight Service Preview :

N’expire pas tant qu’on ne le supprime pas explicitement (vs. 5 jours),
Peut avoir jusqu’à 40 nœuds de calcul (data node) (vs. 3 nœuds) de 4 cœurs (vs 2. cœurs).

Ce cluster dispose toujours d’un nœud principal (head node) de 8 cœurs.

Comme vous le verrez, l’un des avantages du service réside dans le fait, que via le portail, les données qui doivent être analysées par le cluster ainsi constitué à la demande peuvent provenir soit du cluster lui-même (comme vous pouvez vous y attendre), soit d’ailleurs, comme par exemple, d’un autre compte Windows Azure (si vous en avez des données sur des « blob storages » Windows Azure) ou bien être le résultat d’un transfert sur le cluster par FTP. Le service s’occupe ensuite de placer vos données pour que ces dernières puissent être prises en compte par le cluster.

La version préliminaire publique permet à l’équipe de développement de collecter vos retours utilisateurs et d’isoler et corriger des bogues non encore identifiées. En retour, Microsoft propose un rabais de 50% sur le coût des machines virtuelles (instances de worker roles) sous-jacentes pour cette période préliminaire.

Il est temps à présent de créer votre cluster.

Obtenir un passe pour accéder à la version préliminaire

De façon à accéder à la version préliminaire publique de Windows Azure HDInsight depuis le portail de gestion Windows Azure, il est avant toute chose nécessaire de disposer d’un compte Windows Azure.

Si tel n’est pas le cas, deux solutions s’offrent à vous si vous ne disposez pas d’ores et déjà d’un compte Windows Azure:

Vous avez la possibilité de souscrire à un compte payant, à vous ensuite de gérer votre abonnement et les frais associés. Plus d’informations sur le sujet, vous pouvez consulter les détails de la facturation;
Vous pouvez créer un compte de test en profitant de l’offre 90 jours. Attention cependant, le déploiement de Windows Azure HDInsight sur cette offre peut conduire à consommer les ressources incluses assez rapidement. Plus d’informations sur le sujet, vous pouvez consulter le détail de la facturation à la section HDInsight (version préliminaire). Le billet [TUTO] : Comment souscrire gratuitement à Windows Azure ? sur le blog MSDN Windows Azure France propose un pas à pas détaillé pour la création d’un compte de test. Vous pouvez le consulter à cet effet si besoin pour une vue d’ensemble.

Avant de commencer, vous pouvez vérifier si votre compte a déjà accès à la fonctionnalité HDInsight en cliquant sur NOUVEAU en bas à gauche dans le portail de gestion Windows Azure (https://manage.windowsazure.com).

Si la fonctionnalité est marquée comme non disponible, il est nécessaire de vous inscrire à la fonctionnalité :

Cliquez sur preview program.

Cliquez sur try it now dans la section «Azure HDInsight Preview.

Sélectionnez votre type d’abonnement Windows Azure (ici une évaluation gratuite de 3 mois).

Validez la demande. Après cela, il convient d’attendre un courriel d’acceptation de votre « candidature ». Attention toutefois ce courriel peut mettre un certain temps à venir (pour ma part j’ai attendu 4 jours). Les demandes sont validées généralement le mercredi et le week-end donc prenez votre mal en patience ;)

Une fois le courriel reçu, connectez vous à votre compte Azure et rendez-vous sur le portail de gestion de Windows Azure pour créer votre premier cluster. Voyons comment cela se traduit dans la pratique.

Créer un compte de stockage

Rendez-vous sur le portail de gestion de Windows Azure pour créer votre premier cluster.

Un compte de stockage est nécessaire à la création d’un cluster HDInsight car c’est l’un des systèmes de stockage de données disponibles comme abordé précédemment, l’autre étant bien sûr HDFS. HDInsight appelle ce système de fichier ASV (Azure Storage Vault).

Pourquoi deux systèmes de fichiers ? Commençons par le plus connu dans le monde Hadoop. HDFS permet d’exécuter des programmes Map/Reduce conçus pour Hadoop d’une façon générale (et ce indépendamment de la plateforme Azure). Dans la pratique, les données sur HDFS sont stockées sur des disques locaux des nœuds de calcul (data node).

ASV permet aussi d’exécuter des programmes Map/Reduce, mais cette fois sur des données stockées dans le compte de stockage précédent dans des « blobs » Windows Azure. Les performances sont équivalentes; elles peuvent d’ailleurs être meilleures avec ASV. Cela contourne notamment la nécessité de charger des données sur le système HDFS au préalable du traitement.

Au final, la principale différence réside essentiellement dans le fait que les données dans ASV survivent à l’arrêt du cluster HDInsight ; ce qui n’est pas le cas des données HDFS (puisqu’elles sont sur les disques des machines virtuelles (VM) que l’on supprime en arrêtant le cluster). Par ailleurs, certains projets comme l’extension Data Explorer pour Excel - dont nous aurons l’occasion de reparler prochainement - utilisent le système ASV pour récupérer des résultats d’analyses faites sur HDInsight. Nous aurons l’occasion de parler du Data Explorer dans un prochain billet.

Pour revenir à ce compte de stockage pour ASV, il est nécessaire de le créer aujourd’hui dans le centre de données de l’Est des Etats-Unis, comme la version préliminaire publique est disponible uniquement dans ce centre de données pour l’instant.

Pour cela, cliquez sur NOUVEAU et sélectionnez SERVICES DE DONNEES, STOCKAGE, et CREATION RAPIDE.

Précisez un nom (« donnee2 » dans l’illustration précédente) et cliquez sur CREER UN COMPTE DE STOCKAGE pour valider.

Créer un cluster HDInsight

Passons à la création du cluster en tant que telle. Celle-ci s’effectue comme suit. Cliquez sur l’icône HDINSIGHT sur la partie gauche du portail.

Cliquez sur NOUVEAU puis sélectionnez SERVICES DE DONNEES, HDINSIGHT, et QUICK CREATE.

Vous devez préciser un nom pour votre cluster (CLUSTER NAME). Vous devez sélectionner une taille (CLUSTER SIZE) ; La valeur par défaut est 4 (nœuds de calcul) mais 8, 16 et 32 sont aussi disponibles. (Pour choisir plus finement le nombre de nœuds, il faut choisir CUSTOM CREATE au lieu de QUICK CREATE).

Il convient de noter noter que seulement la version 4 sera gratuite. Il est enfin nécessaire de préciser un mot de passe (PASSWORD) pour le cluster. (Le nom d’utilisateur par défaut est par défaut est admin.) Ces informations d’identification vous seront demandées pour accéder au portail Web.

Vous devez enfin sélectionner le compte de stockage précédemment créé (STORAGE ACCOUNT).

Cliquez sur CREATE HDINSIGHT CLUSTER pour valider. Ceci déclenche la création du cluster ; ce qui nécessite quelques minutes.

Une fois le cluster prêt, une notification s’affiche dans la barre du bas. De plus, le statut du cluster passe à Running.

Découvrir le cluster

Toujours depuis le portail de gestion Windows Azure, dans la rubrique HDInsight, vous pouvez voir le cluster activé, en cours d’utilisation.

Pour accéder au Dashboard de votre cluster et commencer à l’utilisation. Cliquez simplement dessus.

Une fois dans la page DASHBOARD, cliquez sur le lien présent dans la section Go To Cluster ou bien sur MANAGE dans la barre du bas.

Une nouvelle page d’authentification apparaît, précisez avec vos informations d’authentification spécifiées lors de la création du cluster (« admin » et votre mot de passe).

Vous accédez alors au portail de votre cluster, ici elephantjaune.azurehdinsight.net.

Le portail comporte deux sections principales groupant différents liens (représentés par icones).

Une première section Your Cluster vous permet par le biais de plusieurs méthodes d’interagir et de gérer votre cluster : Interactive Console pour une console pour JavaScript et pour Hive, Remote Desktop pour un accès distant direct au cluster, Job History pour l’historique des « jobs » lancés, Samples pour des exemples « clef-en-main » et prêts à s’exécuter sur Windows Azure HDInsight à l’image du pilote ODBC et l’extension Hive pour Excel) etc.

Il convient d’apporter une petite précision sur Remote Desktop : celui-ci vous amènera sur le nœud principal (head node) du cluster Hadoop. C’est sur celui-ci que sont installés les différents modules complémentaires et que vous pouvez utiliser (via ligne de commande) Hadoop.

La seconde section intitulée Your Tasks vous permet de créer des nouveaux « jobs » et de tracer ceux que vous avez déjà créés ou lancés pour cette session.

Il est temps de s’intéresser à la programmation et aux possibilités apportées par Windows Azure HDInsight en la matière.

Créer des « jobs » avec Windows Azure HDInsight

Comme indiqué en introduction de ce billet, Windows Azure HDInsight s’appuie sur HDP 1.1.0 et propose de fait un degré élevé de fidélité avec l’écosystème Hadoop. En tant que telles, de nombreuses capacités « en l'état » comme attendu.

Un cluster HDInsight est créé avec les projets Apache suivant pour le traitement distribué :

Map/Reduce : Map/Reduce constitue en soi une fondation pour le traitement distribué dans Hadoop. On peut écrire un programme en Java ou tirer parti pour cela d'autres langages et environnements d'exécution grâce à l'utilisation d'Hadoop Streaming. L’article Using MapReduce with HDInsight propose un guide simple pour l’écriture de programmes optimisés sur HDInsight.
Hive : Hive est un logiciel d'analyse de données permettant d'utiliser Hadoop avec une syntaxe proche du SQL appelé HiveQL et ce, via un mécanisme permettant de projeter une structure sur ces données. Ceci permet d’exprimer des requêtes qui se compilent en un ensemble de programmes Map/Reduce optimisés. Dans la pratique, Hive propose un support pour la plupart des constructions auxquelles on peut s’attendre dans SQL (agrégation, regroupements, filtrage, etc.), et se parallélise facilement à travers les nœuds de votre cluster. L’article Using Hive with HDInsight vous propose un premier niveau de guide pour utiliser Hive. Vous pouvez également consulter le tutoriel complet Analyzing Twitter Movie Data with Hive in Hadoop on Azure utilisant les données de Twitter.
Pig : Pig est une plateforme d'analyse de données comparable à Hive, mais qui utilise un langage de description de flux d’instructions sur les données qui se compile en un ensemble de programmes Map/Reduce à l’aide d’un langage appelé Pig Latin. L’article Using Pig with HDInsight propose un guide de démarrage pour Pig avec HDInsight.
Oozie : Oozie est un ordonnanceur de flux de travail (workflow) pour la gestion d'un graphe acyclique dirigé d’actions, où des actions peuvent être des « jobs » Map/Reduce, Pig, Hive ou d'autres « jobs ». Vous trouverez plus de détails dans le guide de démarrage ici.

Le billet de Benjamin Guinebertière offre un tutoriel sur HDInsight pour l’exécution de programmes Map/Reduce, Pig et Hive. Vous pouvez consulter également l’article A Lap Around HDInsight sur HDInsight parcourant les sujets de Map/Reduce, Pig et Hive.

HDInsight propose également un certain nombre de compléments propre pour la programmation.

Microsoft .NET SDK For Hadoop

Les équipes Microsoft en charge d’HDInsight travaillent sur la construction un portefeuille d'outils qui permettent aux développeurs de tirer parti de leurs compétences et des investissements en .NET pour utiliser Hadoop. Ces projets sont hébergés sur la forge CodePlex, avec des paquets disponibles à partir de NuGet pour créer des programmes fonctionnant sur HDInsight.

Les outils/bibliothèques suivants sont aujourd’hui notamment disponibles sur la forge sous forme d’un paquet NuGet :

.NET Map/Reduce : .NET Map/Reduce est un « wrapper » .NET de la bibliothèque Java Hadoop Common pour écrire un programme Map/Reduce.
LINQ to Hive : LINQ to Hive permet d’utiliser des requêtes LINQ sur des données gérées par Hive installé (par défaut) sur votre cluster HDInsight. Il est ainsi possible par exemple de créer une base de données Hive sur votre cluster HDInsight, puis, développer une application cliente sur votre machine personnelle qui requête cette base Hive avec LINQ.
WebHDFS Client : WebHDFS Client est une abstraction .NET du système de fichiers HDFS d’Hadoop. Il permet ni plus ni moins de créer, de lire, ou de supprimer des fichiers contenu sur votre cluster Hadoop programmatiquement parlant. Il utilise pour cela le service REST WebHDFS du cluster HDInsight.

Pilote HIVE ODBC

Le pilote HIVE ODBC disponible dans la rubrique Downloads du portail de gestion de votre cluster HDInsight permet de faire la connexion entre une table Hive et Excel (ou tout autre client ODBC).

L’article How to Connect Excel to Windows Azure HDInsight via HiveODBC vous propose un pas à pas complet.

Pour aller plus loin avec Windows Azure HDInsight

Nous en avons bien conscience, ce billet ne fait qu’effleurer le champ des possibles et il existe beaucoup d’autres fonctionnalités à découvrir dans Windows Azure HDInsight. Ainsi, par exemple, si l’installation depuis le portail d’un cluster HDInsight a été abordée, il est tout à fait possible de réaliser le même type d’opération par API. Un tel déploiement de cluster est décrit dans l’article Deploying an HDInsight Service Cluster Programmatically.

Toujours dans le registre de l’automatisation, l’automatisation de l’exécution des jobs cette fois peut s’effectuer via WebHCat (également référencé sous l’appellation Templeton) comme documenté dans l’article Executing Remote Jobs on Your HDInsight Cluster Programmatically.

Les consoles interactives en JavaScript et Hive permettent une connexion au cluster via une interface Web comme décrit avec l’article HDInsight Service Interactive JavaScript and Hive Consoles.

Tout cela représente autant de pistes d’exploration pour faire le meilleur usage du service Windows Azure HDInsight. Ceci étant, au-delà des éléments apportés par ce billet ou par celui de Benjamin, vous pouvez également vous reporter :

Au blog MSDN Windows Azure, qui consacre une série de 5 billets à ce service Windows Azure HDInsight : Getting Started with HDInsight, Azure HDInsight and Azure Storage, Developing for HDInsight, etc.
A la documentation HDInsight sur le site Windows Azure.

Comme le titre ce billet, bienvenue dans la version préliminaire de Windows Azure HDInsight et bonne découverte !

Démarrez avec HDInsight Server !

Philippe Beraud - MSFT — Tue, 26 Mar 2013 09:11:26 GMT

Les billets Installation d'HDInsight Server (Hadoop) sur une machine Windows et Créer une machine virtuelle HDInsight Server sur Windows Azure disponibles sur ce blog vous ont accompagné quant à la mise en place d’un cluster de test HDInsight Server de façon à disposer rapidement de services Hadoop opérationnels en environnement Windows.

Quelle que soit l’approche que vous ayez retenue au final, nous supposons dans ce billet que vous disposez à ce stade d’une installation opérationnelle d’HDInsight Server.

Une rapide présentation

Rendez-vous dans le dossier C:\Hadoop. C’est ici que tout a été installé.

Comme vous pouvez le constater, ce dossier racine contient un ensemble de dossiers :

Avec un premier lieu, un dossier GettingStarted auquel nous allons nous intéresser très prochainement ;
Un dossier hadoop-1.1.0-SNAPSHOT correspondant au dossier système d’Hadoop dans l’implémentation Hortonworks Data Platform (HDP) 1.1.0 pour Windows Server d’Hortonworks ;
Un dossier HDFS où seront stockées les données sur ce nœud (mais nous n’avons qu’un nœud ici…) ;
Les dossiers Hive-0.9.0, pig-0.9.3-SNAPSHOT et sqoop-1.4.2 qui contiennent respectivement les projets/surcouches Apache Hive (en version 0.9.0), Apache Pig (en version 0.9.3), Apache Sqoop (en version 1.4.2). Hive est un logiciel d'analyse de données permettant d'utiliser Hadoop avec une syntaxe proche du SQL appelé HiveQL et ce, via un mécanisme permettant de projeter une structure sur ces données. Pig est une plateforme d'analyse de données comparable à Hive, mais qui utilise le langage Pig Latin. Enfin, Sqoop est un outil conçu pour l'importation et l'exportation de données à partir de magasins de données structurées telles que des bases de données relationnelles, des entrepôts de données d'entreprise et des systèmes NoSQL ;
Un dossier java où la machine virtuelle Java (JVM) est installée ;
Un dossier websites intéressant à certains égards pour nous faciliter la vie au quotidien avec, par exemple, la console JavaScript ou encore l’interface de gestion du cluster, etc.

Ce dossier racine contient enfin les deux scripts start-onebox et stop-onebox pour respectivement démarrer et arrêter le service Hadoop. Dans notre cas de figure, il est déjà démarré.

Naviguez à présent dans le dossier GettingStarted (C:\Hadoop\GettingStarted). Ce dernier contient trois scripts Windows PowerShell :

buildSamples.ps1 pour compiler les codes source si vous faites des modifications.
importData.ps1 pour importer depuis un serveur IIS ses fichiers journaux (log) au format W3C Logging.
runSamples.ps1 pour lancer les programmes en C# ou en Java, etc. sur le jeu de données importé auparavant.

Sélectionnez le fichier importData.ps1, faites un clic droit, puis sélectionnez Exécuter avec PowerShell pour le lancer. Trois fichiers appelés data_w3c_small.txt, data_w3c_medium.txt, et data_w3c_large.txt sont alors produits.

Le script insère ensuite directement les fichiers générés dans HDFS. Pour le vérifier, lancez le Hadoop Command Line (icone sur le bureau) puis tapez la ligne suivante :

hadoop dfs –ls /w3c/input

Une rapide explication s’impose : hadoop fait appel à l’application, dfs spécifie que nous voulons accéder au système de fichiers, -ls est un argument qui précise de lister les éléments trouvés (comme sous Unix), et /w3c/input/ correspond au chemin du dossier.

Vous devriez voir trois dossiers comme ceci :

Le répertoire small contient le fichier data_w3c_small.txt, et ainsi de suite.

Intéressons-nous à présent au script runSamples.ps1. Ce dernier prend 4 arguments :

scenario : vous n’en avez qu’un à considérer ici : en l’occurrence « w3c ».
size : « small », « medium » ou « large ». Cela correspond au volume de données que vous voulez analyser. Plus il sera petit, plus l’analyse sera rapide (avec toutefois un temps non compressible lié à la soumission du job lui-même).
method : « csharp », « java », « pig », ou « hive ». Cela correspond aux deux différentes implémentations du programme, l’une est en Java (dans le dossier du même nom) et l’autre en C#. Vous pouvez d’ailleurs y « jeter un œil » au passage. Pig et Hive présentent simplement un cas d’utilisation dans les deux langages.
job : « totalhits », « avgtime » ou « errors ». Ce sont vos cas de test. Le premier calcule sur les données le nombre total de vues pour chaque page ; il en ressort une liste. Le deuxième exprime la durée moyenne qu’un utilisateur passe sur une page ; de façon similaire, il en ressort la liste des pages avec le temps passé dessus. Le troisième indique combien d’erreurs sont affichées sur le nombre de visionnages ; cela permet de savoir quelle page pose le plus de problèmes aux visiteurs.

Ces précisions faites, il vous suffit de lancer runSamples dans la console Windows PowerShell depuis le répertoire GettingStarted :

cd c:/hadoop/GettingStarted/)
powershell –ExecutionPolicy unrestricted –F runSamples.ps1 w3c small java avgtime

La commande powershell permet d’exécuter tout simplement des scripts Windows PowerShell : l’argument -ExecutionPolicy est nécessaire pour exécuter sans erreur le script, l’argument -F spécifie l’emplacement et le nom du script. Les quatre mots suivants sont les arguments injectés dans le script PowerShell et correspondent dans l’ordre aux arguments scenario, size, method, et job vus ci-avant.

Votre job est lancé : vous allez voir apparaître le pourcentage d’avancement des deux étapes « map » et « reduce ». A la fin du traitement, l’affichage de la console permet de faire ressortir le top 3 des pages avec un temps moyen le plus élevé.

Cette rapide introduction étant faite, intéressons-nous à votre première application.

Une première application « from scratch »

Pour votre première application, nous avons besoin d’une problématique à traiter : « Vous voulez savoir quels sont les types de browsers utilisés par les utilisateurs du site hébergé par votre serveur IIS ».

Pour ce faire, vous avez à disposition les fichiers journaux récupérés par l’exercice précédent. Examinons-les.

Ouvrez le fichier data_w3c_small sous C:\Hadoop\GettingStarted\w3c\ data_w3c_small.txt.

On constate que le fichier est constitué de 15 colonnes. Celle qui vous intéresse est l’avant dernière (la 14) : cs(User-Agent) :

Vous pouvez vous reporter au format W3C Logging des fichiers journaux d’IIS pour plus de détails ici. En bref, pour ce qui vous intéresse dans le cas présent compte tenu de l’objectif fixé, User-Agent correspond au type de browser. Vous aurez notamment d’indiqué le moteur HTML et le nom du navigateur ensuite.

L’exemple suivant indique que l’utilisateur possède Internet Explorer 10 avec le moteur de rendu HTML Trident (vous savez aussi que le navigateur est installé sur le système d’exploitation Windows 7) :

Mozilla/5.0+(compatible;+MSIE+10.0;+Windows+NT+6.1;+WOW64;+Trident/6.0)

L’article User Agent String explained vous donne toutes les informations nécessaires sur le browser correspondant à un User Agent donné.

Algorithme

Passons maintenant à l’algorithme Map/Reduce qui sera appliqué par Hadoop sur chacune de nos données.

Vous allez à présent écrire cette application en JavaScript via la console interactive proposée dans le portail de gestion Microsoft HDInsight Dashboard qui vous permettra de le faire simplement.

Il est en effet proposé aux utilisateurs d’HDInsight (que ça soit Windows Azure HDInsight ou HDInsight Server comme ici) d’écrire le code Map/Reduce en JavaScript. Vous noterez que ceci n’est pas proposé par défaut dans Apache Hadoop.

Une telle capacité permet de se concentrer uniquement sur les parties « importantes » de notre algorithme et masque les parties « superficielles » de Map/Reduce en Java comme les « imports » ou encore l’instanciation de types spécifiques.

Le code de démonstration est censé être clair… Vous nous le direz ;)

Ouvrez votre environnement de développement (IDE) préféré pour faire du JavaScript. C’est parti ! Si vous n’en avez pas, vous pouvez vous prendre Notepad++ comme dans la suite de ce billet pour les exemples d’illustration. Vous pouvez trouver télécharger une version ici.

A ce stade, vous vous êtes intéressés à la structure fichier journal et vous en avez retiré le numéro de colonne de UserAgent : la 14^ème.

Map

Le modèle de base pour la méthode map en JavaScript est la suivante ; A vous de la personnaliser.

var map = function(cle, valeur, context){

}

Vous y ajoutez ceci :

var parties = valeur.split(new RegExp("\\s"));

Vous éclatez ainsi la valeur qui vous est passée en paramètre dans un tableau parties via une expression régulière. L’élément de séparation des colonnes est \s ce qui correspond à un espace tout simplement. Pour une première initiation aux expressions régulières, vous pouvez par exemple vous reporter au tutoriel Les expressions régulières.

La suite :

if(parties.length != 15 || parties[13] == "-")

return;

Vous testez si le tableau « parties » ne contient pas 15 cases pour savoir si le « record » est bien formaté. Vous regardez ensuite si la case n°14 (c’est-à-dire la 13 en partant de 0) est égale au caractère "-", ce qui indiquerait l’absence de donnée. Si ces tests réussissent, alors le record est mal formé et vous ne pouvez pas récupérer de clé valide à insérer dans la Map. Donc vous passez au record suivant.

Cette ligne permet d’émettre le résultat de la méthode map sur le record courant.

context.write(p

arties[13], 1) ;

Voici le code complet :

var map = function(cle, valeur, context){

var parties = valeur.split(new RegExp("\\s"));

if(parties.length != 15 || parties[13] == "-")

return;

context.write(parties[13], 1);

}

Vous en avez fini avec cette méthode. Passons à l’implémentation de votre Reducer.

Reduce

Le modèle de base se définit comme ceci :

var reduce = function(cle, valeurs, context){

}

Il reçoit en paramètre la clé à laquelle corresponds plusieurs valeurs. Un objet context aussi permet d’émettre le résultat final.

var somme = 0 ;

C’est votre variable stockant la somme de toutes les valeurs.

while(valeurs.hastNext()){

somme += parseInt(valeurs.next());

}

Vous bouclez sur les valeurs pour additionner celles-ci dans la somme.

context.write(cle, somme);

Vous émettez la somme finale pour la clé correspondante.

Voici le code complet :

var map = function(cle, valeur, context){

var parties = valeur.split(new RegExp("\\s"));

if(parties.length != 15 || parties[13] == "-")

return;

context.write(parties[13], 1);

}

var reduce = function(cle, valeurs, context){

var somme = 0;

while(valeurs.hasNext()){

somme += parseInt(valeurs.next());

}

context.write(cle, somme);

}

Exécution

Vous en avez terminé pour ce qui est du code. Enregistrez ce fichier par exemple sous le nom navigateurs_detection.js à la racine du disque C :

Ensuite, sur le bureau de la machine virtuelle, exécutez le portail de gestion Microsoft HDInsight Dashboard en cliquant sur le raccourci éponyme.

Cliquez ensuite sur Interactive Console dans la section Your Cluster : http://localhost:8085/Cluster/InteractiveJS

Exécutez la procédure suivante : Tapez « #put » dans la console puis « Entrée ». Cette commande appelle en réalité le système de fichier HDFS pour y insérer un nouveau fichier. Avant d’exécuter du code avec Hadoop, il sera impératif de l’ajouter sur HDFS. Le # dans la console interactive précise que la commande suivant celui-ci est une commande générale d’Hadoop. Cette commande #put correspond à :

hadoop dfs –put c:/monfichier.ext /mondossierhdfs/monfichier.ext

Dans Source, cliquez sur Browse pour parcourir et recherchez le fichier JavaScript C:\navigateurs_dectection.js.

Dans Destination, précisez « ./navigateurs_detection.js », puis cliquez sur Upload

A ce stade, vous avez placé votre premier fichier sur HDFS en utilisant la console interactive.

Vous devez vous assurer que le dossier « /w3c/out » qui stockera le résultat n’existe pas, sinon lors de l’exécution du programme, vous rencontrerez une erreur comme suit : « … at org.apache.hadoop.util.RunJar.main(RunJar.java:…)… ».

En effet, le système HDFS stocke les données une et une seule fois, aucune mise à jour n’est possible ; le caractère immuable des données fait que la parallélisation est possible. Les fichiers que vous stockez sont pour cette raison au final en lecture seule. Si nécessaire, vous pouvez les supprimer au préalable via la commande Hadoop rmr. Entrez la ligne suivant dans la console JS :

#rmr /w3c/out

Exécutez ensuite notre code par le biais de la commande runJs :

runJs("navigateurs_detection.js", "/w3c/input/large", "w3c/out") ;

La fonction runJs prend comme premier paramètre le chemin d’accès du fichier JavaScript contenant les fonctions map() et reduce(). Le deuxième paramètre représente le chemin du répertoire des données à traiter. Vos fichiers journaux sont stockés dedans. Le troisième indique le chemin où sera stocké le résultat de votre traitement Map/Reduce sur les données d’entrée.

Une fois l’exécution terminée, un message apparait du type « INFO mapred.JobClient : Map output records=5656 ». Le loader, lui, disparaitra.

Visualisation du résultat

L’exécution de votre programme étant terminée, le résultat a été placé sous le répertoire /w3c/out. Certes, mais comment visualise-t-on le résultat de manière compréhensible ?

Vous pouvez visionner le résultat dans la console JavaScript:

fichier = fs.read("/w3c/out");

Nom du browser	User Agent (chaine identifiant le browser)	Décompte
Chrome 22	Mozilla/5.0+(Windows+NT+6.1;+WOW64)+AppleWebKit/537.1+(KHTML,+like+Gecko)+Chrome/22.0.1207.1+Safari/537.1	962
Internet Explorer 6	Mozilla/5.0(Windows; +U;+MSIE+6.0;+Windows+NT+5.1;+SV1;+.NET+CLR+2.0.50727)	1905
Firefox 14	Mozilla/5.0+(Windows;+U;+Windows+NT+6.1;+WOW64;+en-US;+rv:2.0.4)+Gecko/20120718+AskTbAVR-IDW/3.12.5.17700+Firefox/14.0.1	919
Firefox 14 pour Ubuntu	Mozilla/5.0+(X11;+Ubuntu;+Linux+x86_64;+rv:14.0)+Gecko/20100101+Firefox/14.0.1	919
Internet Explorer 10	Mozilla/5.0+(compatible;+MSIE+10.0;+Windows+NT+6.1;+WOW64;+Trident/6.0)	951

Graph

Il est possible, via la console JavaScript et l’objet graph, de générer des graphiques en fonction des données récupérées. Il faut cependant les préparer au préalable, et ce de façon à ce que graph connaisse le formatage de notre résultat.

Commencez par récupérer votre variable « fichier » remplie précédemment, puis parcourez-la à l’aide de la méthode parse :

resultat = parse(fichier.data, "userAgent,count:long");

La méthode parse dé-sérialise la chaine contenue dans fichier.data dans un tableau JavaScript (Array). Vous devez lui indiquer comment est formatée la chaine et quelles sont les colonnes avec leurs types (si le type est absent, string est mis par défaut) : userAgent et count.

Voici ce qui est affiché :

[

0: {

userAgent: "Mozilla/5.0+(Windows+NT+6.1;+WOW64)+AppleWebKit/537.1+(KHTML,+like+Gecko)+Chrome/22.0.1207.1+Safari/537.1"

}

1: {

userAgent: "Mozilla/5.0+(Windows;+U;+MSIE+6.0;+Windows+NT+5.1;+SV1;+.NET+CLR+2.0.50727)"

}

2: {

userAgent: "Mozilla/5.0+(Windows;+U;+Windows+NT+6.1;+WOW64;+en-US;+rv:2.0.4)+Gecko/20120718+AskTbAVR-IDW/3.12.5.17700+Firefox/14.0.1"

}

3: {

userAgent: "Mozilla/5.0+(X11;+Ubuntu;+Linux+x86_64;+rv:14.0)+Gecko/20100101+Firefox/14.0.1"

}

4: {

userAgent: "Mozilla/5.0+(compatible;+MSIE+10.0;+Windows+NT+6.1;+WOW64;+Trident/6.0)"

}

]

Comme vous l’aurez probablement reconnu, il s’agit d’une structure JSON (JavaScript Objet Notation), qui contient 5 éléments. Chaque élément possède deux attributs : userAgent et count.

Le fait que vous utilisiez JavaScript permet certaines facilités quant à la modification dynamique de cette structure. Vous allez donc en profiter et ajouter un 3^ème attribut, en l’occurence name, et ainsi donner un nom simplifié aux browsers.

D’après le tableau précédent, appliquez le code suivant dans la console :

resultat[0].name = "Chrome 22"; resultat[1].name = "Internet Explorer 6"; resultat[2].name = "Firefox 14"; resultat[3].name = "Firefox 14 Linux"; resultat[4].name = "Internet Explorer 10";

Vous avez ainsi modifié pour chacun des résultats la structure de l’élément en ajoutant un attribut name.

Construisez maintenant la structure pour paramétrer votre graphique. D’après la documentation, l’objet options se compose des éléments suivants :

options	(object) objet d’options, avec
x	(string) Indique quelle propriété est en abscisse
y	(string) Indique quelle propriété est en ordonnée
title	(string) Le titre du graphique
orientation	(number) Utile pour incliner les entêtes de colonne
tickInterval	(number) Pour décaler les entêtes de colonne

Tapez le code suivant :

options = {x :"name", y : "count", title: "Popularité des navigateurs sur le site"};

Vous êtes prêts à présent pour lancer la génération du graphique. Entrez la ligne suivante :

graph.pie(resultat, options);

Et voilà!

graph est le nom de l’objet JavaScript exposé par la console interactive. La fonction pie peut être remplacée par la fonction bar pour avoir un graphique de type histogramme. A vous de jouer à présent !

Pour cela, vous pouvez visionner la démonstration didactique réalisée par Benjamin Guinebertière lors des après-midi du développement, reprendre le tutoriel Using Interactive JavaScript for Data Visualization in Hadoop on Windows Azure Cluster, consulter le tutoriel Running Hadoop Jobs on Windows Azure, Importing Data from Windows Azure Marketplace, and Analysing the Data with the Excel Hive Add-In sur le lancement de jobs avec HDInsight, l’importation de données récupérées depuis Windows Azure Marketplace, ainsi qu’une analyse finale des données avec Excel, etc.

Ceci conclut notre billet. Bien sûr, vous pouvez suivre la même procédure de programme JavaScript sous Windows Azure HDInsight Service comme ce service propose la même console interactive. A ce propos, vous trouverez une documentation sur l’utilisation de la console interactive ici.

Créer une machine virtuelle HDInsight Server sur Windows Azure

Philippe Beraud - MSFT — Mon, 25 Mar 2013 18:20:13 GMT

Comme nous avons déjà eu l’occasion d’en parler ensemble, HDInsight a été développé en partenariat avec le développeur logiciel et distributeur Hadoop Hortonworks et s’appuie sur Hortonworks Data Platform pour mettre à disposition les services Hadoop, et en, particulier Apache Hadoop, Apache Hive, Apache Pig, Apache Sqoop, Apache Oozie, Apache HCatalog, et Apache Templeton.

Windows Azure HDInsight et HDInsight Server facilitent le déploiement et la configuration d’Hadoop sur la plateforme Windows (sans avoir de frein sur la création du cluster, le choix des composants à installer, etc.), donnent aux clients ainsi l'accès à une distribution d’Hadoop standard prête pour l'entreprise avec les dernières versions des composants mis à disposition, et permettent à ces derniers de démarrer tout de suite sur leurs données, de voir ce qu’il est possible d’en extraire avec Hadoop, et en complément de bénéficier de la richesse et la puissance de l’offre de BI (Business Intelligence) de Microsoft pour faire ressortir des pistes de réflexion actionnables des Big Data comme nous avons pu l’illustrer récemment. D’une façon générale, ces offres Hadoop et SQL Server sont très complémentaires.

Dans la pratique, Windows Azure HDInsight est un service pour l’hébergement de votre cluster Hadoop sur Windows Azure. Nous y reviendrons très prochainement avec la désormais disponibilité de la version préliminaire publique (Public Preview) de Windows Azure HDInsight directement dans le portail de gestion de Windows Azure. Si vous disposez d’un compte Windows Azure – si tel n’est pas d’ores et déjà le cas, vous allez pouvoir y remédier dans la suite de ce billet - vous pouvez demander un accès à la bêta publique et créer alors un cluster HDInsight au sein du portail de gestion de Windows Azure. Une fois votre compte configuré, chaque fois que vous avez besoin d’un cluster pour quelques heures ou quelques jours, il vous suffit de le demander quelques minutes avant dans le portail de gestion de Windows Azure. C’est aussi simple que cela !

HDInsight Server permet de créer son propre cluster Hadoop sur sa machine Windows comme illustré dans un précédent billet et ce, pour réaliser, par exemple, très rapidement des tests et cela permet de réaliser des tests très rapidement. Ce billet a été l’occasion de découvrir ensemble le portail de gestion Microsoft HDInsight Dashboard pour le cluster déployé alors sur seule instance (un seul nœud donc).

Vous pouvez aisément reproduire cette installation sur votre propre machine Windows mais à bien des égards, il peut s’avérer intéressant de la réaliser pour des fins de test sur une machine virtuelle et pour l’avoir toujours accessible pourquoi ne pas le faire dans Windows Azure (la plateforme PaaS et IaaS de Microsoft pour héberger vos machines virtuelles, créer des réseaux virtuels, et bénéficier de bien d’autres services) ? Cela nous procure un certain nombre d’avantages :

Un portail HTML5 très facile à utiliser,
Des images Windows 8, Windows Server 2008 R2, Windows Server 2012 prêtes à l’emploi,
Une installation rapide !
Une configuration complète pour l’utilisation,
Une offre 90 jours de tests gratuits !

Commençons par le commencement. Rendez-vous sur le site de Windows Azure pour vous créer compte de test en profitant de l’offre 90 jours. Le billet [TUTO] : Comment souscrire gratuitement à Windows Azure ? sur le blog MSDN Windows Azure France propose un pas à pas détaillé pour la création d’un compte de test. Vous pouvez le consulter à cet effet si besoin pour une vue d’ensemble.

Si vous disposez déjà d’un compte Windows Azure actif, vous pouvez passer directement à l’étape de création d’une machine dans le portail.

Naviguez vers http://www.windowsazure.com/fr-fr/pricing/free-trial/ et cliquez sur essayer-la gratuitement (en vert).

Vous êtes redirigé vers une page de connexion. Précisez votre compte Microsoft (anciennement Windows Live ID, une adresse email Hotmail, Outlook, MSN, etc.).

Ensuite, complétez les différents formulaires pour obtenir votre compte Azure.

Il convient de noter qu’une carte de crédit vous sera demandée. Aucun débit ne sera réalisé sur cette carte sauf si vous supprimez explicitement la limite de dépenses associée à ce compte d’essai.

Une fois votre version d’évaluation Windows Azure activée, vous pouvez accéder au portail de gestion Windows Azure.

Cliquez sur le bouton bleu Portail en haut à droite de l’écran. Une petite visite vous attend pour expliquer où trouver les panneaux sur l’interface. Cliquez sur nouveau en bas à gauche de l’interface.

Nous allons choisir un Ordinateur virtuel en Création rapide dans l’onglet Calcul.

Le NOM DNS est le nom de la machine virtuelle sur le réseau. Dans cette illustration, nous avons choisis « vm-hdinsight ». Choisissez Windows Server 2012, October 2012 pour l’image, une taille moyenne sera suffisante. Précisez votre mot de passe administrateur de la machine, et un emplacement. Pour la France, choisissez par exemple Europe de l’Ouest comme illustré ci-après.

Cliquez sur CREER UN ORDINATEUR VIRTUEL pour confirmer la création. La création prend de l’ordre de quelques minutes.

Cliquez sur DEMARRER si besoin pour exécuter la machine.

Une fois la machine créé, cliquez sur l’onglet ORDINATEURS VIRTUELS si vous n’y êtes pas déjà. Cliquez sur DEMARRER en bas de l’interface si besoin pour exécuter la machine que vous venez de créer : vm-hdpinsight.cloudapp.net.

Cliquez sur CONNECTER, toujours en bas de l’interface. Cela vous propose soit de télécharger un fichier (d’extension « rdp ») soit de l’exécuter (sous Internet Explorer par exemple). Exécutez ce fichier.

Cliquez sur Connect Précisez votre mot de passe administrateur dans le dialogue Windows Security.

La boîte de dialogue Remote Desktop Connection s’ouvre.

Cliquez sur Yes ; vous voici alors dans une session Windows Server avec le Server Manager ouvert. Ouvrez l’écran Start. Pour cela, cliquez sur l’icône à gauche dans le titre de la fenêtre Remote Desktop Connection, sélectionnez Remote commands puis Start.

Exécutez Internet Explorer. A ce stade, suivez les instructions du tutoriel Installation d'HDInsight Server (Hadoop) sur une machine Windows précédemment publié sur ce blog pour l’installation d’HDInsight Server. L’installation du cluster HDInsight Server s’effectue depuis l’environnement Web Platform Installer (Web PI).

Vous disposez à présent d’un cluster Hadoop de test prêt l’usage. Un prochain billet sera l’occasion de faire un tour vos premiers pas avec.

Vous avez dit Hadoop ? – 2nde partie

Philippe Beraud - MSFT — Mon, 25 Mar 2013 18:06:40 GMT

Dans la première partie de ce billet, nous avons introduit les origines d’Hadoop et présenté deux premières briques, en l’occurrence :

HDFS ou la couche de stockage;
Map/Reduce ou la couche de traitement des données.

Dans une seconde et dernière partie, nous nous intéressons à la notion d’ordonnanceur ainsi qu’aux différentes abstractions proposées par l’écosystème Hadoop.

Troisième brique : l’ordonnanceur

L’avantage du modèle au global est qu’il présente d’excellentes performances pour des « jobs » sur des volumes de données en « batch » et Map/Reduce est idéal pour un système de stockage comme HDFS.

Cependant, dans la pratique, la mise en œuvre de ce que nous avons vu juste avant suppose un ordonnanceur ou « scheduler ». En effet, la création/allocation de nouvelles tâches, leur gestion, le fait de synchroniser les processus entre eux, etc. ne se fait pas tout seul et suppose la présence d’un moteur complet qui gère cela au sein d’Hadoop.

Oozie est un ordonnanceur de flux de travail (workflow) pour la gestion d'un graphe acyclique dirigé d’actions, où des actions peuvent être des « jobs » Map/Reduce mais aussi d'autres « jobs » qui reviennent à cela au final comme par exemple avec Hive et Pig. Vous trouverez plus de détails dans le guide de démarrage ici.

Les versions futures d’Hadoop introduiront vraisemblablement des évolutions dans ce domaine à l’image des travaux courants sur YARN (pour Yet Another Resource Negotiator). Vous trouverez une description des principes de son fonctionnement ici.

A ce jour, l’« inconvénient » du Framework Hadoop est que celui-ci demeure fortement couplé à Map/Reduce et n’est pas (encore) adapté à la résolution de certains problèmes liés aux Big Data comme évoqués en introduction de ce billet. (Ce ne sera peut-être plus le cas demain).

Comme l’illustre ce billet, Hadoop est un excellent outil pour travailler sur le Volume, selon le principe des 3V des big Data (Cf. Gartner Says Solving 'Big Data' Challenge Involves More Than Just Managing Volumes of Data). Pour d’autres aspects comme la Vitesse, des technologies comme Microsoft StreamInsight de traitement de flux à haut débit ou Storm s’avèrent mieux adaptés. Nous aurons l’occasion d’y revenir prochainement.

C’est pourquoi le groupe de projet d’Apache en charge du développement d’Hadoop travaille actuellement pour ce découplage et l’ajout de nouveaux paradigmes comme MPI mais ceci est une autre histoire ;)

Quatrième brique : Les abstractions

Depuis l’arrivée du projet principal Hadoop à maturation, plusieurs outils se sont construits sur le moteur d’exécution pour simplifier le développement d’applications. En effet, Hadoop dans son package de base demande que le développeur soit initié au fonctionnement Map/Reduce et qu’il comprenne les bases de la programmation fonctionnelle.

Hive

Hive est un logiciel d'analyse de données permettant d'utiliser Hadoop avec une syntaxe proche du SQL appelée HiveQL et ce, via un mécanisme permettant de définir un schéma lors de la lecture des données. Il permet d’exprimer des requêtes à la SQL qui se compilent en un ensemble de programmes Map/Reduce optimisés, des implémentations en Java du Mapper et du Reducer comme nous l’avons fait. Il propose pour cela un support pour la plupart des constructions auxquelles on peut s’attendre dans SQL (agrégation, regroupements, filtrage, etc.). Il est toutefois possible de soumettre ses propres classes d’implémentation si nécessaire.

Nous aurons l’occasion d’en parler dans un prochain billet lorsque nous découvrirons Windows Azure HDInsight (ou Hadoop on Windows Azure).

Pig

Pig possède lui aussi son propre langage (Pig Latin), mais son approche est différente. Pour faire simple, il est plus facile d’utiliser un langage d’abstraction proche du « pseudo code » pour se focaliser sur la sémantique puis de laisser un compilateur optimiser votre code pour une approche Map/Reduce.

L’avantage de Pig réside dans la simplicité de l’expression d’une suite logique de tâches Map/Reduce sur les données :

A = LOAD 'data' AS (a, b, c).

B = FOREACH A GENERATE a, null;

Le principal inconvénient est qu’il faut apprendre du coup la syntaxe associée. Ceci étant dit, il est difficile de programmer une application avec Map/Reduce et bien souvent, cette dernière n’est pas bien optimisée. La compilation de celle-ci avec Pig donne des performances excellentes que très peu de développeurs arrivent à surpasser.

Il existe beaucoup d’autres projets sur Hadoop dû au potentiel de la plateforme comme notamment :

Mahout qui apporte des capacités de « Machine Learning » avec des algorithmes sur étagère.
Sqoop qui se charge du transfert de données contenues dans des bases de données SQL vers HDFS et inversement.
Etc.

Vous trouverez sur le site officiel Apache Hadoop la liste des projets Apache dans la rubrique Related Projects.

Hadoop Streaming

Pour finir, dans l’installation d’Hadoop, on retrouve une bibliothèque appelée Hadoop Streaming. Cette dernière sert à programmer une application Map/Reduce dans n’importe quel langage de programmation (Python, C#, C++, PHP, etc…). Cette bibliothèque de classes Java écoute pour cela la sortie standard (stdout).

Le principe est le suivant :

Il suffit d’émettre dans celle-ci - avec par un cout en C++ ou un Console.WriteLine() en C# – la clé et la valeur pour la méthode map() puis de récupérer l’entrée – via un cin en C++ ou un Console.ReadLine() en C# – dans la méthode reduce().

Naturellement, écrire puis parser la sortie standard a un coût sur les performances globales d’une application. En dépit de cela, l’approche reste quand même très pratique.

L’article Hadoop on Azure C# Streaming Sample Tutorial propose un tutoriel complet exposant la méthode pour programmer en C # avec le streaming. Vous pouvez également vous appuyer sur la documentation officielle.

Pour aller plus loin

Malgré sa longueur et ses deux parties (pour l’atténuer), ce billet ne fait qu’effleurer Hadoop.

Pour aller plus loin, vous pouvez consulter :

L’un des premiers tutoriels sur Hadoop, très complet, réalisé par l’équipe Yahoo,
La documentation officielle du projet Hadoop,
Le Wiki associé où vous trouverez tout le nécessaire,
Etc.

Les ressources ne manquent pas !

Il convient d’évoquer également à ce propos l’excellent ouvrage Hadoop: The Definitive Guide, 3rd Edition - Storage and Analysis at Internet Scale que beaucoup considèrent à juste titre comme LA référence.

Nous espérons en tout cas que ce billet aura su répondre à certaines de vos questions et vous aura donné l’envie d’aller plus loin avec Hadoop :)

Vous avez dit Hadoop ? - 1ère partie

Philippe Beraud - MSFT — Mon, 25 Mar 2013 17:58:00 GMT

Les Big Data constituent à l’évidence un sujet de prédilection ces derniers temps que ce soit sur les différents blogs de la toile ou dans le cadre des conférences du monde de l’IT. Et lorsque l’on parle de Big Data, un Framework revient en particulier inévitablement sur le devant de la scène : Hadoop (et ce, même si ce dernier ne couvre pas forcément tous les domaines caractérisés par le principe des 3V (Cf. Gartner Says Solving 'Big Data' Challenge Involves More Than Just Managing Volumes of Data), comme la Vitesse notamment)

Pourquoi ce « buzz » ? On peut se dire que les Big Data existent déjà depuis longtemps, sous d’autres appellations, et que ce n’est autre qu’une dénomination marketing. Néanmoins, si on analyse la situation d’un peu plus près, on se rend vite compte que l’apparition d’un Framework a changé la donne.

Dans ce billet, nous allons nous intéresser à l’écosystème d’Hadoop et ce qu’il propose comme outils. L’objectif n’est pas de faire à nouveau un survol des possibilités de la solution mais plutôt de rentrer dans les « entrailles de la bête ». Malheureusement, il existera toujours des aspects manquants, mais nous allons essayer de traiter les principaux.

Les billets suivants s’intéresseront quant à eux à l’implémentation de solutions avec HDInsight : Windows Azure HDInsight et HDInsight Server.

En guise d’introduction

Hadoop est un Framework pour le développement d’applications massivement parallèles écrit en Java. Concrètement ? Cela veut dire une abstraction des mécanismes complexes liés à la programmation parallèle.

Ils sont :

Souvent difficiles à appréhender (ou bien à adapter).
Fortement dépendants du système sur lequel l’application s’exécute (ex : architecture à mémoire partagée ou à mémoire distribuée).

Pour parler de programmation parallèle, nous allons d’abord parler de paradigme.

Qu’est-ce qu’un paradigme ?

D’après notre « ami » Wikipédia, c’est une manière de voir les choses ou plus spécifiquement une conception d’un problème en génie logiciel. On peut prendre comme exemples connus : le paradigme procédural, la programmation orientée objet (POO), le paradigme fonctionnel, etc.

Bref, dans la pratique, il existe deux paradigmes lorsqu’on parle de programmation sur systèmes massivement parallèles et ceux-ci découlent de l’architecture sur laquelle on exécute notre solution :

Le paradigme à mémoire partagée : Celui-ci découle de l’architecture des ordinateurs récents composés de processeurs multi-cœurs. Ces cœurs accèdent à une seule et même mémoire (la RAM) par l’intermédiaire d’un bus. On dit que la mémoire est « partagée ». On fait souvent le raccourci en parlant de programmation SMP (pour symmetric shared memory multiprocessor). Ce paradigme ne nous intéressera pas dans ce billet dans la mesure où il est utilisé pour de faire la programmation parallèle sur simple ordinateur. Il est présenté ici pour comprendre l’évolution de la programmation parallèle.
Le paradigme à mémoire distribuée : Quant à lui, son utilisation est pertinente lorsque l’on programme sur des « clusters ». Un cluster est tout simplement un réseau de serveurs/ordinateurs (on appelle ça des nœuds) sur lesquels s’exécute une application. Cela permet de procéder à de gros traitements en parallèle sans posséder de super ordinateur ; une approche certainement moins onéreuse ;-) Chaque nœud possède sa propre mémoire, il est donc nécessaire de s’envoyer par le réseau les bouts de mémoire nécessaires à un autre traitement. On procède par envoi de message (« Message Passing »).

A la simple description précédente, vous l’aurez compris, ce dernier paradigme pourrait nous intéresser pour les Big Data. Cependant, comme vous le verrez tout de suite après, Hadoop se fonde dans la pratique sur un autre paradigme, appelé Map/Reduce découlant des limitations de ces deux premiers paradigmes, d’où l’intérêt de les introduire très brièvement.

Un rapide historique

Ces architectures présentées précédemment existent déjà depuis fort longtemps (début les années 60 !), alors pourquoi les architectures Big Data sont apparues aussi tard ?

Et bien, tout d’abord parce que, jusqu’à l’avènement d’Internet et surtout du Web 2.0 (encore un « buzzword »…), il n’y avait pas tant de données à traiter que ça. Donc le « Message Passing » fonctionnait. Mais à partir du moment où chaque utilisateur a commencé à produire du contenu (on appelle ça le Web 2.0), la courbe d’évolution du nombre de données s’est transformée en courbe exponentielle. En ce 21^ième siècle, à l’heure du tout numérique, désormais toute information a vocation à être « donnée » et toute donnée représente potentiellement un facteur clé pour la réussite d’une organisation, qu’il s’agisse d’un organisme de recherche, d’un acteur du Secteur Public ou d’une entreprise. Je vous renvoie à notre billet d’introduction pour ce blog.

Le problème pour le traitement du déluge de données aussi omniprésentes est, qu’avec les envois de messages, le réseau se trouve très vite saturé. On perd très vite l’avantage de traiter les données en parallèle.

Jeffrey Dean et Sanjay Ghemahat, deux ingénieurs de chez Google, se sont dès lors investis à trouver une solution au problème. Ils sont partis pour cela d’un principe simple et ingénieux : Plutôt que de déplacer les données par le réseau, déplaçons le code. Entre passer par le réseau 500 Go de données ou 40 Mo de code compilé, un choix semble s’imposer de lui-même !

Leur publication Map Reduce : Simplified Data Processing on Large Cluster, résultat de ces travaux, décrit les principes d’un nouveau paradigme appelé Map/Reduce en référence aux fonctions map et reduce, parties intégrantes des langages fonctionnels comme Lisp. Son objectif consiste également à proposer une interface simplifiée à la création d’applications massivement parallèles.

C’est à ce moment-là qu’arrive Hadoop. Doug Cutting et Michael J. Cafarella, les deux créateurs, travaillaient précédemment sur un moteur de recherche Open Source du nom de Nutch. Un sous projet de Nutch visant à en faire un moteur d’indexation distribué les a amené à développer pour le fonctionnement interne de leur moteur un système de fichier distribué appelé NDFS (Nutch Distribued File System).

Avec la publication de Map/Reduce facilitant le traitement de larges ensembles de données, ils créeront Hadoop, un Framework composé d’un système de fichier distribué issu de NDFS sur lequel on exécute des traitements parallèles appliquant Map/Reduce.

Voilà l’historique et le cheminement associé. Maintenant concrètement Hadoop qu’est-ce que c’est ?

C’est un « runtime » (un moteur d’exécution) qui s’installe sur un cluster. A la base, il est composé d’une bibliothèque de classes Java et tout un paquet d’outils (Hadoop Common), d’un système de fichier HDFS (Hadoop Distributed File System), d’une implémentation Map/Reduce pour la définition de programmes et d’un ordonnanceur comme Oozie par exemple.

Pour faire simple, nous programmons notre application en Java en utilisant les classes de la bibliothèque contenue dans Hadoop Common. Ensuite il suffit de compiler ce code et de le lancer dans le moteur d’exécution. Pour le reste, Hadoop « gère » notre code et s’occupe de tout !

Pour appliquer le principe de base énoncé plus haut, les deux ingénieurs ont planché sur un système de stockage distribué. Les données sont réparties sur les différents nœuds du cluster et le code s’exécute sur chacun des nœuds.

Première brique : HDFS (ou la couche de stockage des données)

HDFS est le nom donné au système de stockage distribué. C’est l’élément sur lequel repose tout le Framework Hadoop. On notera qu’Hadoop prévoit aussi qu’on puisse remplacer le système de fichiers distribué par une autre implémentation qu’HDFS. C’est ce que fait la distribution MapR par exemple. Dans le cas d’HDInsight sur Windows Azure, on peut utiliser soit HDFS, soit le stockage Windows Azure (ASV, pour Azure Storage Vault).

Qu’est-ce qu’un système de fichier ?

Un système de fichiers (File system) est une abstraction pour stocker, récupérer ou mettre à jour des données. Dans le cas d’HDFS, la mise à jour n’est pas autorisée.

On peut prendre comme exemples les systèmes de fichiers ReFS, NTFS et FAT32 (pour les stockages Windows) ou bien ext3, ext4 (pour les stockages Linux).

HDFS lui est distribué, c’est-à-dire qu’il va diviser les données par paquet ou « split » et ensuite les stocker. La taille d’un paquet est fixée par Hadoop.

Le fait qu’il soit distribué ne se perçoit pas durant l’utilisation car on accède aux fichiers HDFS de manière classique, autrement dit au travers d’une arborescence classique sous la forme dossier/sous_dossier/fichier.extension. Cependant, la donnée est bel est bien répartie sur les différents nœuds avec un mécanisme de réplication (pour le cas où il y aurait perte).

Il est tout à fait possible d’utiliser HDFS sans passer par la partie Map/Reduce d’Hadoop ; c’est ce que fait par exemple Apache HBase, une base de données non-relationnelle.

Comment HDFS retrouve l’information ?

HDFS définit deux types de nœuds :

Le nœud principal ou NameNode : il s’agit d’un nœud qui a pour fonction de répertorier où sont stockées les données, sur quels nœuds précisément. Si un nœud est hors d’usage, ce dernier a répertorié aussi l’adresse de la réplique de données.

Le nœud de données ou DataNode : Ce nœud est réservé pour le stockage de la donnée. Elle est stockée telle quelle (donnée brute). Cela permet à HDFS de rester simple et d’éviter la non prise en charge de certains formats (pour les convertir).

Le schéma suivant illustre la répartition des fichiers dans HDFS :

Pour plus d’informations, vous pouvez regarder ici.

Deuxième brique : Map/Reduce (ou la couche de traitement des données)

On présente souvent Map/Reduce en parlant d’Hadoop comme un Framework, mais le terme est inexact. Map/Reduce est une stratégie de parallélisation et lorsqu’on parle de Map/Reduce dans Hadoop, il s’agit de son implémentation.

Greg Andrews définit cinq familles de stratégies (dans son ouvrage Concurrent Programming: Principles and Practice), dont une qui s’intitule « le parallélisme récursif », qui n’est autre que l’application du concept de « diviser pour régner ».

Il s’agit de décomposer le problème initial en sous-problèmes plus simples, et ainsi de suite jusqu’à ce que le sous-problème soit trivial (ex : oui ou non).

Pour faire une analogie, cela revient à défaire un sac de nœuds en défaisant d’abord les plus petits nœuds. Cette stratégie est facilement parallélisable car chaque sous-problème est indépendant.

Le principe de base

Map/Reduce est une application de cette stratégie dite récursive avec une particularité toutefois : on stocke les résultats dans une Map (au sens programmation du terme).

Prenons un exemple : Nous voulons compter le nombre de vues pour chaque billet de ce blog. Pour cela, nous avons les fichiers journaux (logs) de la plateforme sur laquelle est hébergé ce blog.

Solution :

Dans notre programme, nous voulons un affichage avec la page (son url) et le nombre de vues.

Ex : exploitez-le-171-d-233-luge-des-donn-233-es-187.aspx : 20834 vues

(Le nombre est volontairement exagéré, c’est pour l’égo pur ;))

Explication :

La phase de « mapping » va générer, pour chaque ligne de nos fichiers journaux, le nom de la page (qui est notre clé) puis la valeur 1 (pour signaler qu’il y a une vue) dans un objet de type Map. Une méthode map traitera donc chacune des lignes, recevant comme input son adresse relative au document (« offset ») et le contenu correspondant.

La phase de « reduce » va récupérer cet objet Map, puis faire la somme des valeurs trouvées pour une page donnée.

En quelque sorte, Map spécifie ce que nous voulons comme type de résultats (ce qui permet de diviser implicitement le travail) et Reduce rassemble tous ces résultats intermédiaires pour composer le résultat final.

L'implémentation de Map/Reduce dans Hadoop (Hadoop MapReduce API)

Bonne nouvelle : l’implémentation existe déjà dans l’API fournie par Hadoop ; il n’est donc nul besoin d’apprendre un nouveau paradigme. Il suffit d’utiliser les classes fournies par la bibliothèque Hadoop Common. Nous allons en expliquer le mécanisme.

Une application Hadoop est un fichier JAR (Java ARchive) composée d’une classe point d’entrée Main et de deux implémentations : la première de la classe Mapper, l’autre de la classe Reducer.

Dans le Main, on configure ce qu’on appelle un « job ». Il correspond à un traitement sur le cluster. C’est notre problème initial.

Le job prend comme paramètres :

Le répertoire d’entrée,
Le fichier de sortie qui contiendra le résultat,
Le type de données en entrée,
Et celui en sortie.

Il est ensuite exécuté. Voici à quoi ressemble le Main :

public static class Main

{

// Ne pas oublier de faire les imports!

public static void main(String[] args) throws Exception{

// Classe de configuration fournie par Hadoop Common

Configuration config = new Configuration();

// Instance du job représentant notre problème. Il a un objet de config et un nom.

Job job = new Job(config, "le_nom_du_programme");

// Configuration du type de contenu en entrée

job.setInputFormatClass(TextInputFormat.class);

// Configuration du type de contenu du résultat final

job.setOutputFormatClass(TextOutputFormat.class);

// On spécifie quelle est notre implémentation du Mapper

job.setMapperClass(MonMapperImpl.class);

// On spécifie quelle est notre implémentation du Reducer

job.setReducerClass(MonReducerImpl.class);

//Configuration du type de la Map. Ici elle sera de type Map<Text, IntWritable>

job.setOutputKeyClass(Text.class);

job.setOutputValueClass(IntWritable.class);

// On donne le chemin d'entrée où sont stockées nos données

FileInputFormat.addInputPath(job, new Path("dossierHDFS/sous_dossier/mon_dossier_data");

// On donne le chemin de sortie où sera stocké le fichier contenant le résultat

FileOutputFormat.setOutputPath(job, new Path("dossierHDFS/mon_dossier_sortie"));

// On lance le job et on spécifie qu'il faut attendre la fin de celui-ci avant de

// terminer le main (true).

job.waitForCompletion(true);

}

Il convient de noter qu’il est tout à fait possible de définir plusieurs Jobs dans le Main.

Explication de code :

Notre méthode main() s’occupe ici d’instancier un objet Job qui nous est fourni par le package MapReduce de Hadoop (org.apache.hadoop.mapreduce). On le paramètre d’abord par le type de contenu en entrée que nous allons émettre dans la Map. Ce type, TextInputFormat, se trouve également dans l’API. Le deuxième paramétrage est le type de contenu en sortie (Idem que le précédent). Ces deux premiers paramètres vont indiquer au moteur d’exécution qu’en entrée on aura du texte et en sortie également du texte. Simple non ?
Ensuite, c’est au tour des paramètres indiquant au moteur d’exécution quelles sont nos implémentations. Ici nous avons nommé pour l’exemple « MonMapperImpl » l’implémentation de notre classe Mapper, et « MonReducerImpl » l’implémentation de notre classe Reducer.
Les deux paramètres suivants ciblent le type de l’objet Map» interne au Framework. On va dire que notre clé sera de type « Text » et que notre valeur sera de type « IntWritable » (un entier donc). Chaque paire contenue dans la Map sera identifiée par une chaine de caractère et aura pour valeur un entier. (Mais tout cela dépendra de votre application). Ceci correspond à ce que nous voulons : le nom de la page (Text) et un nombre de vues (IntWritable).
Les deux derniers paramètres précisent le chemin d’accès au dossier d’entrée, autrement dit là où nos données que nous voulons analyser sont stockées, et le chemin de sortie du fichier de résultat.
Une fois tous ces paramètres spécifiés, nous lançons le Job grâce à la méthode « waitForCompletion() ». Cette méthode à la particularité de prendre en paramètre un booléen qui précise si oui ou non elle bloquera l’exécution des instructions suivantes dans le main jusqu’à ce que le Job soit fini.

Maintenant, nous passons aux implémentations :

public static class MonMapperImpl extends Mapper<Object, Text, Text, IntWritable> {

private static final int pagePos = 2;

static final IntWritable nombreUn = new IntWritable(1);

private Text clefCourante = new Text();

@Override

public void map(Object key, Text value, Context context)

throws IOException {

String[] parts = value.toString().split("\\s+");

if (parts.length < 0) //only take records with all values

{

return;

}

clefCourante.set( parts[pagePos] );

context.write(clefCourante, nombreUn);

}

Notre classe MonMapperImpl implémente l’interface « Mapper » qui est générique. Le premier type générique correspond à la clé en entrée de la méthode map (c’est un objet représentant le numéro de ligne courant) et le second correspond à la valeur en entrée (c’est le contenu de cette ligne). Le troisième et le quatrième sont respectivement indiqués pour la clé de sortie et la valeur de sortie de cette méthode.

Ceux-ci permettent à la méthode map() de savoir ce qui lui arrive comme « record » (ici c’est un numéro de ligne et du texte), puis de configurer un objet Context utilisé pour émettre un résultat intermédiaire. (Un « record » par défaut correspond à une ligne au sens Unix (« \n ») dans des données intermédiaires stockées sur le système de fichiers distribué.)

L’interface Mapper spécifie donc une méthode map() à implémenter. La nôtre est simple :

On découpe dans un tableau de chaines de caractères ce qui nous arrive en entrée (l’élément de séparation est un espace Unix : \s).
On teste si le tableau est vide. Si oui, on passe au « record » suivant (la ligne suivante).
On modifier l’instance clefCourante pour y mettre la chaine contenue dans le tableau à la case numéro 2 car nous savons que nos fichiers journaux sont constitués ainsi : <DateTime> <ip_du_visiteur> <nom_de_la_page.html>. Le fait d’avoir une seule instance de la clef évite d’en instancier une à chaque fois que la méthode map() est appelée (ce qui fait beaucoup). C’est la même chose pour le nombre un.
On émet via l’objet output une nouvelle clef trouvée avec la valeur 1 pour signaler que nous l’avons trouvée une fois dans le record.

Implémentation du Reducer :

public static class MonReducerImpl extends Reducer<Text, IntWritable, Text, IntWritable>

{

@Override

public void reduce(Text key, Iterator<IntgWritable> values,Context context)

throws IOException {

int compte = 0;

while( values.hasNext())

{

compte += values.next().get();

}

if (compte> 0)

{

context.collect(key, new IntWritable(compte));

}

Notre Reducer ici se déclare comme le Mapper précédent, mis à part le fait qu’il implémente non pas l’interface Mapper, mais bien l’interface Reducer (avec les mêmes types génériques):

On reçoit une clé – le nom de la page- et un itérateur, « values », qui nous permet de parcourir la collection de valeurs remplies par la méthode map(). On boucle donc sur la collection : pour chaque valeur (dans notre cas égale à 1), on incrémente le compteur pour cette clé.
On émet la paire « nom de la page, compte total » dans le fichier ou les fichiers de sortie. (Le fait que les traitements soient répartis fait que plusieurs fichiers peuvent être générés dans un même dossier. Logiquement, cet ensemble de données peut être lu comme la concaténation de tous les fichiers.)

L’exécution en détail (Hadoop MapReduce System)

Explication du schéma :

Au niveau du nœud principal (head node), le « JobTracker » est responsable de la gestion des ressources, autrement dit du contrôle des nœuds de calcul (worker node). Il gère toute la durée de vie d’un job.

Le « TaskTracker » a des responsabilités plus simples, à savoir lancer les tâches dans l’ordre fourni par le « JobTracker » et périodiquement donner un statut d’avancement de la tâche au « JobTracker ». Ces nœuds de calcul sont les mêmes nœuds que les nœuds de données (data node) évoqués précédemment au niveau de la couche de stockage.

Chaque « Tracker » est une instance de la JVM (Java Virtual Machine).

Il convient de considérer 3 phases successives :

La phase de « mapping »,
La phase de « shuffle »,
La phase de « reduce ».

Voyons ce qu’il en est.

La phase de « mapping »

Lorsque nous lançons un job, ce dernier s’exécute sur le cluster et commence la phase de Map. Le « JobTracker » au niveau du nœud principal (head node) prend en compte le job et le disperse sur les « TaskTrackers ». Les nœuds de calcul (worker node) reçoivent alors le code à exécuter sur leurs sous-ensembles de données respectifs.

Le code se trouve dans notre classe d’implémentation MonMapperImpl : c’est la méthode « map() ». Dans notre cas de test, la méthode émet en clé le nom de la page du blog visité et puis en valeur (l’entier 1) pour incrémenter le compteur total. Une fois la tâche terminée, le « TaskTracker » signale au « JobTracker » qu’il a fini.

La phase de « shuffle »

Elle est gérée entièrement par le Framework. Elle constitue la phase où nous devons regrouper toutes les valeurs produites pour une même clé par les nœuds de calcul. La phase de « reduce » n’aura plus qu’à les agréger.

La phase de « reduce »

La phase de « reduce » commence quand tous les « TaskTracker » ont terminé leur tâche « map ». Il lance alors une nouvelle tâche sur une JVM qui va s’occuper de la combinaison de tous les résultats intermédiaires et ainsi former le résultat final (principe de « diviser pour régner »).

Plus concrètement ? Notre programme récupère les objets Map de chaque nœud de calcul, puis les agrège. Partons du principe suivant :

Le nœud de calcul n°1 possède une Map avec comme clefs :

‘exploitez-le-171-d-233-luge-des-donn-233-es-187.aspx’=>1
‘tirer-parti-d-un-cluster-hadoop-depuis-ssis.aspx’=>1

Le nœud de calcul n°2 possède une Map avec comme clefs :

‘exploitez-le-171-d-233-luge-des-donn-233-es-187.aspx’=>1

Le Reduce va constituer une seule Map avec :

‘exploitez-le-171-d-233-luge-des-donn-233-es-187.aspx’=>2
‘tirer-parti-d-un-cluster-hadoop-depuis-ssis.aspx’=>1

Dans notre cas, nous voulions une somme des 1 pour chaque page correspondante. Mais à vous de voir le Reduce comme il vous plaira. (Il existe une petite optimisation qui fait un « reduce » intermédiaire sur les nœuds de calcul. On l’appelle le « combiner ». Généralement c’est la même classe Reducer qui est utilisée, mais il est possible d’en utiliser une autre.)

Ceci conclut cette première partie du billet. Dans une seconde et dernière partie nous aborderons la notion d’ordonnanceur et les abstractions proposées par l’écosystème Hadoop.