Come installare e utilizzare Apache PredictionIO per lapprendimento automatico su CentOS 7

• Prerequisiti
• Installa Java
• Installa PredictionIO
• Installa dipendenze richieste
• Configurare l'ambiente PredictionIO
• Avvio di PredictionIO
• Implementazione di un modello di motore
• Avvolgendo

Gli approcci tradizionali all'analisi dei dati sono impossibili da usare quando i set di dati raggiungono una certa dimensione. Un'alternativa moderna all'analisi delle enormi serie di dati sta usando i metodi di apprendimento automatico. L'apprendimento automatico è in grado di produrre risultati accurati quando si utilizza un algoritmo rapido ed efficiente.

Apache PredictionIO è un server di machine learning open source utilizzato per creare motori predittivi per qualsiasi attività di machine learning. Riduce il tempo di applicazione dell'apprendimento automatico dal laboratorio alla produzione utilizzando modelli di motore personalizzabili che possono essere creati e distribuiti rapidamente. Fornisce la raccolta dei dati e serve i componenti e estrae la tecnologia sottostante per esporre un'API che consente agli sviluppatori di concentrarsi sui componenti di trasformazione. Una volta che il server motore di PredictionIO è distribuito come servizio Web, può rispondere a query dinamiche in tempo reale.

Apache PredictionIO è costituito da diversi componenti.

• Piattaforma PredictionIO : uno stack di apprendimento automatico open source costruito sulla cima di alcune applicazioni open source all'avanguardia come Apache Spark, Apache Hadoop, Apache HBase ed Elasticsearch.
• Server degli eventi : raccoglie continuamente dati dal server Web o dal server delle applicazioni mobile in modalità in tempo reale o in modalità batch. I dati raccolti possono essere utilizzati per addestrare il motore o per fornire una vista unificata per l'analisi dei dati. Il server degli eventi utilizza Apache HBase per archiviare i dati.
• Server del motore : il server del motore è responsabile dell'effettiva previsione. Legge i dati di training dall'archivio dati e utilizza uno o più algoritmi di machine learning per la creazione di modelli predittivi. Un motore, una volta distribuito come servizio Web, risponde alle query fatte da un'app Web o mobile utilizzando l'API REST o l'SDK.
• Galleria dei modelli : questa galleria offre vari tipi di modelli di motori predefiniti. Puoi scegliere un modello simile al tuo caso d'uso e modificarlo in base alle tue esigenze.

Prerequisiti

• Un'istanza del server Vultr CentOS 7 con almeno 8 GB di RAM. A scopo di test e sviluppo, è possibile scegliere un'istanza con 4 GB di RAM e un'altra memoria di scambio da 4 GB .
• Un utente sudo .

In questo tutorial, useremo 192.0.2.1come indirizzo IP pubblico del server. Sostituisci tutte le occorrenze di 192.0.2.1con il tuo indirizzo IP pubblico Vultr.

Aggiorna il tuo sistema di base usando la guida Come aggiornare CentOS 7 . Dopo aver aggiornato il sistema, procedere con l'installazione di Java.

Installa Java

Molti dei componenti di PredictionIO richiedono JDK, o Java Development Kit, versione 8 per funzionare. Supporta sia OpenJDK che Oracle Java. In questo tutorial, installeremo OpenJDK versione 8.

OpenJDK può essere facilmente installato, poiché il pacchetto è disponibile nel repository YUM predefinito.

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

Verifica la versione di Java per assicurarti che sia stata installata correttamente.

java -version

Otterrai un risultato simile.

[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)

Prima di poter procedere oltre, dovremo impostare le variabili di ambiente JAVA_HOMEe JRE_HOME. Trova il percorso assoluto dell'eseguibile JAVA nel tuo sistema.

readlink -f $(which java)

Vedrai un risultato simile.

[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

Ora, impostare JAVA_HOMEe JRE_HOMEla variabile di ambiente in base al percorso della directory 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

Esegui il bash_profilefile.

source ~/.bash_profile

Ora puoi eseguire il echo $JAVA_HOMEcomando per verificare se la variabile di ambiente è impostata.

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

Installa PredictionIO

Apache fornisce file di origine PredictionIO che possono essere scaricati e compilati localmente. Creare una nuova directory temporanea per scaricare e compilare il file di origine.

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

Scarica l'archivio dei file di origine di PredictionIO utilizzando qualsiasi sito Apache Mirror .

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

Estrarre l'archivio e compilare l'origine per creare una distribuzione di PredictionIO.

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

La distribuzione di cui sopra sarà costruito contro le versioni predefinite delle dipendenze, che sono Scala 2.11.8, Spark 2.1.1, Hadoop 2.7.3e ElasticSearch 5.5.2. Attendere il completamento della compilazione, per il completamento della procedura saranno necessari circa dieci minuti.

Nota : sei libero di utilizzare l'ultima versione supportata delle dipendenze, ma potresti visualizzare alcuni avvisi durante la compilazione poiché alcune funzioni potrebbero essere obsolete. Esegui ./make-distribution.sh -Dscala.version=2.11.11 -Dspark.version=2.1.2 -Dhadoop.version=2.7.4 -Delasticsearch.version=5.5.3, sostituendo il numero di versione in base alla tua scelta.

Una volta completata la compilazione, alla fine verrà visualizzato il seguente messaggio.

...
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

I file binari di PredictionIO verranno salvati PredictionIO-0.12.0-incubating.tar.gznell'archivio. Estrarre l'archivio nella /optdirectory e fornire la proprietà all'utente corrente.

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

Imposta la PIO_HOMEvariabile d'ambiente.

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

Installa dipendenze richieste

Creare una nuova directory per installare dipendenze PredictionIO come HBase, Sparke Elasticsearch.

mkdir /opt/PredictionIO-0.12.0-incubating/vendors

Scarica Scala versione 2.11.8 ed estrailo nella vendorsdirectory.

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

Scarica Apache Hadoop versione 2.7.3 ed estrailo nella vendorsdirectory.

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 è il motore di elaborazione predefinito per PredictionIO. Scarica Spark versione 2.1.1 ed estrailo nella vendorsdirectory.

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

Scarica Elasticsearch versione 5.5.2 ed estrailo nella vendorsdirectory.

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

Infine, scarica HBase versione 1.2.6 ed estrailo nella vendorsdirectory.

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

Apri il hbase-site.xmlfile di configurazione per configurare HBase in modo che funzioni in un ambiente autonomo.

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

Trova il blocco di configurazione vuoto e sostituiscilo con la seguente configurazione.

<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>

La directory dei dati verrà creata automaticamente da HBase. Modifica il file di ambiente HBase per impostare il JAVA_HOMEpercorso.

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

Scollega la riga numero 27 e imposta JAVA_HOMEil percorso jredell'installazione Java. È possibile trovare il percorso dell'eseguibile JAVA usando il readlink -f $(which java)comando

# 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

Inoltre, commentare i numeri di riga 46 e 47 in quanto non sono richiesti per 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"

Configurare l'ambiente PredictionIO

La configurazione predefinita nel file di ambiente PredictionIO pio-env.shpresuppone che stiamo usando PostgreSQL o MySQL. Poiché abbiamo utilizzato HBase ed Elasticsearch, dovremo modificare quasi tutte le configurazioni nel file. È meglio eseguire un backup del file esistente e creare un nuovo file di ambiente PredictionIO.

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

Ora crea un nuovo file per la configurazione dell'ambiente PredictionIO.

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

Popolare il file con la seguente configurazione.

# 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

Salvare il file ed uscire dall'editor.

Apri il file di configurazione di Elasticsearch.

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

Rimuovi il commento dalla riga e imposta il nome del cluster esattamente uguale a quello fornito nel file di ambiente PredictionIO. Il nome del cluster è impostato pionella configurazione sopra.

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

Ora aggiungi la $PIO_HOME/bindirectory nella variabile PATH in modo che gli eseguibili PredictionIO vengano eseguiti direttamente.

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

A questo punto, PredictionIO è installato correttamente sul tuo server.

Avvio di PredictionIO

Puoi avviare tutti i servizi in PredictionIO come Elasticsearch, HBase ed Event Server usando un solo comando.

pio-start-all

Vedrai il seguente output.

[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...

Utilizzare il comando seguente per verificare lo stato del server PredictionIO.

pio status

Vedrai il seguente output.

[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.

Come possiamo vedere nei messaggi sopra, il nostro sistema è pronto per l'uso per l'implementazione di un modello di motore e la previsione dei dati.

Implementazione di un modello di motore

Diversi modelli di motori pronti all'uso sono disponibili nella Galleria dei modelli di PredictionIO che può essere facilmente installata sul server PredictionIO. Sei libero di sfogliare l'elenco dei modelli di motore per trovare quello più vicino alle tue esigenze oppure puoi scrivere il tuo motore.

In questo tutorial, implementeremo il E-Commerce Recommendationmodello di motore per dimostrare la funzionalità del server PredictionIO utilizzando alcuni dati di esempio. Questo modello di motore fornisce alcune raccomandazioni personali a un utente in un sito Web di e-commerce. Per impostazione predefinita, ha funzionalità come l'esclusione di articoli esauriti o la fornitura di consigli a un utente che si iscrive dopo la formazione del modello. Inoltre, per impostazione predefinita, il modello di motore consente all'utente di visualizzare e acquistare eventi, elementi con categorie e proprietà e un elenco di elementi non disponibili. Una volta che il motore è stato addestrato e distribuito, è possibile inviare una query con l'id utente e il numero di elementi da raccomandare. L'output generato sarà un elenco classificato degli ID articolo consigliati.

Installa Git, poiché verrà usato per clonare il repository.

cd ~    
sudo yum -y install git

Clonare il modello del motore di raccomandazione e-commerce sul sistema.

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

Creare una nuova applicazione per il motore di modello di raccomandazione e-commerce. Ogni applicazione in PredictionIO viene utilizzata per archiviare i dati per un sito Web separato. Se si dispone di più siti Web, è possibile creare più app per archiviare i dati di ciascun sito Web in un'applicazione diversa. Sei libero di scegliere qualsiasi nome per la tua applicazione.

cd MyEComRecomm/
pio app new myecom

Vedrai il seguente output.

[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

L'output sopra contiene anche la chiave di accesso che verrà utilizzata per l'autenticazione durante l'invio dei dati di input al server degli eventi.

Puoi sempre trovare la chiave di accesso insieme all'elenco delle applicazioni disponibili eseguendo.

pio app list

Vedrai il seguente output contenente un elenco di applicazioni e la chiave di accesso.

[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).

Ora che abbiamo creato una nuova applicazione, aggiungeremo alcuni dati ad essa. Nell'ambiente di produzione, si desidera inviare automaticamente i dati al server degli eventi integrando l'API del server degli eventi nell'applicazione. Per sapere come funziona PredictionIO, importeremo alcuni dati di esempio al suo interno. Il motore modello fornisce uno script Python che può essere facilmente utilizzato per importare i dati di esempio nel server degli eventi.

Installa pip Python.

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

Installa PredictionIO Python SDK usando pip.

sudo pip install predictionio

Esegui lo script Python per aggiungere i dati di esempio al server degli eventi.

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

Assicurarsi di sostituire la chiave di accesso con la chiave di accesso effettiva. Vedrai un risultato simile.

[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.

Lo script precedente importa 10 utenti, 50 articoli in 6 categorie e alcuni eventi casuali di acquisto e visualizzazioni. Per verificare se gli eventi sono importati o meno, è possibile eseguire la seguente query.

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

L'output mostrerà l'elenco di tutti gli eventi importati in formato JSON.

Ora apri il engine.jsonfile nell'editor. Questo file contiene la configurazione del motore.

nano engine.json

Trova entrambe le occorrenze appNamee sostituisci il valore con il nome effettivo dell'app che hai creato in precedenza.

{
  "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
      }
    }
  ]
}

Costruisci l'applicazione.

pio build --verbose

Se non si desidera visualizzare i messaggi di registro, rimuovere l' --verboseopzione. La creazione del modello di motore per la prima volta richiederà alcuni minuti. Vedrai un output simile al termine della compilazione.

[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.

Allena il motore adesso. Durante l'addestramento, il motore analizza il set di dati e si allena in base all'algoritmo fornito.

pio train

Prima di distribuire l'applicazione, sarà necessario aprire la porta in 8000modo che lo stato dell'applicazione possa essere visualizzato sulla GUI Web. Inoltre, i siti Web e le applicazioni che utilizzano il server degli eventi invieranno e riceveranno le loro query tramite questa porta.

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

Ora puoi distribuire il motore PredictionIO.

pio deploy

Il comando precedente distribuirà il motore e il server Web integrato sulla porta 8000per rispondere alle domande dei siti Web e delle applicazioni di e-commerce. Alla fine verrà visualizzato il seguente output una volta che il motore è stato distribuito correttamente.

[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.

Puoi verificare lo stato del motore andando a http://192.0.2.1:8000utilizzare qualsiasi browser moderno. Assicurati di sostituire 192.0.2.1con il tuo attuale indirizzo IP Vultr.

Ciò significa che il modello di motore per la raccomandazione e-commerce è distribuito e in esecuzione correttamente. È possibile eseguire una query sul modello del motore per recuperare cinque consigli per l'utente u5eseguendo la seguente query in una nuova sessione del terminale.

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

Vedrai i consigli generati per l'utente 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}]}

Avvolgendo

Congratulazioni, Apache PredictionIO è stato distribuito correttamente sul tuo server. È ora possibile utilizzare l'API del server degli eventi per importare i dati nel motore per prevedere i consigli per l'utente. Se lo desideri, puoi utilizzare alcuni altri modelli dalla galleria dei modelli. Assicurati di dare un'occhiata al modello di motore di Universal Raccomandatore che può essere utilizzato in quasi tutti i casi d'uso incluso e-commerce, notizie o video.