CAP0104 Capstone Project

Projeto Angkoot por Cap0104 Capstone Project Team (Kirimas) Bangkit Academy 2021

Visão geral

Angkoot é um aplicativo que tem o objetivo de digitalizar o transporte de Angkot em Surabaya, na Indonésia. Os serviços que o Angkoot fornece agora são previsão de tarifa para o pedido, estimativa de distância da viagem e registro do usuário.

Créditos

Para a previsão da tarifa, somos inspirados em Dimitre Oliveira: https://github.com/dimitreoliveira/newyorkcitytaxifare

E o conjunto de dados de previsão de tarifas que usamos é de Kaggle. [DataSet]

O processo de implantação do Flask to Google Compute Engine foi feito usando ajuda do tutorial de Alara Dirik: https://github.com/alaradirik/google-cloud-flask-tutorial [implantação]

Como é?

Para a previsão da tarifa, estamos usando apenas cerca de 500.000 dados de todo o conjunto de dados. E então pré -processamos o conjunto de dados com base na preparação de dados do Dimitre Oliveira com alguns ajustes. E então construímos o modelo usando o modelo Keras. No começo, tentamos usar o estimador Tensorflow, o mesmo com o Dimitre's. Mas então fazemos alguns ajustes para usar apenas Keras em nosso projeto. Depois disso, fazemos o treinamento e exportamos o modelo salvo. Em seguida, o modelo salvo é implantado usando o Flask, com adição de Nginx e Unicorn, no Google Compute Engine. A partir disso, obtemos a API que mais tarde será acionada pelo aplicativo Android para fazer algumas previsões.

Passo a passo

Estas são as etapas que você pode fazer:

Treine o modelo

1. Faça o download do conjunto de dados de Kaggle. [DataSet]
2. Clone este repositório

git clone https://github.com/anriza-fanani-bangkit/CAP0104-Capstone-Project/

3. Instale os requisitos.txt

pip install -r requirements.txt

4. Pré -processo o trem.csv e test.csv do conjunto de dados usando o script de preparação de dados.ipynb para obter os dados para treinamento.
5. Treine os dados usando model_keras.ipynb e obtenha o modelo salvo no formato de buffer de protocolo (.pb) ou formato HDF5 (.h5). Você também pode convertê -los em JSON usando o conversor TFJS e o modelo Tflite usando o conversor Tflite. Você também pode ajustar o hiperparâmetro ou a arquitetura.

Modelo de implantação usando frasco

1. Precisamos verificar se o modelo pode ser carregado ou não usando load_model.ipynb , se as previsões puderam ser feitas, então estamos da maneira certa.
2. Depois disso, precisamos redesenhar o script Model_Keras para que ele possa ser implantado no servidor da Web local usando o Flask. Portanto, fizemos Flask_model.py para pré -processamento e para tentar algumas previsões no host local.
3. Em seguida, temos dois scripts diferentes para implantação de frascos: FLASK_USING_DATAFORM.IPYNB e MAIN.IPYNB . É basicamente os mesmos scripts, mas com algumas diferenças. Em Flask_USing_DataForm.ipynb , estamos usando o formulário de dados para fazer uma previsão carregando o arquivo CSV e clique o botão Prever e, para Main.IPYNB , apagamos o formulário de dados para implantá -lo no Google Compute Engine para que as previsões pudessem ser realizadas retas e continuamente. main.py basicamente o mesmo script, mas com formato python.
4. Se você executar o script main.ipynb , poderá tentar enviar algumas solicitações de postagem usando o requests.ipynb ou usando o serviço de postman.

Implantação de modelo de frasco no Google Compute Engine

Estamos basicamente fazendo essas coisas do tutorial de Alara Dirik acima com algum ajuste. Os detalhes podem ser lidos [aqui]

1. Primeiro, você precisa fazer uma instância da VM no Google Compute Engine (GCE). Estamos usando o Ubuntu 18.04 LTS e não esquecemos de permitir o tráfego HTTP.
2. Em seguida, precisamos configurar as regras do firewall para o Flask, pois está sendo executado na porta 5000 na rede VPC> Regras do firewall.
3. Em seguida, precisamos configurar nossa instância da VM. Abra a VM usando SSH.
4. Depois disso, prepararemos as dependências e o ambiente virtual. Na execução do terminal:

 # update system packages, install the required packages, and miniconda
sudo apt-get update
sudo apt-get install bzip2 libxml2-dev libsm6 libxrender1 libfontconfig1
wget https://repo.anaconda.com/miniconda/Miniconda3-4.7.10-Linux-x86_64.sh
bash Miniconda3-4.7.10-Linux-x86_64.sh
# make conda executable
export PATH=/home/ < based on your Google Cloud ' s name>/miniconda3/bin:$PATH
rm Miniconda3-4.7.10-Linux-x86_64.sh
# create and activate a new virtual environment
conda create -n angkoot python=3.7
conda activate angkoot

5. Em seguida, clonaremos este repositório para a VM. Para facilitar, movemos o Flask_model.py , keras_model.h5 , main.py e main_dataform.py (adicional) para a pasta raiz deste repositório. Então, a pasta raiz deve ficar assim:

 CAP0104-Capstone-Project
│   README.md
│   flask_model.py                  # Functions to preprocess the input data    
│   keras_model.h5                  # Keras saved model to be loaded in Flask
│   main.py                         # Flask model app to predict continuosly
│   main_dataform.py                # Flask model app to predict with data form
│   requirements.txt                # To install the dependencies

6. Em seguida, precisamos instalar as dependências do requisitos.txt no ambiente virtual e começar a executar o script main.py :

 cd CAP0104-Capstone-Project
pip install -r requirements.txt
python main.py

7. Você pode verificar se é feito corretamente enviando algumas solicitações de postagem, como antes de usar o endereço de IP externo da VM.
8. Se for feito corretamente, você poderá usar o NGINX e o Gunicorn para fazer a VM pode lidar com solicitações HTTP, porque o próprio frasco não pode lidar com eles. Precisamos instalar o nginx no terminal GCE.

 # you need to go out from repo folder
cd
sudo apt-get install nginx-full
sudo /etc/init.d/nginx start

9. Em seguida, precisamos configurar o nginx.

 # remove default configuration file
sudo rm /etc/nginx/sites-enabled/default
# create a new site configuration file
sudo touch /etc/nginx/sites-available/angkoot_project
sudo ln -s /etc/nginx/sites-available/angkoot_project /etc/nginx/sites-enabled/angkoot_project

10. Agora, podemos editar o arquivo de configuração.

sudo nano /etc/nginx/sites-enabled/angkoot_project

Em seguida, adicione este código abaixo:

server {
    client_max_body_size 100M ;
    location / {
        proxy_pass http://0.0.0.0:5000 ;
    }
}

11. Em seguida, reinicie o servidor nginx.

sudo /etc/init.d/nginx restart

12. Por fim, precisamos voltar à pasta repo e ligar o modelo de frasco Main.py ao servidor Gunicorn.

 cd CAP0104-Capstone-Project
gunicorn --bind 0.0.0.0:5000 main:app

13. Agora, poderíamos acionar a API da VM de qualquer lugar. Em nosso projeto, podemos desencadeá -lo do nosso aplicativo Android.

Resultado final

Por causa do aplicativo Android, ainda está em desenvolvimento, você pode verificar o resultado com solicitações e solicitações de postagem com test_processd.csv com os 'arquivos' dos valores -chave para http://34.101.176.23/ para obter solicitações (ele deve mostrar "KiriMas estava aqui") e http://34.101.176.2.2.2.2.2.2.2.2.2.2, http://34.101.176.2.2.2.2.2. previsões) como mostrado abaixo: