CAP0104 Capstone Project

Proyecto Angkoot de Cap0104 Capstone Project Team (KiriMas) Bangkit Academy 2021

Descripción general

Angkoot es una aplicación que tiene el propósito de digitalizar el transporte de Angkot en Surabaya, Indonesia. Los servicios que proporciona Angkoot ahora son la predicción de tarifas para el pedido, la estimación de distancia de viaje y el registro del usuario.

Créditos

Para la predicción de tarifas, estamos inspirados en Dimitre Oliveira: https://github.com/dimitreoliveira/newyorkcityTaxifare

Y el conjunto de datos de predicción de tarifas que usamos es de Kaggle. [conjunto de datos]

El proceso de implementación con Flask to Google Compute Engine se ha realizado utilizando Ayuda del tutorial de Alare Dirik: https://github.com/alaradirik/google cloud-flask-tutorial [implementación]

¿Cómo es?

Para la predicción de tarifas, estamos utilizando solo alrededor de 500,000 datos de todo el conjunto de datos. Y luego preprocesamos el conjunto de datos basado en la preparación de datos de Dimitre Oliveira con algunos ajustes. Y luego construimos el modelo usando el modelo Keras. Al principio intentamos usar el estimador TensorFlow, lo mismo con el de Dimitre. Pero luego hacemos algunos ajustes para que solo usemos keras en nuestro proyecto. Después de eso, hacemos la capacitación y exportamos el modelo guardado. A continuación, el modelo guardado se implementa utilizando Flask, con la adición de Nginx y Unicornio, al motor de Compute de Google. A partir de eso, obtenemos la API que luego se activará de la aplicación Android para hacer algunas predicciones.

Paso a paso

Estos son pasos que podrías hacer:

Entrenar el modelo

1. Descargue el conjunto de datos de Kaggle. [conjunto de datos]
2. Clon este repositorio

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

3. Instale los requisitos.txt

pip install -r requirements.txt

4. Preprocese el tren.csv y test.csv desde el conjunto de datos utilizando la preparación de datos .
5. Entrena los datos usando model_keras.ipynb y obtenga el modelo guardado en formato de búfer de protocolo (.pb) o formato HDF5 (.H5). También puede convertirlos en JSON usando el convertidor TFJS y el modelo TFLite usando el convertidor TFLite. También puede ajustar el hiperparámetro o la arquitectura.

Despliegue del modelo con frascos

1. Necesitamos verificar si el modelo podría cargarse o no usar load_model.ipynb , si se pueden hacer predicciones, entonces estamos de la manera correcta.
2. Después de eso, necesitamos rediseñar el script Model_keras para que pueda implementarse en el servidor web local usando Flask. Por lo tanto, hicimos frasco_model.py para el preprocesamiento y para probar algunas predicciones en localhost.
3. A continuación, tenemos dos scripts diferentes para la implementación de frascos: frask_using_dataform.ipynb y main.ipynb . Básicamente son los mismos guiones, pero con un poco de diferencias. En Flask_using_DataForm.ipynb estamos utilizando el formulario de datos para hacer una predicción cargando el archivo CSV y Clik el botón Predicte, y para Main.ipynb borramos el formulario de datos para implementarlo en Google Compute Engine para que las predicciones se puedan hacer rectas y continuas. main.py básicamente el mismo script pero con formato de pitón.
4. Si ejecuta el script main.ipynb , puede intentar enviar algunas solicitudes de publicación usando solicitudes.ipynb o usando el servicio postman.

Implementación del modelo de frasco en Google Compute Engine

Básicamente estamos haciendo estas cosas del tutorial de Alare Dirik anterior con algún ajuste. Los detalles podrían leerse [aquí]

1. Primero, debe hacer una instancia de VM en Google Compute Engine (GCE). Estamos usando Ubuntu 18.04 LTS y no olvidamos permitir el tráfico HTTP.
2. A continuación, necesitamos configurar las reglas de firewall para Flask porque se ejecuta en el puerto 5000 en la red VPC> Reglas de firewall.
3. Luego, necesitamos configurar nuestra instancia de VM. Abra la VM usando SSH.
4. Después de eso, prepararemos las dependencias y el entorno virtual. En la ejecución de la 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. A continuación, clonaremos este repositorio a la VM. Para hacerlo más fácil, hemos movido el frasc_model.py , keras_model.h5 , main.py y main_dataform.py (adicional) a la carpeta raíz de este repositorio. Entonces, la carpeta raíz debería verse así:

 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. Luego, necesitamos instalar las dependencias desde requisitos.txt en el entorno virtual y comenzar a ejecutar el script main.py :

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

7. Puede verificarlo si se hace correctamente enviando algunas solicitudes de publicación como antes de usar la dirección VM externa-IP.
8. Si se hace bien, puede usar Nginx y Gunicorn para hacer que la VM pueda manejar las solicitudes HTTP, porque el frasco en sí no puede manejarlas. Necesitamos instalar Nginx en el terminal GCE.

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

9. A continuación, necesitamos configurar el 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. Ahora, podemos editar el archivo de configuración.

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

Luego, agregue este código a continuación:

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

11. Luego, reinicie el servidor NGINX.

sudo /etc/init.d/nginx restart

12. Por último, debemos volver a la carpeta Repo y vincular el modelo de frascos main.py al servidor Gunicorn.

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

13. Ahora, podríamos activar la API VM desde cualquier lugar. En nuestro proyecto, podemos activarlo desde nuestra aplicación Android.

Resultado final

Because of the Android app is still under development, you may check the result by GET requests and POST requests with test_processed.csv with key values 'files' to http://34.101.176.23/ for GET requests (it should show "Kirimas was here") and http://34.101.176.23/predict for POST requests (it should show json file as a result of model predicciones) como se muestra a continuación: