Comment installer et utiliser Apache PredictionIO pour lapprentissage automatique sur CentOS 7

• Conditions préalables
• Installer Java
• Installer PredictionIO
• Installer les dépendances requises
• Configurer l'environnement PredictionIO
• Démarrage de PredictionIO
• Implémentation d'un modèle de moteur
• Emballer

Les approches traditionnelles de l'analyse des données sont impossibles à utiliser lorsque les ensembles de données atteignent une certaine taille. Une alternative moderne à l'analyse des énormes ensembles de données consiste à utiliser des méthodes d'apprentissage automatique. L'apprentissage automatique est capable de produire des résultats précis lors de l'utilisation d'un algorithme rapide et efficace.

Apache PredictionIO est un serveur d'apprentissage machine open source utilisé pour créer des moteurs prédictifs pour toute tâche d'apprentissage machine. Il raccourcit le temps d'application de l'apprentissage automatique du laboratoire à la production en utilisant des modèles de moteur personnalisables qui peuvent être créés et déployés rapidement. Il fournit la collecte de données et les composants de service, et résume la technologie sous-jacente pour exposer une API qui permet aux développeurs de se concentrer sur les composants de transformation. Une fois que le serveur moteur de PredictionIO est déployé en tant que service Web, il peut répondre aux requêtes dynamiques en temps réel.

Apache PredictionIO se compose de différents composants.

• Plateforme PredictionIO : pile d'apprentissage machine open source construite sur le dessus de certaines applications open source de pointe telles qu'Apache Spark, Apache Hadoop, Apache HBase et Elasticsearch.
• Serveur d'événements : il collecte en continu les données de votre serveur Web ou serveur d'applications mobiles en mode temps réel ou en mode batch. Les données recueillies peuvent être utilisées pour entraîner le moteur ou pour fournir une vue unifiée pour l'analyse des données. Le serveur d'événements utilise Apache HBase pour stocker les données.
• Serveur de moteur : le serveur de moteur est chargé de faire la prédiction réelle. Il lit les données d'apprentissage du magasin de données et utilise un ou plusieurs algorithmes d'apprentissage automatique pour construire les modèles prédictifs. Un moteur, une fois déployé en tant que service Web, répond aux requêtes effectuées par une application Web ou mobile à l'aide de l'API REST ou du SDK.
• Galerie de modèles : cette galerie propose différents types de modèles de moteur prédéfinis. Vous pouvez choisir un modèle similaire à votre cas d'utilisation et le modifier selon vos besoins.

Conditions préalables

• Une instance de serveur Vultr CentOS 7 avec au moins 8 Go de RAM. À des fins de test et de développement, vous pouvez choisir une instance avec 4 Go de RAM et une autre mémoire d'échange de 4 Go .
• Un utilisateur sudo .

Dans ce didacticiel, nous utiliserons 192.0.2.1comme adresse IP publique du serveur. Remplacez toutes les occurrences de 192.0.2.1par votre adresse IP publique Vultr.

Mettez à jour votre système de base à l'aide du guide Comment mettre à jour CentOS 7 . Une fois votre système mis à jour, installez Java.

Installer Java

De nombreux composants de PredictionIO nécessitent JDK, ou Java Development Kit, version 8 pour fonctionner. Il prend en charge OpenJDK et Oracle Java. Dans ce tutoriel, nous allons installer OpenJDK version 8.

OpenJDK peut être facilement installé, car le package est disponible dans le référentiel YUM par défaut.

sudo yum -y install java-1.8.0-openjdk-devel

Vérifiez la version de Java pour vous assurer qu'elle a été installée correctement.

java -version

Vous obtiendrez une sortie similaire.

[user@vultr ~]$ java -version
openjdk version "1.8.0_151"
OpenJDK Runtime Environment (build 1.8.0_151-b12)
OpenJDK 64-Bit Server VM (build 25.151-b12, mixed mode)

Avant de continuer, nous devrons configurer les variables d'environnement JAVA_HOMEet JRE_HOME. Trouvez le chemin absolu de l'exécutable JAVA dans votre système.

readlink -f $(which java)

Vous verrez une sortie similaire.

[user@vultr ~]$ readlink -f $(which java)
/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.151-1.b12.el7_4.x86_64/jre/bin/java

Maintenant, définissez JAVA_HOMEet JRE_HOMEvariable d'environnement selon le chemin du répertoire Java.

echo "export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.151-1.b12.el7_4.x86_64" >> ~/.bash_profile
echo "export JRE_HOME=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.151-1.b12.el7_4.x86_64/jre" >> ~/.bash_profile

Exécutez le bash_profilefichier.

source ~/.bash_profile

Vous pouvez maintenant exécuter la echo $JAVA_HOMEcommande pour vérifier si la variable d'environnement est définie.

[user@vultr ~]$ echo $JAVA_HOME
/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.151-1.b12.el7_4.x86_64

Installer PredictionIO

Apache fournit des fichiers source PredictionIO qui peuvent être téléchargés et compilés localement. Créez un nouveau répertoire temporaire pour télécharger et compiler le fichier source.

mkdir /tmp/pio_sourcefiles && cd /tmp/pio_sourcefiles

Téléchargez l'archive du fichier source PredictionIO à l'aide de n'importe quel site Apache Mirror .

wget http://apache.mirror.vexxhost.com/incubator/predictionio/0.12.0-incubating/apache-predictionio-0.12.0-incubating.tar.gz

Extrayez l'archive et compilez la source pour créer une distribution de PredictionIO.

tar xf apache-predictionio-0.12.0-incubating.tar.gz
./make-distribution.sh

La répartition ci - dessus sera construite contre les versions par défaut des dépendances, qui sont Scala 2.11.8, Spark 2.1.1, Hadoop 2.7.3et ElasticSearch 5.5.2. Attendez la fin de la génération, il faudra environ dix minutes pour terminer en fonction des performances de votre système.

Remarque : Vous êtes libre d'utiliser la dernière version prise en charge des dépendances, mais vous pouvez voir certains avertissements pendant la génération car certaines fonctions peuvent être obsolètes. Exécutez ./make-distribution.sh -Dscala.version=2.11.11 -Dspark.version=2.1.2 -Dhadoop.version=2.7.4 -Delasticsearch.version=5.5.3, en remplaçant le numéro de version selon votre choix.

Une fois la construction terminée, vous verrez le message suivant à la fin.

...
PredictionIO-0.12.0-incubating/python/pypio/__init__.py
PredictionIO-0.12.0-incubating/python/pypio/utils.py
PredictionIO-0.12.0-incubating/python/pypio/shell.py
PredictionIO binary distribution created at PredictionIO-0.12.0-incubating.tar.gz

Les fichiers binaires PredictionIO seront enregistrés dans l' PredictionIO-0.12.0-incubating.tar.gzarchive. Extrayez l'archive dans le /optrépertoire et fournissez la propriété à l'utilisateur actuel.

sudo tar xf PredictionIO-0.12.0-incubating.tar.gz -C /opt/
sudo chown -R $USER:$USER /opt/PredictionIO-0.12.0-incubating

Définissez la PIO_HOMEvariable d'environnement.

echo "export PIO_HOME=/opt/PredictionIO-0.12.0-incubating" >> ~/.bash_profile
source ~/.bash_profile

Installer les dépendances requises

Créez un nouveau répertoire pour installer les dépendances PredictionIO telles que HBase, Sparket Elasticsearch.

mkdir /opt/PredictionIO-0.12.0-incubating/vendors

Téléchargez Scala version 2.11.8 et extrayez-le dans le vendorsrépertoire.

wget https://downloads.lightbend.com/scala/2.11.8/scala-2.11.8.tgz
tar xf scala-2.11.8.tgz -C /opt/PredictionIO-0.12.0-incubating/vendors

Téléchargez Apache Hadoop version 2.7.3 et extrayez-le dans le vendorsrépertoire.

wget https://archive.apache.org/dist/hadoop/common/hadoop-2.7.3/hadoop-2.7.3.tar.gz
tar xf hadoop-2.7.3.tar.gz -C /opt/PredictionIO-0.12.0-incubating/vendors

Apache Spark est le moteur de traitement par défaut de PredictionIO. Téléchargez Spark version 2.1.1 et extrayez-le dans le vendorsrépertoire.

wget https://archive.apache.org/dist/spark/spark-2.1.1/spark-2.1.1-bin-hadoop2.7.tgz
tar xf spark-2.1.1-bin-hadoop2.7.tgz -C /opt/PredictionIO-0.12.0-incubating/vendors

Téléchargez Elasticsearch version 5.5.2 et extrayez-le dans le vendorsrépertoire.

wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-5.5.2.tar.gz
tar xf elasticsearch-5.5.2.tar.gz -C /opt/PredictionIO-0.12.0-incubating/vendors

Enfin, téléchargez HBase version 1.2.6 et extrayez-le dans le vendorsrépertoire.

wget https://archive.apache.org/dist/hbase/stable/hbase-1.2.6-bin.tar.gz
tar xf hbase-1.2.6-bin.tar.gz -C /opt/PredictionIO-0.12.0-incubating/vendors

Ouvrez le hbase-site.xmlfichier de configuration pour configurer HBase pour qu'il fonctionne dans un environnement autonome.

nano /opt/PredictionIO-0.12.0-incubating/vendors/hbase-1.2.6/conf/hbase-site.xml

Recherchez le bloc de configuration vide et remplacez-le par la configuration suivante.

<configuration>
  <property>
    <name>hbase.rootdir</name>
    <value>file:///home/user/PredictionIO-0.12.0-incubating/vendors/hbase-1.2.6/data</value>
  </property>
  <property>
    <name>hbase.zookeeper.property.dataDir</name>
    <value>/home/user/PredictionIO-0.12.0-incubating/vendors/hbase-1.2.6/zookeeper</value>
  </property>
</configuration>

Le répertoire de données sera créé automatiquement par HBase. Modifiez le fichier d'environnement HBase pour définir le JAVA_HOMEchemin.

nano /opt/PredictionIO-0.12.0-incubating/vendors/hbase-1.2.6/conf/hbase-env.sh

Décommentez la ligne numéro 27 et définissez JAVA_HOMEle chemin de jrevotre installation Java. Vous pouvez trouver le chemin d'accès à l'exécutable JAVA à l'aide de la readlink -f $(which java)commande.

# The java implementation to use.  Java 1.7+ required.
export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.151-1.b12.el7_4.x86_64/jre

En outre, commentez les numéros de ligne 46 et 47 car ils ne sont pas requis pour JAVA 8.

# Configure PermSize. Only needed in JDK7. You can safely remove it for JDK8+
# export HBASE_MASTER_OPTS="$HBASE_MASTER_OPTS -XX:PermSize=128m -XX:MaxPermSize=128m"
# export HBASE_REGIONSERVER_OPTS="$HBASE_REGIONSERVER_OPTS -XX:PermSize=128m -XX:MaxPermSize=128m"

Configurer l'environnement PredictionIO

La configuration par défaut dans le fichier d'environnement PredictionIO pio-env.shsuppose que nous utilisons PostgreSQL ou MySQL. Comme nous avons utilisé HBase et Elasticsearch, nous devrons modifier presque toutes les configurations du fichier. Il est préférable d'effectuer une sauvegarde du fichier existant et de créer un nouveau fichier d'environnement PredictionIO.

mv /opt/PredictionIO-0.12.0-incubating/conf/pio-env.sh /opt/PredictionIO-0.12.0-incubating/conf/pio-env.sh.bak

Créez maintenant un nouveau fichier pour la configuration de l'environnement PredictionIO.

nano /opt/PredictionIO-0.12.0-incubating/conf/pio-env.sh

Remplissez le fichier avec la configuration suivante.

# PredictionIO Main Configuration
#
# This section controls core behavior of PredictionIO. It is very likely that
# you need to change these to fit your site.

# SPARK_HOME: Apache Spark is a hard dependency and must be configured.
SPARK_HOME=$PIO_HOME/vendors/spark-2.1.1-bin-hadoop2.7

# POSTGRES_JDBC_DRIVER=$PIO_HOME/lib/postgresql-42.0.0.jar
# MYSQL_JDBC_DRIVER=$PIO_HOME/lib/mysql-connector-java-5.1.41.jar

# ES_CONF_DIR: You must configure this if you have advanced configuration for
#              your Elasticsearch setup.
ES_CONF_DIR=$PIO_HOME/vendors/elasticsearch-5.5.2/config

# HADOOP_CONF_DIR: You must configure this if you intend to run PredictionIO
#                  with Hadoop 2.
HADOOP_CONF_DIR=$PIO_HOME/vendors/spark-2.1.1-bin-hadoop2.7/conf

# HBASE_CONF_DIR: You must configure this if you intend to run PredictionIO
#                 with HBase on a remote cluster.
HBASE_CONF_DIR=$PIO_HOME/vendors/hbase-1.2.6/conf

# Filesystem paths where PredictionIO uses as block storage.
PIO_FS_BASEDIR=$HOME/.pio_store
PIO_FS_ENGINESDIR=$PIO_FS_BASEDIR/engines
PIO_FS_TMPDIR=$PIO_FS_BASEDIR/tmp

# PredictionIO Storage Configuration
#
# This section controls programs that make use of PredictionIO's built-in
# storage facilities. Default values are shown below.
#
# For more information on storage configuration please refer to
# http://predictionio.incubator.apache.org/system/anotherdatastore/

# Storage Repositories

# Default is to use PostgreSQL
PIO_STORAGE_REPOSITORIES_METADATA_NAME=pio_meta
PIO_STORAGE_REPOSITORIES_METADATA_SOURCE=ELASTICSEARCH

PIO_STORAGE_REPOSITORIES_EVENTDATA_NAME=pio_event
PIO_STORAGE_REPOSITORIES_EVENTDATA_SOURCE=HBASE

PIO_STORAGE_REPOSITORIES_MODELDATA_NAME=pio_model
PIO_STORAGE_REPOSITORIES_MODELDATA_SOURCE=LOCALFS

# Storage Data Sources

# PostgreSQL Default Settings
# Please change "pio" to your database name in PIO_STORAGE_SOURCES_PGSQL_URL
# Please change PIO_STORAGE_SOURCES_PGSQL_USERNAME and
# PIO_STORAGE_SOURCES_PGSQL_PASSWORD accordingly
# PIO_STORAGE_SOURCES_PGSQL_TYPE=jdbc
# PIO_STORAGE_SOURCES_PGSQL_URL=jdbc:postgresql://localhost/pio
# PIO_STORAGE_SOURCES_PGSQL_USERNAME=pio
# PIO_STORAGE_SOURCES_PGSQL_PASSWORD=pio

# MySQL Example
# PIO_STORAGE_SOURCES_MYSQL_TYPE=jdbc
# PIO_STORAGE_SOURCES_MYSQL_URL=jdbc:mysql://localhost/pio
# PIO_STORAGE_SOURCES_MYSQL_USERNAME=pio
# PIO_STORAGE_SOURCES_MYSQL_PASSWORD=pio

# Elasticsearch Example
PIO_STORAGE_SOURCES_ELASTICSEARCH_TYPE=elasticsearch
PIO_STORAGE_SOURCES_ELASTICSEARCH_HOSTS=localhost
PIO_STORAGE_SOURCES_ELASTICSEARCH_PORTS=9200
PIO_STORAGE_SOURCES_ELASTICSEARCH_SCHEMES=http
PIO_STORAGE_SOURCES_ELASTICSEARCH_CLUSTERNAME=pio
PIO_STORAGE_SOURCES_ELASTICSEARCH_HOME=$PIO_HOME/vendors/elasticsearch-5.5.2

# Optional basic HTTP auth
# PIO_STORAGE_SOURCES_ELASTICSEARCH_USERNAME=my-name
# PIO_STORAGE_SOURCES_ELASTICSEARCH_PASSWORD=my-secret
# Elasticsearch 1.x Example
# PIO_STORAGE_SOURCES_ELASTICSEARCH_TYPE=elasticsearch
# PIO_STORAGE_SOURCES_ELASTICSEARCH_CLUSTERNAME=<elasticsearch_cluster_name>
# PIO_STORAGE_SOURCES_ELASTICSEARCH_HOSTS=localhost
# PIO_STORAGE_SOURCES_ELASTICSEARCH_PORTS=9300
# PIO_STORAGE_SOURCES_ELASTICSEARCH_HOME=$PIO_HOME/vendors/elasticsearch-1.7.6

# Local File System Example
PIO_STORAGE_SOURCES_LOCALFS_TYPE=localfs
PIO_STORAGE_SOURCES_LOCALFS_PATH=$PIO_FS_BASEDIR/models

# HBase Example
PIO_STORAGE_SOURCES_HBASE_TYPE=hbase
PIO_STORAGE_SOURCES_HBASE_HOME=$PIO_HOME/vendors/hbase-1.2.6

# AWS S3 Example
# PIO_STORAGE_SOURCES_S3_TYPE=s3
# PIO_STORAGE_SOURCES_S3_BUCKET_NAME=pio_bucket
# PIO_STORAGE_SOURCES_S3_BASE_PATH=pio_model

Enregistrez le fichier et quittez l'éditeur.

Ouvrez le fichier de configuration Elasticsearch.

nano /opt/PredictionIO-0.12.0-incubating/vendors/elasticsearch-5.5.2/config/elasticsearch.yml

Décommentez la ligne et définissez le nom du cluster exactement comme celui fourni dans le fichier d'environnement PredictionIO. Le nom du cluster est défini sur piodans la configuration ci-dessus.

# Use a descriptive name for your cluster:
#
cluster.name: pio

Ajoutez maintenant le $PIO_HOME/binrépertoire dans la variable PATH afin que les exécutables PredictionIO soient exécutés directement.

echo "export PATH=$PATH:$PIO_HOME/bin" >> ~/.bash_profile
source ~/.bash_profile

À ce stade, PredictionIO est installé avec succès sur votre serveur.

Démarrage de PredictionIO

Vous pouvez démarrer tous les services dans PredictionIO tels qu'Elasticsearch, HBase et le serveur d'événements à l'aide d'une seule commande.

pio-start-all

Vous verrez la sortie suivante.

[user@vultr ~]$ pio-start-all
Starting Elasticsearch...
Starting HBase...
starting master, logging to /opt/PredictionIO-0.12.0-incubating/vendors/hbase-1.2.6/bin/../logs/hbase-user-master-vultr.guest.out
Waiting 10 seconds for Storage Repositories to fully initialize...
Starting PredictionIO Event Server...

Utilisez la commande suivante pour vérifier l'état du serveur PredictionIO.

pio status

Vous verrez la sortie suivante.

[user@vultr ~]$ pio status
[INFO] [Management$] Inspecting PredictionIO...
[INFO] [Management$] PredictionIO 0.12.0-incubating is installed at /opt/PredictionIO-0.12.0-incubating
[INFO] [Management$] Inspecting Apache Spark...
[INFO] [Management$] Apache Spark is installed at /opt/PredictionIO-0.12.0-incubating/vendors/spark-2.1.1-bin-hadoop2.7
[INFO] [Management$] Apache Spark 2.1.1 detected (meets minimum requirement of 1.3.0)
[INFO] [Management$] Inspecting storage backend connections...
[INFO] [Storage$] Verifying Meta Data Backend (Source: ELASTICSEARCH)...
[INFO] [Storage$] Verifying Model Data Backend (Source: LOCALFS)...
[INFO] [Storage$] Verifying Event Data Backend (Source: HBASE)...
[INFO] [Storage$] Test writing to Event Store (App Id 0)...
[INFO] [HBLEvents] The namespace pio_event doesn't exist yet. Creating now...
[INFO] [HBLEvents] The table pio_event:events_0 doesn't exist yet. Creating now...
[INFO] [HBLEvents] Removing table pio_event:events_0...
[INFO] [Management$] Your system is all ready to go.

Comme nous pouvons le voir dans les messages ci-dessus, notre système est prêt à l'emploi pour implémenter un modèle de moteur et prévoir des données.

Implémentation d'un modèle de moteur

Plusieurs modèles de moteur prêts à l'emploi sont disponibles sur la galerie de modèles PredictionIO qui peuvent être facilement installés sur le serveur PredictionIO. Vous êtes libre de parcourir la liste des modèles de moteurs pour trouver celui qui correspond le mieux à vos besoins ou vous pouvez écrire votre propre moteur.

Dans ce didacticiel, nous allons implémenter le E-Commerce Recommendationmodèle de moteur pour démontrer la fonctionnalité du serveur PredictionIO à l'aide de quelques exemples de données. Ce modèle de moteur fournit des recommandations personnelles à un utilisateur dans un site Web de commerce électronique. Par défaut, il comporte des fonctionnalités telles que l'exclusion des articles en rupture de stock ou la fourniture de recommandations à un utilisateur qui s'inscrit après la formation du modèle. En outre, par défaut, le modèle de moteur prend la vue d'un utilisateur et achète des événements, des éléments avec des catégories et des propriétés et une liste d'éléments non disponibles. Une fois le moteur formé et déployé, vous pouvez envoyer une requête avec l'ID utilisateur et le nombre d'éléments à recommander. La sortie générée sera une liste classée des ID d'article recommandés.

Installez Git, car il sera utilisé pour cloner le référentiel.

cd ~    
sudo yum -y install git

Clonez le modèle de moteur de recommandation de commerce électronique sur votre système.

git clone https://github.com/apache/incubator-predictionio-template-ecom-recommender.git MyEComRecomm  

Créez une nouvelle application pour le moteur de modèle de recommandation de commerce électronique. Chaque application de PredictionIO est utilisée pour stocker les données d'un site Web distinct. Si vous avez plusieurs sites Web, vous pouvez créer plusieurs applications pour stocker les données de chaque site Web dans une application différente. Vous êtes libre de choisir n'importe quel nom pour votre application.

cd MyEComRecomm/
pio app new myecom

Vous verrez la sortie suivante.

[user@vultr MyEComRecomm]$ pio app new myecom
[INFO] [HBLEvents] The table pio_event:events_1 doesn't exist yet. Creating now...
[INFO] [App$] Initialized Event Store for this app ID: 1.
[INFO] [Pio$] Created a new app:
[INFO] [Pio$]       Name: myecom
[INFO] [Pio$]         ID: 1
[INFO] [Pio$] Access Key: a_DnDr4uyvjsKRldPoJAFMuPvb-QBz-BhUFyGehXoTKbm89r00Gx4ygnqspTJx4t

La sortie ci-dessus contient également la clé d'accès qui sera utilisée pour s'authentifier lors de l'envoi des données d'entrée au serveur d'événements.

Vous pouvez toujours trouver la clé d'accès avec la liste des applications disponibles en exécutant.

pio app list

Vous verrez la sortie suivante contenant une liste d'applications et la clé d'accès.

[user@vultr MyEComRecomm]$ pio app list
[INFO] [Pio$]                 Name |   ID |                                                       Access Key | Allowed Event(s)
[INFO] [Pio$]               myecom |    1 | a_DnDr4uyvjsKRldPoJAFMuPvb-QBz-BhUFyGehXoTKbm89r00Gx4ygnqspTJx4t | (all)
[INFO] [Pio$] Finished listing 1 app(s).

Maintenant que nous avons créé une nouvelle application, nous y ajouterons des données. Dans l'environnement de production, vous souhaitez envoyer automatiquement les données au serveur d'événements en intégrant l'API du serveur d'événements dans l'application. Pour savoir comment fonctionne PredictionIO, nous allons y importer des exemples de données. Le moteur de modèle fournit un script Python qui peut être facilement utilisé pour importer les exemples de données dans le serveur d'événements.

Installez pip Python.

sudo yum -y install python-pip
sudo pip install --upgrade pip

Installez PredictionIO Python SDK à l'aide de pip.

sudo pip install predictionio

Exécutez le script Python pour ajouter les exemples de données au serveur d'événements.

python data/import_eventserver.py --access_key a_DnDr4uyvjsKRldPoJAFMuPvb-QBz-BhUFyGehXoTKbm89r00Gx4ygnqspTJx4t

Assurez-vous de remplacer la clé d'accès par votre clé d'accès réelle. Vous verrez une sortie similaire.

[user@vultr MyEComRecomm]$ python data/import_eventserver.py --access_key a_DnDr4uyvjsKRldPoJAFMuPvb-QBz-BhUFyGehXoTKbm89r00Gx4ygnqspTJx4t
Namespace(access_key='a_DnDr4uyvjsKRldPoJAFMuPvb-QBz-BhUFyGehXoTKbm89r00Gx4ygnqspTJx4t', url='http://localhost:7070')
{u'status': u'alive'}
Importing data...
('Set user', 'u1')
('Set user', 'u2')

...

('User', 'u10', 'buys item', 'i30')
('User', 'u10', 'views item', 'i40')
('User', 'u10', 'buys item', 'i40')
204 events are imported.

Le script ci-dessus importe 10 utilisateurs, 50 articles dans 6 catégories et certains événements d'achat et de vues aléatoires. Pour vérifier si les événements sont importés ou non, vous pouvez exécuter la requête suivante.

