Cum se instalează și se utilizează Apache PredictionIO pentru învățarea mașinii pe CentOS 7

• Cerințe preliminare
• Instalați Java
• Instalați PredictionIO
• Instalează dependențele obligatorii
• Configurați mediul PredictionIO
• Începând Predicția
• Implementarea unui șablon motor
• Înveliți

Abordările tradiționale de analiză a datelor sunt imposibil de utilizat atunci când seturile de date ating o anumită dimensiune. O alternativă modernă la analiza seturilor uriașe de date este utilizarea metodelor de învățare automată. Învățarea automată este capabilă să producă rezultate precise atunci când utilizați un algoritm rapid și eficient.

Apache PredictionIO este un server open source de învățare a mașinilor, folosit pentru a crea motoare predictive pentru orice sarcină de învățare automată. Acesta scurtează timpul aplicării învățării automate de la laborator la producție, folosind șabloane personalizate ale motorului care pot fi construite și implementate rapid. Oferă componentele de colectare și servire a datelor și rezumă tehnologia care stă la baza expunerii unei API care permite dezvoltatorilor să se concentreze pe componentele de transformare. Odată ce serverul motor al PredictionIO este implementat ca un serviciu web, acesta poate răspunde la întrebări dinamice în timp real.

Predice Apache constă din diferite componente.

• Platforma PredictionIO : o stivă de învățare a mașinilor open source, construită pe partea de sus a unei aplicații open-source de ultimă generație, precum Apache Spark, Apache Hadoop, Apache HBase și Elasticsearch.
• Server de evenimente : acesta colectează continuu date de pe serverul dvs. web sau serverul de aplicații mobile în modul în timp real sau în mod lot. Datele colectate pot fi utilizate pentru a antrena motorul sau pentru a oferi o vedere unificată pentru analiza datelor. Serverul de evenimente folosește Apache HBase pentru a stoca datele.
• Serverul motorului : Serverul motorului este responsabil pentru realizarea predicției reale. Citește datele de instruire din depozitul de date și folosește unul sau mai mulți algoritmi de învățare automată pentru construirea modelelor predictive. Un motor, odată implementat ca serviciu web, răspunde la întrebările făcute de o aplicație web sau mobilă folosind API REST sau SDK.
• Galeria de șabloane : Această galerie oferă diferite tipuri de șabloane de motor pre-construite. Puteți alege un șablon care este similar cu cazul dvs. de utilizare și să-l modificați în funcție de cerințele dvs.

Cerințe preliminare

• O instanță a serverului Vultr CentOS 7 cu cel puțin 8 GB RAM. În scop de testare și dezvoltare, puteți alege o instanță cu 4 GB RAM și o altă memorie swap de 4 GB .
• Un utilizator sudo .

În acest tutorial, vom folosi 192.0.2.1ca adresă IP publică a serverului. Înlocuiți toate aparițiile 192.0.2.1cu adresa dvs. IP publică Vultr.

Actualizați-vă sistemul de bază utilizând ghidul Cum actualizați CentOS 7 . După ce sistemul dvs. a fost actualizat, continuați să instalați Java.

Instalați Java

Multe dintre componentele PredictionIO necesită JDK sau Java Development Kit, versiunea 8 pentru a funcționa. Acceptă atât OpenJDK cât și Oracle Java. În acest tutorial, vom instala versiunea 8 a OpenJDK.

OpenJDK poate fi instalat cu ușurință, deoarece pachetul este disponibil în depozitul YUM implicit.

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

Verificați versiunea Java pentru a vă asigura că a fost instalată corect.

java -version

Veți obține o ieșire similară.

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

Înainte de a putea merge mai departe, va trebui să stabilim variabilele JAVA_HOMEși JRE_HOMEmediul. Găsiți calea absolută a executării JAVA în sistemul dvs.

readlink -f $(which java)

Veți vedea o ieșire similară.

[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

Acum, setați JAVA_HOMEși JRE_HOMEvariabila de mediu în funcție de calea directorului 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

Executați bash_profilefișierul.

source ~/.bash_profile

Acum puteți rula echo $JAVA_HOMEcomanda pentru a verifica dacă variabila de mediu este setată.

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

Instalați PredictionIO

Apache oferă fișiere sursă PredictionIO care pot fi descărcate și compilate local. Creați un nou director temporar pentru a descărca și compila fișierul sursă.

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

Descărcați arhiva de fișiere sursă PredictionIO folosind orice site Apache Mirror .

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

Extrageți arhiva și compilați sursa pentru a crea o distribuție a PredictionIO.

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

Distribuția de mai sus va fi construit în versiunile implicite ale dependențelor, care sunt Scala 2.11.8, Spark 2.1.1, Hadoop 2.7.3și ElasticSearch 5.5.2. Așteptați ca finalizarea construcției să dureze aproximativ zece minute, în funcție de performanțele sistemului.

Notă : Aveți libertatea de a utiliza cea mai recentă versiune acceptată a dependențelor, dar puteți vedea unele avertismente în timpul compilării, deoarece unele funcții ar putea fi depășite. Rulați ./make-distribution.sh -Dscala.version=2.11.11 -Dspark.version=2.1.2 -Dhadoop.version=2.7.4 -Delasticsearch.version=5.5.3, înlocuind numărul versiunii în funcție de alegerea dvs.

După terminarea cu succes a construirii, veți vedea următorul mesaj la sfârșit.

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

Fișierele binare PredictionIO vor fi salvate în PredictionIO-0.12.0-incubating.tar.gzarhivă. Extrageți arhiva din /optdirector și oferiți proprietatea utilizatorului curent.

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

Setați PIO_HOMEvariabila de mediu.

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

Instalează dependențele obligatorii

Creați un nou director pentru a instala PredictionIO dependențe , cum ar fi HBase, Sparkși Elasticsearch.

mkdir /opt/PredictionIO-0.12.0-incubating/vendors

Descărcați versiunea Scala 2.11.8 și extrageți-o în vendorsdirector.

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

Descărcați Apache Hadoop versiunea 2.7.3 și extrageți-l în vendorsdirector.

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 este motorul implicit de procesare pentru PredictionIO. Descărcați Spark versiunea 2.1.1 și extrageți-l în vendorsdirector.

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

Descărcați Elasticsearch versiunea 5.5.2 și extrageți-l în vendorsdirector.

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

În cele din urmă, descărcați HBase versiunea 1.2.6 și extrageți-l în vendorsdirector.

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

Deschideți hbase-site.xmlfișierul de configurare pentru a configura HBase să funcționeze într-un mediu autonom.

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

Găsiți blocul de configurare gol și înlocuiți-l cu următoarea configurație.

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

Directorul de date va fi creat automat de HBase. Editați fișierul de mediu HBase pentru a seta JAVA_HOMEcalea.

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

Numărul de linie 27 de dezacord și setați JAVA_HOMEcalea jreinstalării dvs. Java. Puteți găsi calea către executabilul JAVA folosind readlink -f $(which java)comanda.

# 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

De asemenea, comentează numerele de linie 46 și 47, deoarece acestea nu sunt obligatorii pentru 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"

Configurați mediul PredictionIO

Configurația implicită în fișierul de mediu PredictionIO pio-env.shpresupune că folosim PostgreSQL sau MySQL. Deoarece am folosit HBase și Elasticsearch, va trebui să modificăm aproape fiecare configurație a fișierului. Cel mai bine este să iei o copie de rezervă a fișierului existent și să creezi un nou fișier de mediu PredictionIO.

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

Acum creează un nou fișier pentru configurarea mediului PredictionIO.

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

Populați fișierul cu următoarea configurație.

# 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

Salvați fișierul și ieșiți din editor.

Deschideți fișierul de configurare Elasticsearch.

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

Deconectați linia și setați numele clusterului exact ca acela furnizat în fișierul de mediu PredictionIO. Numele clusterului este setat pioîn configurația de mai sus.

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

Acum adăugați $PIO_HOME/bindirectorul în variabila PATH, astfel încât executabilele PredictionIO să fie executate direct.

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

În acest moment, PredictionIO este instalat cu succes pe serverul dvs.

Începând Predicția

Puteți porni toate serviciile din PredictionIO cum ar fi Elasticsearch, HBase și serverul de evenimente folosind o singură comandă.

pio-start-all

Veți vedea următoarea ieșire.

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

Utilizați următoarea comandă pentru a verifica starea serverului PredictionIO.

pio status

Veți vedea următoarea ieșire.

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

După cum putem vedea în mesajele de mai sus, sistemul nostru este gata de utilizare pentru implementarea unui șablon de motor și prezicerea datelor.

Implementarea unui șablon motor

Mai multe șabloane gata de utilizare a motorului sunt disponibile pe Galeria de șabloane PredictionIO, care poate fi instalată cu ușurință pe serverul PredictionIO. Puteți naviga pe lista șabloanelor motorului pentru a-l găsi pe cel care se apropie de cerințele dvs. sau vă puteți scrie propriul motor.

În acest tutorial, vom implementa E-Commerce Recommendationșablonul motorului pentru a demonstra funcționalitatea serverului PredictionIO folosind câteva exemple de date. Acest model de motor oferă câteva recomandări personale utilizatorului de pe un site web de comerț electronic. În mod implicit, acesta are caracteristici, cum ar fi excluderea articolelor din stoc sau furnizarea de recomandări unui utilizator care se înscrie după instruirea modelului. De asemenea, în mod implicit, șablonul motorului preia vizualizarea utilizatorului și cumpără evenimente, articole cu categorii și proprietăți și listă de articole indisponibile. După ce motorul a fost instruit și folosit, puteți trimite o interogare cu ID-ul de utilizator și numărul de articole care trebuie recomandate. Produsul generat va fi o listă clasificată a ID-urilor de articol recomandate.

Instalați Git, deoarece va fi folosit pentru clonarea depozitului.

cd ~    
sudo yum -y install git

Clonați șablonul de motor al E-Commerce Recommender pe sistemul dvs.

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

Creați o nouă aplicație pentru motorul șablonului Recomandare comerțului electronic. Fiecare aplicație din PredictionIO este folosită pentru a stoca datele pentru un site web separat. Dacă aveți mai multe site-uri web, atunci puteți crea mai multe aplicații pentru a stoca datele fiecărui site web într-o aplicație diferită. Puteți alege orice nume pentru aplicația dvs.

cd MyEComRecomm/
pio app new myecom

Veți vedea următoarea ieșire.

[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

Ieșirea de mai sus conține, de asemenea, cheia de acces care va fi folosită pentru autentificarea la trimiterea datelor de intrare către serverul de evenimente.

Puteți găsi întotdeauna cheia de acces împreună cu lista de aplicații disponibile rulând.

pio app list

Veți vedea următoarea ieșire care conține o listă de aplicații și cheia de acces.

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

Acum, după ce am creat o aplicație nouă, vom adăuga câteva date. În mediul de producție, doriți să trimiteți automat datele către serverul de evenimente prin integrarea API-ului serverului de evenimente în aplicație. Pentru a afla cum funcționează PredictionIO, vom importa câteva date-eșantion în el. Motorul de șabloane oferă un script Python care poate fi utilizat cu ușurință pentru a importa datele de probă în serverul de evenimente.

Instalați Python pip.

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

Instalați PredictionIO Python SDK folosind pip.

sudo pip install predictionio

Rulați scriptul Python pentru a adăuga datele de probă pe serverul de evenimente.

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

Asigurați-vă că înlocuiți cheia de acces cu cheia de acces reală. Veți vedea o ieșire similară.

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

Scriptul de mai sus importă 10 utilizatori, 50 de articole din 6 categorii și unele evenimente aleatoare de cumpărare și vizualizări. Pentru a verifica dacă evenimentele sunt importate sau nu, puteți rula următoarea interogare.

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

Rezultatul vă va afișa lista cu toate evenimentele importate în format JSON.

Acum, deschideți engine.jsonfișierul în editor. Acest fișier conține configurația motorului.

nano engine.json

Găsiți atât aparițiile appNameși înlocuiți valoarea cu numele real al aplicației pe care ați creat-o anterior.

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

Construiți aplicația.

pio build --verbose

Dacă nu doriți să vedeți mesajele de jurnal, eliminați --verboseopțiunea. Construirea șablonului motorului pentru prima dată va dura câteva minute. Veți vedea o ieșire similară când se finalizează cu succes construcția.

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

Antrenează motorul acum. În timpul antrenamentului, motorul analizează setul de date și se antrenează în conformitate cu algoritmul furnizat.

pio train

Înainte de a implementa aplicația, va trebui să deschidem portul 8000astfel încât starea aplicației să poată fi vizualizată pe GUI-ul Web. De asemenea, site-urile web și aplicațiile care utilizează serverul de evenimente vor trimite și primi întrebările prin acest port.

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

Acum puteți deplasa motorul PredictionIO.

pio deploy

Comanda de mai sus va implementa motorul și serverul web încorporat pe port 8000pentru a răspunde la întrebările de pe site-urile și aplicațiile de comerț electronic. La sfârșit, veți vedea următoarea ieșire odată ce motorul este instalat cu succes.

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

Puteți verifica starea motorului accesând http://192.0.2.1:8000orice browser modern. Asigurați-vă că înlocuiți 192.0.2.1cu adresa dvs. IP reală Vultr.

Aceasta înseamnă că șablonul motorului pentru recomandarea comerțului electronic este implementat și funcționează cu succes. Puteți interoga șablonul motorului pentru a obține cinci recomandări pentru utilizator, u5rulând următoarea interogare într-o nouă sesiune de terminal.

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

Veți vedea recomandările generate pentru utilizator 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}]}

Înveliți

Felicitări, Apache PredictionIO a fost implementat cu succes pe serverul dvs. Acum puteți utiliza API-ul serverului de evenimente pentru a importa datele în motor pentru a prezice recomandările pentru utilizator. Dacă doriți, puteți utiliza câteva alte șabloane din galeria de șabloane. Asigurați-vă că consultați șablonul motorului Universal Recommender , care poate fi utilizat în aproape toate cazurile de utilizare, inclusiv comerțul electronic, știri sau videoclipuri.