Introduction

Google Prediction promet de démocratiser l’analyse de volumes de données importants et d’en tirer des “prédictions”. Il devient alors possible, en quelques clics et à un coût très raisonnable, de bénéficier des apports du datamining. Dans un futur proche, ceci permettrait aux grandes organisations de généraliser cette approche à toutes les strates et aux plus petites de bénéficier de méthodes d’analyse jusqu’alors hors d’atteinte.

Pour tester ce produit magique et plein de promesses, nous avons développé un POC qui permet d’utiliser l’API proposée par Google. Son principe est simple : à partir de la note qu’un utilisateur donne à un film, l’application doit être capable de conseiller d’autres films qui pourrait l’intéresser.

Pour ce POC, nous avons utilisé :

  • PHP en tant que langage ;
  • l’API PHP de Google Prediction ;
  • Google Cloud Storage.

Pré-requis

Pour utiliser Google Prediction, vous devez :

  • disposer d’un Google Account ;
  • accéder à la Google Console Project et y activer les services Google Prediction et Google Cloud Storage (pour ce dernier, il est nécessaire d’activer la fonction « Billing »);
  • activer l’authentification en utilisant OAuth2.

Phase d’initialisation

Avant toute prédiction, il est nécessaire de monter les données à analyser et de les préparer. Cette préparation permettra de générer un « modèle ». Ce modèle correspond à vos données qui ont été catégorisées (la réponse désirée est de type string) ou ordonnées (la réponse désirée est de type numérique) afin de pouvoir répondre à vos futures requêtes.

Étape 1 : uploader les données

Pour monter un modèle dans Prediction, il faut tout d’abord uploader un fichier CSV dans Google Cloud Storage. Ce fichier doit respecter les contraintes suivantes :

  • format : la première colonne doit présenter la classe – ex : « french », « Je ne suis jamais fatigué. » ;
  • format : la donnée de réponse aux requêtes doit être dans la première colonne – dans l’exemple précédent : c’est “french” ;
  • format : le fichier ne doit pas contenir de ligne d’en-tête ;
  • taille : si la taille du fichier n’a pas d’importance pour Cloud Storage, Prediction a une limite de 250 Mo. Au-dessus, impossible d’entraîner le modèle (voir ci-dessous).

Pour information, Google Cloud Storage est un service payant.

Étape 2 : entraîner le modèle

Ensuite seulement peut commencer l’entraînement du modèle. Cela va permettre à Prediction de préparer l’ensemble de données uploadé à recevoir les requêtes de prédiction. Pour ce faire, Prediction va “trier” les données en fonction de la la donnée en première colonne de votre fichier (la réponse) :

  • Si cette donnée est de type alphanumérique, Prediction va “catégoriser” le modèle : les données vont être classées par catégories.
  • Si cette donnée est de type numérique, Prediction va trier les données par rapport à la valeur de cette donnée. On parle alors de “régression”.

Cet entraînement est lancé en appelant le service trainedmodel.insert.

Lors du premier entraînement d’un modèle, il faut lui donner un id. Cet id doit être unique et servira à retrouver ce modèle parmi d’autres lors des futures requêtes.

L’appel au service trainedmodel.insert est asynchrone. Une fois lancé, l’entraînement s’effectue en tâche de fond. Pour connaître son état, il faut alors utiliser le service trainedmodel.get(id).

Note : préparer plusieurs modèles en même temps allonge sensiblement – et de manière quasi-exponentielle – la durée des préparations. Ainsi, pour un même fichier, le temps de préparation peut passer de 1H (préparation lancée seule) à 5H lorsque 2 préparations ont été lancées en même temps.

Prise en main de l’API

Les services de Google Prediction sont exposées en mode RESTful. Il n’est donc ni difficile ni coûteux de les appeler directement. Mais Google met à la disposition des développeurs une API simple qui gère et simplifie ces appels.

Étape 1 : installer l’API

Les API sont disponibles à l’adresse suivante : https://developers.google.com/prediction/docs/libraries?hl=fr

Étape 2 : appeler le service de “prédiction”