curl -i -X GET "http://localhost:7070/events.json?accessKey=a_DnDr4uyvjsKRldPoJAFMuPvb-QBz-BhUFyGehXoTKbm89r00Gx4ygnqspTJx4t"

La sortie vous montrera la liste de tous les événements importés au format JSON.

Maintenant, ouvrez le engine.jsonfichier dans l'éditeur. Ce fichier contient la configuration du moteur.

nano engine.json

Recherchez les deux occurrences de appNameet remplacez la valeur par le nom réel de l'application que vous avez créée précédemment.

{
  "id": "default",
  "description": "Default settings",
  "engineFactory": "org.example.ecommercerecommendation.ECommerceRecommendationEngine",
  "datasource": {
    "params" : {
      "appName": "myecom"
    }
  },
  "algorithms": [
    {
      "name": "ecomm",
      "params": {
        "appName": "myecom",
        "unseenOnly": true,
        "seenEvents": ["buy", "view"],
        "similarEvents": ["view"],
        "rank": 10,
        "numIterations" : 20,
        "lambda": 0.01,
        "seed": 3
      }
    }
  ]
}

Générez l'application.

pio build --verbose

Si vous ne souhaitez pas voir les messages du journal, supprimez l' --verboseoption. La construction du modèle de moteur pour la première fois prendra quelques minutes. Vous verrez une sortie similaire lorsque la génération se termine avec succès.

[user@vultr MyEComRecomm]$ pio build --verbose
[INFO] [Engine$] Using command '/opt/PredictionIO-0.12.0-incubating/sbt/sbt' at /home/user/MyEComRecomm to build.

...

[INFO] [Engine$] Build finished successfully.
[INFO] [Pio$] Your engine is ready for training.

Entraînez le moteur maintenant. Pendant la formation, le moteur analyse l'ensemble de données et s'entraîne selon l'algorithme fourni.

pio train

Avant de déployer l'application, nous devons ouvrir le port 8000afin que l'état de l'application puisse être affiché sur l'interface graphique Web. De plus, les sites Web et applications utilisant le serveur d'événements enverront et recevront leurs requêtes via ce port.

sudo firewall-cmd --zone=public --permanent --add-port=8000/tcp
sudo firewall-cmd --reload

Vous pouvez maintenant déployer le moteur PredictionIO.

pio deploy

La commande ci-dessus déploiera le moteur et le serveur Web intégré sur le port 8000pour répondre aux requêtes des sites Web et des applications de commerce électronique. Vous verrez la sortie suivante à la fin une fois le moteur déployé avec succès.

[INFO] [HttpListener] Bound to /0.0.0.0:8000
[INFO] [MasterActor] Engine is deployed and running. Engine API is live at http://0.0.0.0:8000.

Vous pouvez vérifier l'état du moteur en http://192.0.2.1:8000utilisant n'importe quel navigateur moderne. Assurez-vous que vous remplacez 192.0.2.1par votre adresse IP Vultr réelle.

Cela signifie que le modèle de moteur de recommandation de commerce électronique est déployé et s'exécute correctement. Vous pouvez interroger le modèle de moteur pour récupérer cinq recommandations pour l'utilisateur u5en exécutant la requête suivante dans une nouvelle session de terminal.

curl -H "Content-Type: application/json" \
-d '{ "user": "u5", "num": 5 }' \
http://localhost:8000/queries.json

Vous verrez les recommandations générées pour l'utilisateur u5.

[user@vultr ~]$ curl -H "Content-Type: application/json" \
> -d '{ "user": "u5", "num": 5 }' \
> http://localhost:8000/queries.json
{"itemScores":[{"item":"i25","score":0.9985169366745619},{"item":"i10","score":0.996613946803819},{"item":"i27","score":0.996613946803819},{"item":"i17","score":0.9962796867639341},{"item":"i8","score":0.9955868705972656}]}

Emballer

Félicitations, Apache PredictionIO a été déployé avec succès sur votre serveur. Vous pouvez désormais utiliser l'API du serveur d'événements pour importer les données dans le moteur afin de prédire les recommandations pour l'utilisateur. Si vous le souhaitez, vous pouvez utiliser d'autres modèles de la galerie de modèles. Assurez-vous de consulter le modèle de moteur Universal Recommender qui peut être utilisé dans presque tous les cas d'utilisation, y compris le commerce électronique, les actualités ou la vidéo.