CAP0104 Capstone Project

Projet Angkoot par Cap0104 Capstone Project Team (Kirimas) Bangkit Academy 2021

Aperçu

Angkoot est une application qui a le but de numériser le transport d'Angkot à Surabaya, en Indonésie. Les services fournis par Angkoot sont maintenant une prédiction des tarifs pour la commande, l'estimation de la distance de voyage et l'enregistrement des utilisateurs.

Crédits

Pour la prédiction des tarifs, nous sommes inspirés de Dimitre Oliveira: https://github.com/dimitreoliveira/newyorkcitytaxifare

Et l'ensemble de données de prédiction tarifaire que nous avons utilisé est de Kaggle. [ensemble de données]

Le processus de déploiement avec Flask to Google Compute Engine a été effectué en utilisant les aides du tutoriel d'Aara Dirik: https://github.com/alaradirik/google-cloud-flask-tutorial [déploiement]

Comment c'est?

Pour la prédiction des tarifs, nous n'utilisons que environ 500 000 données de l'ensemble de données. Et puis nous avons prétraité l'ensemble de données en fonction de la préparation des données de Dimitre Oliveira avec certains ajustements. Et puis nous construisons le modèle à l'aide du modèle Keras. Au début, nous essayons d'utiliser l'estimateur TensorFlow, même avec celui de Dimitre. Mais ensuite, nous faisons un ajustement afin que nous n'utilisions que des keras dans notre projet. Après cela, nous faisons la formation et exportons le modèle enregistré. Ensuite, le modèle enregistré est déployé à l'aide de Flask, avec l'ajout de Nginx et Unicorn, dans Google Compute Engine. À partir de cela, nous obtenons l'API qui sera déclenchée plus tard à partir de l'application Android afin de faire des prédictions.

Étape par étape

Ce sont des étapes que vous pourriez faire:

Former le modèle

1. Téléchargez l'ensemble de données depuis Kaggle. [ensemble de données]
2. Cloner ce référentiel

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

3. Installer les exigences.txt

pip install -r requirements.txt

4. Prétraitez le train.csv et test.csv à partir de l'ensemble de données à l'aide du script Data Préparation.Ipynb pour obtenir les données de formation.
5. Formez les données à l'aide de Model_keras.ipynb et obtenez le modèle enregistré au format de tampon de protocole (.pb) ou au format HDF5 (.h5). Vous pouvez également les convertir en JSON à l'aide du convertisseur TFJS et du modèle TFLITE en utilisant le convertisseur TFLITE. Vous pouvez également ajuster l'hyperparamètre ou l'architecture.

Déploiement du modèle à l'aide de flacon

1. Nous devons vérifier si le modèle pourrait être chargé ou non en utilisant LOAD_MODEL.IPYNB , si des prédictions pouvaient être faites, alors nous sommes de la bonne manière.
2. Après cela, nous devons re-concevoir le script Model_keras afin qu'il puisse être déployé dans le serveur Web local à l'aide de Flask. Par conséquent, nous avons fait flask_model.py pour le prétraitement et pour essayer certaines prédictions dans localhost.
3. Ensuite, nous avons deux scripts différents pour le déploiement de Flask: flask_using_dataform.ipynb et main.ipynb . Ce sont essentiellement les mêmes scripts, mais avec un peu de différences. Dans flask_using_dataform.ipynb, nous utilisons le formulaire de données pour faire une prédiction en téléchargeant le fichier CSV et cliquez le bouton Prédire, et pour main.ipynb, nous avons effacé le formulaire de données afin de le déployer dans le moteur Google Compute afin que les prédictions puissent être effectuées directement et continuellement. main.py fondamentalement le même script mais avec le format Python.
4. Si vous exécutez le script main.ipynb , vous pouvez essayer d'envoyer des demandes de publication à l'aide de remanes.ipynb ou à l'aide du service Postman.

Déploiement du modèle FLASK dans le moteur Google Compute

Nous faisons essentiellement ces choses du tutoriel d'Aara Dirik ci-dessus avec un certain ajustement. Les détails pourraient être lus [ici]

1. Tout d'abord, vous devez faire une instance VM dans Google Compute Engine (GCE). Nous utilisons Ubuntu 18.04 LTS et n'oublions pas d'autoriser le trafic HTTP.
2. Ensuite, nous devons configurer les règles de pare-feu pour le ballon car il s'exécute sur le port 5000 dans le réseau VPC> Règles de pare-feu.
3. Ensuite, nous devons configurer notre instance VM. Ouvrez la machine virtuelle à l'aide de SSH.
4. Après cela, nous préparerons les dépendances et l'environnement virtuel. Sur le 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. Ensuite, nous allons cloner ce référentiel à la machine virtuelle. Afin de faciliter la tâche, nous avons déplacé le flask_model.py , keras_model.h5 , main.py et main_dataform.py (supplémentaire) dans le dossier racine de ce référentiel. Ainsi, le dossier racine devrait ressembler à ceci:

 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. Ensuite, nous devons installer les dépendances à partir des exigences.txt dans l'environnement virtuel et commencer à exécuter le script main.py :

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

7. Vous pouvez vérifier si cela est bien fait en envoyant des demandes de publication comme avant d'utiliser l'adresse VM externe-IP.
8. Si cela est bien fait, vous pouvez utiliser Nginx et Gunicorn pour faire en sorte que la machine virtuelle peut gérer les demandes HTTP, car Flask lui-même ne peut pas les gérer. Nous devons installer nginx dans le terminal GCE.

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

9. Ensuite, nous devons configurer le 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. Maintenant, nous pouvons modifier le fichier de configuration.

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

Ensuite, ajoutez ce code ci-dessous:

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

11. Ensuite, redémarrez le serveur Nginx.

sudo /etc/init.d/nginx restart

12. Enfin, nous devons revenir au dossier Repo et lier le modèle Flask Main.py au serveur Gunicorn.

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

13. Maintenant, nous pouvions déclencher l'API VM de n'importe où. Dans notre projet, nous pouvons le déclencher de notre application Android.

Résultat final

En raison de l'application Android est toujours en cours de développement, vous pouvez vérifier le résultat par des demandes de GET et des demandes de publication avec test_processed.csv avec des fichiers clés de valeurs "à http://34.101.176.23/ pour les demandes de GET (il devrait afficher" Kirimas était ici ") et http://34.101.176.23/ prédictions) comme indiqué ci-dessous: