Hvordan installere og bruke Apache PredictionIO for maskinlæring på CentOS 7

Tradisjonelle tilnærminger til dataanalyse er umulige å bruke når datasett når en viss størrelse. Et moderne alternativ til å analysere de enorme datasettene med data er å bruke maskinlæringsmetoder. Maskinlæring er i stand til å produsere nøyaktige resultater når du bruker en rask og effektiv algoritme.

Apache PredictionIO er en åpen kildekode maskinlæringsserver som brukes til å lage prediktive motorer for enhver maskinlæringsoppgave. Det forkorter tiden for maskinlæringsapplikasjoner fra laboratorium til produksjon ved å bruke tilpassbare motormaler som kan bygges og distribueres raskt. Det gir datainnsamling og serveringskomponenter, og abstraherer underliggende teknologi for å avsløre et API som lar utviklere fokusere på transformasjonskomponenter. Når motorserveren til PredictionIO er distribuert som en webtjeneste, kan den svare på dynamiske forespørsler i sanntid.

Apache PredictionIO består av forskjellige komponenter.

• PredictionIO Platform : En åpen kildekode maskinlæringsstabel bygget på toppen av noen toppmoderne åpen kildekodeapplikasjoner som Apache Spark, Apache Hadoop, Apache HBase og Elasticsearch.
• Hendelsesserver : Denne samler kontinuerlig data fra din webserver eller mobilapplikasjonsserver i sanntidsmodus eller batchmodus. De innsamlede dataene kan brukes til å trene motoren eller for å gi en enhetlig visning for dataanalyse. Hendelsesserveren bruker Apache HBase til å lagre dataene.
• Motorserver : Motorserveren er ansvarlig for å lage selve prediksjonen. Den leser treningsdataene fra datalageret og bruker en eller flere maskinlæringsalgoritmer for å bygge de prediktive modellene. En motor, når den er distribuert som en nettjeneste, svarer på forespørslene fra en nett- eller mobilapp ved hjelp av REST API eller SDK.
• Malgalleri : Dette galleriet tilbyr ulike typer forhåndsbygde motormaler. Du kan velge en mal som ligner din brukssituasjon og endre den i henhold til dine krav.

Forutsetninger

• En Vultr CentOS 7-serverforekomst med minst 8 GB RAM. For test- og utviklingsformål kan du velge en instans med 4 GB RAM og et annet 4 GB bytteminne .
• En sudo-bruker .

I denne opplæringen vil vi bruke 192.0.2.1som den offentlige IP-adressen til serveren. Erstatt alle forekomster av 192.0.2.1med din Vultr offentlige IP-adresse.

Oppdater basissystemet ditt ved å bruke veiledningen Hvordan oppdatere CentOS 7 . Når systemet ditt har blitt oppdatert, fortsett å installere Java.

Installer Java

Mange av komponentene i PredictionIO krever JDK, eller Java Development Kit, versjon 8 for å fungere. Den støtter både OpenJDK og Oracle Java. I denne opplæringen vil vi installere OpenJDK versjon 8.

OpenJDK kan enkelt installeres, siden pakken er tilgjengelig i standard YUM-depot.

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

Bekreft Javas versjon for å sikre at den ble riktig installert.

java -version

Du vil få en lignende utgang.

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

Før vi kan gå videre, må vi sette opp JAVA_HOMEog JRE_HOMEmiljøvariablene. Finn den absolutte banen til den kjørbare JAVA-filen i systemet ditt.

readlink -f $(which java)

Du vil se en lignende utgang.

