Como instalar e usar o Apache PredictionIO para aprendizado de máquina no CentOS 7

• Pré-requisitos
• Instale Java
• Instale o PredictionIO
• Instalar dependências necessárias
• Configurar o ambiente PredictionIO
• Iniciando o PredictionIO
• Implementando um modelo de mecanismo
• Empacotando

As abordagens tradicionais para análise de dados são impossíveis de usar quando os conjuntos de dados atingem um determinado tamanho. Uma alternativa moderna para analisar grandes conjuntos de dados é usar métodos de aprendizado de máquina. O aprendizado de máquina é capaz de produzir resultados precisos ao usar um algoritmo rápido e eficiente.

O Apache PredictionIO é um servidor de aprendizado de máquina de código aberto usado para criar mecanismos preditivos para qualquer tarefa de aprendizado de máquina. Reduz o tempo do aplicativo de aprendizado de máquina do laboratório para a produção usando modelos de mecanismo personalizáveis ​​que podem ser construídos e implantados rapidamente. Ele fornece os componentes de coleta e exibição de dados e abstrai a tecnologia subjacente para expor uma API que permite que os desenvolvedores se concentrem nos componentes de transformação. Depois que o servidor de mecanismo do PredictionIO é implantado como um serviço da Web, ele pode responder a consultas dinâmicas em tempo real.

O Apache PredictionIO consiste em diferentes componentes.

• Plataforma PredictionIO : Uma pilha de aprendizado de máquina de código aberto criada no topo de alguns aplicativos de código aberto de última geração, como Apache Spark, Apache Hadoop, Apache HBase e Elasticsearch.
• Servidor de Eventos : reúne continuamente dados do servidor da Web ou servidor de aplicativos móveis no modo em tempo real ou no lote. Os dados coletados podem ser usados ​​para treinar o mecanismo ou fornecer uma visão unificada para análise de dados. O servidor de eventos usa o Apache HBase para armazenar os dados.
• Servidor do mecanismo : o servidor do mecanismo é responsável por fazer a previsão real. Ele lê os dados de treinamento do repositório de dados e usa um ou mais algoritmos de aprendizado de máquina para construir os modelos preditivos. Um mecanismo, uma vez implantado como um serviço da web, responde às consultas feitas por um aplicativo da web ou móvel usando a API REST ou SDK.
• Galeria de modelos : esta galeria oferece vários tipos de modelos de mecanismo pré-criados. Você pode escolher um modelo semelhante ao seu caso de uso e modificá-lo de acordo com seus requisitos.

Pré-requisitos

• Uma instância do servidor Vultr CentOS 7 com pelo menos 8 GB de RAM. Para fins de teste e desenvolvimento, você pode escolher uma instância com 4 GB de RAM e outra memória de troca de 4 GB .
• Um usuário sudo .

Neste tutorial, usaremos 192.0.2.1como o endereço IP público do servidor. Substitua todas as ocorrências 192.0.2.1pelo seu endereço IP público do Vultr.

Atualize seu sistema básico usando o guia Como atualizar o CentOS 7 . Depois que seu sistema for atualizado, continue com a instalação do Java.

Instale Java

Muitos dos componentes do PredictionIO requerem o JDK, ou Java Development Kit, versão 8, para funcionar. Ele suporta o OpenJDK e o Oracle Java. Neste tutorial, instalaremos o OpenJDK versão 8.

O OpenJDK pode ser facilmente instalado, pois o pacote está disponível no repositório YUM padrão.

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

Verifique a versão do Java para garantir que foi instalada corretamente.

java -version

Você obterá uma saída semelhante.

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

Antes de prosseguirmos, precisaremos configurar as variáveis ​​de ambiente JAVA_HOMEe JRE_HOME. Encontre o caminho absoluto do executável JAVA no seu sistema.

readlink -f $(which java)

Você verá uma saída semelhante.