Google a voulu une API simple d’utilisation afin qu’elle puisse s’adapter aux besoins des développeurs sans devenir une contrainte. Le pari est réussi. En guise d’exemple, appeler le service de prédiction à travers l’API se limite à :

<?php
$service = new Google_PredictionService($client);

$data = new Google_InputInput();
$data->setCsvInstance(array($year, $note, $name));

$input = new Google_Input();
$input->setInput($data);

$result = $service->trainedmodels->predict($id, $input);

print_r($result);

Quelques explications sur le code :

  • La variable $client permet de définir la méthode pour s’authentifier. Cette partie est détaillée ci-dessous.
  • L’instruction $data->setCsvInstance(array($year, $note, $name)) permet de donner au service de prédiction les paramètres d’entrées. Ces paramètres sont :
    • l’id du modèle sur lequel lancer l’analyse ;
    • des données que l’on peut trouver dans le fichier CSV qui a permis de générer le modèle. Ils ne doivent pas contenir de donnée relative à la première colonne (puisque celle-ci représente la réponse attendue).
  • La réponse du service est au format JSON. En PHP, elle présente le format suivant :
Array ( 
[kind] => prediction#output                      //type de résultat
[id] => filmovores_light1                        //id du modèle
[selfLink] => https://www.googleapis.com/prediction/v1.5/trainedmodels/filmovores_light1/predict      //lien vers le service
[outputLabel] => The Hunt for Red October        //meilleur réponse
[outputMulti] => Array (                         //liste des réponses NON triée
      [0] => Array ( 
             [label] => Team America: World Police 
             [score] => 0.00128 
      )
      [1] => ...
   )
)

Si l’on souhaite seulement la meilleure réponse, il suffit d’utiliser la valeur de l’élément “outputLabel”. Mais si l’on a besoin de plus de réponses (dans notre cas, nous souhaitions afficher 10 films à conseiller), il faut extraire le tableau des réponses “outputMulti” et le trier par score.

Note : malgré son format, le score ne correspond pas à une probabilité, c’est plutôt une note relative. Ce n’est pas linéaire : un score de 0.2 n’est pas 2 fois mieux qu’un score de 0.1 !

Étape 3 : choisir le mode de connexion

Il existe 2 principales méthodes pour se connecter.

La voie la plus simple et la plus rapide à mettre en place est la suivante :

<?php
$client = new Google_Client();
$client->setApplicationName("Filmovores - Google Prediction POC");
        
$client->setClientId('[CLIENT ID]'); //ex : xxxxx.apps.googleusercontent.com
$client->setClientSecret('[CLIENT SECRET]');
$client->setRedirectUri('[REDIRECTION URL]'); //ex : http://locahost/filmovores
$client->setDeveloperKey('[CLIENT DEV KEY]');
$client->setScopes(array('https://www.googleapis.com/auth/prediction'));

Toutes ces informations se trouvent et/ou sont configurables sur votre Google Project Console.

Le principal inconvénient – et il est de taille – de cette méthode est que seul l’utilisateur qui détient le modèle peut utiliser l’application. En effet, à chaque appel d’un service de Prediction, l’utilisateur va être redirigé vers son compte. Il pourra alors autoriser (ou pas) l’application à faire appel à ses données stockées sur Prediction. Évidemment, si ce ne sont pas ses données, il ne pourra pas y accéder.

Pour passer cette limitation, nous pouvons utiliser la méthode d’authentification par ServiceAccount. Celle-ci permet, grâce à une clé privée, d’autoriser l’application à faire appel aux données stockées sur le compte choisi – l’application est alors liée à un unique compte. Ainsi, l’authentification devient invisible pour l’utilisateur de l’application.

<?php
const CLIENT_ID = '[CLIENT ID]'; //ex : yyy.apps.googleusercontent.com
const SERVICE_ACCOUNT_NAME = '[SERVICE ACCOUNT NAME]' ; //ex : 'zzz@developer.gserviceaccount.com';
const KEY_FILE = '[URL TO KEY FILE]'; //ex : ‘../mykey.p12’