[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

Sett nå JAVA_HOMEog JRE_HOMEmiljøvariabel i henhold til banen til Java-katalogen.

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

Kjør bash_profilefilen.

source ~/.bash_profile

Nå kan du kjøre echo $JAVA_HOMEkommandoen for å sjekke om miljøvariabelen er satt.

[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 gir PredictionIO-kildefiler som kan lastes ned og kompileres lokalt. Opprett en ny midlertidig katalog for å laste ned og kompilere kildefilen.

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

Last ned PredictionIO-kildefilarkivet ved å bruke et hvilket som helst Apache Mirror-nettsted .

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

Trekk ut arkivet og kompiler kilden for å lage en distribusjon av PredictionIO.

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

Distribusjonen ovenfor vil bygges mot standardversjonene av avhengighetene, som er Scala 2.11.8, Spark 2.1.1, Hadoop 2.7.3og ElasticSearch 5.5.2. Vent til byggingen er ferdig, det vil ta rundt ti minutter å fullføre, avhengig av systemets ytelse.

Merk : Du står fritt til å bruke den siste støttede versjonen av avhengighetene, men du kan se noen advarsler under byggingen da enkelte funksjoner kan bli avviklet. Kjør ./make-distribution.sh -Dscala.version=2.11.11 -Dspark.version=2.1.2 -Dhadoop.version=2.7.4 -Delasticsearch.version=5.5.3, erstatt versjonsnummeret i henhold til ditt valg.

Når byggingen er fullført, vil du se følgende melding på slutten.

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

PredictionIO-binærfilene vil bli lagret i PredictionIO-0.12.0-incubating.tar.gzarkivet. Pakk ut arkivet i /optkatalogen og oppgi eierskapet til gjeldende bruker.

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

Still inn PIO_HOMEmiljøvariabelen.

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

Installer nødvendige avhengigheter

Opprett en ny katalog for å installere PredictionIO-avhengigheter som HBase, Sparkog Elasticsearch.

mkdir /opt/PredictionIO-0.12.0-incubating/vendors

Last ned Scala versjon 2.11.8 og pakk den ut i vendorskatalogen.

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

Last ned Apache Hadoop versjon 2.7.3 og pakk den ut i vendorskatalogen.

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 er standardbehandlingsmotoren for PredictionIO. Last ned Spark versjon 2.1.1 og pakk den ut i vendorskatalogen.

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

Last ned Elasticsearch versjon 5.5.2 og pakk den ut i vendorskatalogen.

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

Til slutt, last ned HBase versjon 1.2.6 og pakk den ut i vendorskatalogen.

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

Åpne hbase-site.xmlkonfigurasjonsfilen for å konfigurere HBase til å fungere i et frittstående miljø.

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

Finn den tomme konfigurasjonsblokken og erstatt den med følgende konfigurasjon.

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

Datakatalogen vil bli opprettet automatisk av HBase. Rediger HBase-miljøfilen for å angi JAVA_HOMEbanen.

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

Fjern kommentaren til linje nummer 27 og sett JAVA_HOMEtil banen til jreJava-installasjonen din. Du kan finne banen til den kjørbare JAVA-filen ved å bruke readlink -f $(which java)kommandoen.

# 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

Kommenter også linjenummer 46 og 47, da de ikke er nødvendige for 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"

Konfigurer PredictionIO-miljøet

Standardkonfigurasjonen i PredictionIO-miljøfilen pio-env.shforutsetter at vi bruker PostgreSQL eller MySQL. Ettersom vi har brukt HBase og Elasticsearch, må vi endre nesten hver konfigurasjon i filen. Det er best å ta en sikkerhetskopi av den eksisterende filen og lage en ny PredictionIO-miljøfil.

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

Now create a new file for PredictionIO environment configuration.

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

Populate the file with the following configuration.

# 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

Save the file and exit from the editor.

Open the Elasticsearch configuration file.

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

Uncomment the line and set the cluster name to exactly the same as the one provided in the PredictionIO environment file. The cluster name is set to pio in the above configuration.

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

Now add the $PIO_HOME/bin directory into the PATH variable so that the PredictionIO executables are executed directly.

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

At this point, PredictionIO is successfully installed on your server.

Starting PredictionIO

You can start all the services in PredictionIO such as Elasticsearch, HBase and Event server using a single command.

pio-start-all

You will see the following 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...

Use the following command to check the status of the PredictionIO server.

pio status

You will see the following 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.

As we can see in the above messages, our system is ready to use for implementing an engine template and predicting data.

Implementing an Engine Template

Several ready to use engine templates are available on the PredictionIO Template Gallery which can be easily installed on the PredictionIO server. You are free to browse through the list of engine templates to find the one that is close to your requirements or you can write your own engine.

In this tutorial, we will implement the E-Commerce Recommendation engine template to demonstrate the functionality of PredictionIO server using some sample data. This engine template provides some personal recommendation to a user in an e-commerce website. By default, it has features such as excluding out of stock items or providing recommendations to a user who signs up after the model is trained. Also, by default, the engine template takes a user's view and buy events, items with categories and properties and list of unavailable items. Once the engine has been trained and deployed, you can send a query with the user id and number of items to be recommended. The generated output will be a ranked list of recommended item ids.

Install Git, as it will be used to clone the repository.

cd ~    
sudo yum -y install git

Clone the E-Commerce Recommender engine template on your system.

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

Create a new application for the E-Commerce Recommendation template engine. Each application in PredictionIO is used to store the data for a separate website. If you have multiple websites, then you can create multiple apps to store each website's data into a different application. You are free to choose any name for your application.

cd MyEComRecomm/
pio app new myecom

You will see the following 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

The output above also contains the access key which will be used to authenticate when sending the input data to the event server.

You can always find the access key along with the list of available applications by running.

pio app list

You will see the following output containing a list of applications and the access key.

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

Nå som vi har opprettet en ny applikasjon, vil vi legge til noen data til den. I produksjonsmiljøet vil du automatisk sende dataene til hendelsesserveren ved å integrere hendelsesserverens API i applikasjonen. For å lære hvordan PredictionIO fungerer, vil vi importere noen eksempeldata til den. Malmotoren gir et Python-skript som enkelt kan brukes til å importere eksempeldataene til hendelsesserveren.

Installer Python pip.

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

Installer PredictionIO Python SDK ved hjelp av pip.

sudo pip install predictionio

Kjør Python-skriptet for å legge til eksempeldataene til hendelsesserveren.

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

Sørg for å erstatte tilgangsnøkkelen med din faktiske tilgangsnøkkel. Du vil se en lignende utgang.

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

Skriptet ovenfor importerer 10 brukere, 50 elementer i 6 kategorier og noen tilfeldige hendelser med kjøp og visninger. For å sjekke om hendelsene er importert eller ikke, kan du kjøre følgende spørring.

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

Utdataene vil vise deg listen over alle importerte hendelser i JSON-format.

Nå åpner du engine.jsonfilen i redigeringsprogrammet. Denne filen inneholder konfigurasjonen av motoren.

nano engine.json

Finn både forekomstene av appNameog erstatt verdien med det faktiske navnet på appen du har opprettet tidligere.

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

Bygg applikasjonen.

pio build --verbose

Hvis du ikke vil se loggmeldingene, fjern --verbosealternativet. Å bygge motormalen for første gang vil ta noen minutter. Du vil se en lignende utgang når byggingen er fullført.

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

Tren motoren nå. Under treningen analyserer motoren datasettet og trener seg selv i henhold til den angitte algoritmen.

pio train

Før vi distribuerer applikasjonen, må vi åpne porten 8000slik at statusen til applikasjonen kan vises på web-grensesnittet. Dessuten vil nettstedene og applikasjonene som bruker hendelsesserveren sende og motta forespørslene sine gjennom denne porten.

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

Nå kan du distribuere PredictionIO-motoren.

pio deploy

Kommandoen ovenfor vil distribuere motoren og den innebygde webserveren på porten for 8000å svare på forespørslene fra e-handelsnettstedene og applikasjonene. Du vil se følgende utgang på slutten når motoren er vellykket distribuert.

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

Du kan bekrefte statusen til motoren ved å gå til en http://192.0.2.1:8000hvilken som helst moderne nettleser. Pass på at du erstatter 192.0.2.1med din faktiske Vultr IP-adresse.

Dette betyr at motormalen for e-handelsanbefaling er distribuert og kjører vellykket. Du kan spørre motormalen for å hente fem anbefalinger for brukeren u5ved å kjøre følgende spørring i en ny terminaløkt.

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

Du vil se de genererte anbefalingene for brukeren 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}]}

Innpakning

Gratulerer, Apache PredictionIO har blitt distribuert på serveren din. Du kan nå bruke API-en til hendelsesserveren til å importere dataene til motoren for å forutsi anbefalingene for brukeren. Hvis du vil, kan du bruke noen andre maler fra malgalleriet. Sørg for å sjekke ut Universal Recommender- motormalen som kan brukes i nesten alle brukstilfeller, inkludert e-handel, nyheter eller video.