[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

Agora, configure JAVA_HOMEe JRE_HOMEvariável de ambiente de acordo com o caminho do diretório 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

Execute o bash_profilearquivo

source ~/.bash_profile

Agora você pode executar o echo $JAVA_HOMEcomando para verificar se a variável de ambiente está configurada.

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

Instale o PredictionIO

O Apache fornece arquivos de origem PredictionIO que podem ser baixados e compilados localmente. Crie um novo diretório temporário para baixar e compilar o arquivo de origem.

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

Faça o download do arquivo-fonte do PredictionIO usando qualquer site do Apache Mirror .

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

Extraia o arquivo morto e compile a fonte para criar uma distribuição do PredictionIO.

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

A distribuição acima será construído contra as versões padrão das dependências, que são Scala 2.11.8, Spark 2.1.1, Hadoop 2.7.3e ElasticSearch 5.5.2. Aguarde o término da compilação, pois levará cerca de dez minutos para concluir, dependendo do desempenho do seu sistema.

Nota : Você pode usar a versão mais recente suportada das dependências, mas poderá receber alguns avisos durante a compilação, pois algumas funções podem estar obsoletas. Execute ./make-distribution.sh -Dscala.version=2.11.11 -Dspark.version=2.1.2 -Dhadoop.version=2.7.4 -Delasticsearch.version=5.5.3, substituindo o número da versão de acordo com sua escolha.

Depois que a compilação for concluída com êxito, você verá a seguinte mensagem no final.

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

Os arquivos binários do PredictionIO serão salvos no PredictionIO-0.12.0-incubating.tar.gzarquivo morto. Extraia o arquivo morto no /optdiretório e forneça a propriedade ao usuário atual.

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

Defina a PIO_HOMEvariável de ambiente.

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

Instalar dependências necessárias

Crie um novo diretório para instalar dependências do PredictionIO, como HBase, Sparke Elasticsearch.

mkdir /opt/PredictionIO-0.12.0-incubating/vendors

Faça o download do Scala versão 2.11.8 e extraia-o no vendorsdiretório

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

Faça o download do Apache Hadoop versão 2.7.3 e extraia-o no vendorsdiretório

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

O Apache Spark é o mecanismo de processamento padrão do PredictionIO. Faça o download do Spark versão 2.1.1 e extraia-o no vendorsdiretório

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

Faça o download do Elasticsearch versão 5.5.2 e extraia-o no vendorsdiretório

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

Por fim, baixe o HBase versão 1.2.6 e extraia-o no vendorsdiretório

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

Abra o hbase-site.xmlarquivo de configuração para configurar o HBase para funcionar em um ambiente independente.

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

Encontre o bloco de configuração vazio e substitua-o pela seguinte configuração.

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

O diretório de dados será criado automaticamente pelo HBase. Edite o arquivo de ambiente do HBase para definir o JAVA_HOMEcaminho.

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

Remova o comentário da linha número 27 e defina JAVA_HOMEo caminho da jresua instalação Java. Você pode encontrar o caminho para o executável JAVA usando o 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

Além disso, comente os números de linha 46 e 47, pois eles não são necessários para o 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"

Configurar o ambiente PredictionIO

A configuração padrão no arquivo de ambiente PredictionIO pio-env.shpressupõe que estamos usando PostgreSQL ou MySQL. Como usamos o HBase e o Elasticsearch, precisaremos modificar quase todas as configurações do arquivo. É melhor fazer um backup do arquivo existente e criar um novo arquivo de ambiente do PredictionIO.

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

Agora crie um novo arquivo para a configuração do ambiente PredictionIO.

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

Preencha o arquivo com a seguinte configuração.

# 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

Salve o arquivo e saia do editor.

Abra o arquivo de configuração do Elasticsearch.

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

Remova o comentário da linha e defina o nome do cluster exatamente igual ao fornecido no arquivo de ambiente do PredictionIO. O nome do cluster está definido piona configuração acima.

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

Agora adicione o $PIO_HOME/bindiretório na variável PATH para que os executáveis ​​do PredictionIO sejam executados diretamente.

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

Neste ponto, o PredictionIO está instalado com sucesso no seu servidor.

Iniciando o PredictionIO

Você pode iniciar todos os serviços no PredictionIO, como o servidor Elasticsearch, HBase e Event, usando um único comando.

pio-start-all

Você verá a seguinte saída.

[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 o comando a seguir para verificar o status do servidor PredictionIO.

pio status

Você verá a seguinte saída.

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

Como podemos ver nas mensagens acima, nosso sistema está pronto para uso na implementação de um modelo de mecanismo e previsão de dados.

Implementando um modelo de mecanismo

Vários modelos de mecanismo prontos para uso estão disponíveis na PredictionIO Template Gallery, que pode ser facilmente instalada no servidor PredictionIO. Você é livre para navegar pela lista de modelos de mecanismo para encontrar o que está mais próximo dos seus requisitos ou pode escrever seu próprio mecanismo.

Neste tutorial, implementaremos o E-Commerce Recommendationmodelo de mecanismo para demonstrar a funcionalidade do servidor PredictionIO usando alguns dados de amostra. Este modelo de mecanismo fornece algumas recomendações pessoais para um usuário em um site de comércio eletrônico. Por padrão, ele possui recursos como excluir itens em falta ou fornecer recomendações a um usuário que se inscreve após o treinamento do modelo. Além disso, por padrão, o modelo de mecanismo captura a visualização do usuário e compra eventos, itens com categorias e propriedades e lista de itens indisponíveis. Depois que o mecanismo for treinado e implantado, você poderá enviar uma consulta com o ID do usuário e o número de itens a serem recomendados. A saída gerada será uma lista classificada de IDs de itens recomendados.

Instale o Git, pois ele será usado para clonar o repositório.

cd ~    
sudo yum -y install git

Clone o modelo do mecanismo Recomendador de comércio eletrônico em seu sistema.

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

Crie um novo aplicativo para o mecanismo de modelo de recomendação de comércio eletrônico. Cada aplicativo no PredictionIO é usado para armazenar os dados em um site separado. Se você tiver vários sites, poderá criar vários aplicativos para armazenar os dados de cada site em um aplicativo diferente. Você pode escolher qualquer nome para o seu aplicativo.

cd MyEComRecomm/
pio app new myecom

Você verá a seguinte saída.

[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

A saída acima também contém a chave de acesso que será usada para autenticar ao enviar os dados de entrada para o servidor de eventos.

Você sempre pode encontrar a chave de acesso junto com a lista de aplicativos disponíveis executando.

pio app list

Você verá a seguinte saída, contendo uma lista de aplicativos e a chave de acesso.

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

Agora que criamos um novo aplicativo, adicionaremos alguns dados a ele. No ambiente de produção, você deseja enviar automaticamente os dados para o servidor de eventos, integrando a API do servidor de eventos ao aplicativo. Para saber como o PredictionIO funciona, importaremos alguns dados de amostra para ele. O mecanismo de modelo fornece um script Python que pode ser facilmente usado para importar os dados de amostra para o servidor de eventos.

Instale o Python pip.

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

Instale o PredictionIO Python SDK usando pip.

sudo pip install predictionio

Execute o script Python para adicionar os dados de amostra ao servidor de eventos.

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

Certifique-se de substituir a chave de acesso pela sua chave de acesso real. Você verá uma saída semelhante.

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

O script acima importa 10 usuários, 50 itens em 6 categorias e alguns eventos aleatórios de compra e visualizações. Para verificar se os eventos são importados ou não, você pode executar a seguinte consulta.

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

A saída mostrará a lista de todos os eventos importados no formato JSON.

Agora, abra o engine.jsonarquivo no editor. Este arquivo contém a configuração do mecanismo.

nano engine.json

Encontre as ocorrências appNamee substitua o valor pelo nome real do aplicativo que você criou anteriormente.

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

Crie o aplicativo.

pio build --verbose

Se você não deseja ver as mensagens de log, remova a --verboseopção A criação do modelo de mecanismo pela primeira vez levará alguns minutos. Você verá uma saída semelhante quando a construção for concluída com êxito.

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

Treine o motor agora. Durante o treinamento, o mecanismo analisa o conjunto de dados e se treina de acordo com o algoritmo fornecido.

pio train

Antes de implantarmos o aplicativo, precisaremos abrir a porta 8000para que o status do aplicativo possa ser visualizado na GUI da Web. Além disso, os sites e aplicativos que usam o servidor de eventos enviarão e receberão suas consultas por essa porta.

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

Agora você pode implantar o mecanismo PredictionIO.

pio deploy

O comando acima implementará o mecanismo e o servidor da Web incorporado na porta 8000para responder às consultas dos sites e aplicativos de comércio eletrônico. Você verá a seguinte saída no final assim que o mecanismo for implantado com sucesso.

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

Você pode verificar o status do mecanismo http://192.0.2.1:8000usando qualquer navegador moderno. Certifique-se de substituir o 192.0.2.1seu endereço IP Vultr real.

Isso significa que o modelo de mecanismo da recomendação de comércio eletrônico está implantado e funcionando com êxito. Você pode consultar o modelo do mecanismo para buscar cinco recomendações para o usuário u5executando a seguinte consulta em uma nova sessão de terminal.

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

Você verá as recomendações geradas para o usuário 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}]}

Empacotando

Parabéns, o Apache PredictionIO foi implantado com sucesso no seu servidor. Agora você pode usar a API do servidor de eventos para importar os dados para o mecanismo e prever as recomendações para o usuário. Se desejar, você pode usar alguns outros modelos da galeria de modelos. Certifique-se de verificar o modelo do mecanismo Universal Recomendar , que pode ser usado em quase todos os casos de uso, incluindo comércio eletrônico, notícias ou vídeo.