$client = new Google_Client();
$client->setApplicationName("Filmovores - Google Prediction POC");

$key = file_get_contents(KEY_FILE);
$client->setAssertionCredentials(
        new Google_AssertionCredentials(
            SERVICE_ACCOUNT_NAME,
            array('https://www.googleapis.com/auth/prediction'),
            $key
)
);

$client->setClientId(CLIENT_ID);

Toutes ces informations se trouvent et/ou sont configurables sur votre Google Project Console, rubrique ServiceAccount.

Étape 4 : Évolution d’un modèle

Après son entraînement initial, un modèle peut être requêté mais il peut aussi être mis à jour.

Il est possible d’ajouter des données à un modèle existant afin de l’enrichir de manière continue. Ceci peut être fait de 2 façons : passer par le service d’update ou bien mettre à jour directement le fichier de données source et relancer un entraînement.

Quelque soit la méthode choisie, un modèle en cours d’entraînement ne peut pas être requêté.

La méthode manuelle : enrichir le fichier CSV source

Cette méthode consiste à reprendre le fichier CSV source et de le compléter avec les informations à ajouter. Ensuite, il faut l’uploader à nouveau sur Google Cloud Storage afin de lancer un entraînement dessus (avec le même id).Cette méthode convient si les mises à jour sont peu fréquentes mais volumineuses.

La méthode automatique : utiliser le service update

Le service trainedmodels.update permet d’ajouter des données dans un format proche du CSV initialement uploadé. Chaque appel de ce service permet d’ajouter l’équivalent d’une ligne.

A chaque appel, le développeur doit fournir :

  • le label, c’est à dire la valeur de réponse associée à la ligne ;
  • les données liées à ce label.

Une ligne ainsi ajoutée doit contenir autant de colonnes que les autres, sous peine d’être ignorée lors des analyses.

<?php
$input = new Google_Update();
$input->setCsvInstance(array($year, $name, $note, date("d-m-Y")));
$input->setLabel($film);

$result = $service->trainedmodels->update($id, $input);

Ce service ne lance pas immédiatement de nouvel entraînement du modèle. Par conséquent, les données ajoutées ne sont pas prises en compte tant qu’un nouvel entraînement n’a pas été lancé.

Un entraînement est lancé automatiquement par Google Prediction lorsque x updates ont été lancés sur un modèle. Aujourd’hui, ce nombre correspond à environ 100 (peut être amené à évoluer).

Cette méthode convient lorsque les mises à jour sont fréquentes et/ou peu volumineuses. L’inconvénient majeur est que l’on ne sait pas à l’avance à quel moment le modèle est ré-entraîné.

Conclusions

La prise en main de l’outil et de l’API est très rapide. En quelques heures, il a été possible de monter ce POC. La tâche la plus longue et la plus critique correspond à la gestion des données qui servent de base au modèle. Cette tâche représente la fondation de l’application et doit être soignée.

L’outil Prediction et son API RESTful sont simples d’utilisation. Ainsi, ils peuvent facilement s’intégrer au sein d’un eco-système diversifié.

Le coût d’utilisation est très faible. Le POC a coûté 9,75$ dont la grande majorité provient de l’upload de fichiers de plusieurs Giga sur Google Cloud Storage (multiples essais, changement de format, essais aux limites, …).

L’API est encore jeune et pas encore tout à fait stable. Par exemple, aujourd’hui, la version PHP utilise toujours la v1.4 des services de Prediction et il a fallu implémenter certains services de la v1.5 à la main (notamment la méthode “list”). Par ailleurs, la limite concernant le volume de données qu’il est possible d’utiliser (250 Mo) est rapidement pénalisante.

Le code est disponible sur Gist (https://gist.github.com/clementseguy/5747912)

Quelques liens :
– Google Prediction : https://developers.google.com/prediction/?hl=fr
– Google Prediction Developer Guide : https://developers.google.com/prediction/docs/developer-guide
– Business Intelligence 2.0 : http://en.wikipedia.org/wiki/Business_Intelligence_2.0