¿Cómo podemos crear aplicaciones de aprendizaje automático de manera fácil y rápida?
¿Y cómo podemos compartir la aplicación con otras personas?

Esta es la aplicación prototipo para el objetivo de hoy. El video de ejemplo es una aplicación web de clasificación de imágenes simple que utiliza el aprendizaje automático para detectar la madurez del banano.

¡Encontremos la solución con SAP BTP Kyma y streamlit!

Descripción general

Podemos crear rápidamente una aplicación de aprendizaje automático basada en SAP BTP, el tiempo de ejecución de Kyma e integrarla con streamline, que es una biblioteca Python de código abierto para crear aplicaciones web personalizadas para el aprendizaje automático y la ciencia de datos.

Pasos para resolver el problema de ML

En general, se siguen los siguientes pasos para resolver un problema de aprendizaje automático.

En esta publicación, nos centraremos en la fase de implementación y monitoreo utilizando la arquitectura conceptual y los requisitos utilizando SAP BTP Kyma y el marco de aplicación de código abierto: simplificado.

Pasos para resolver el problema de aprendizaje automático

Implementar y monitorear

Al implementar y monitorear proyectos de aprendizaje automático, podemos elegir herramientas de creación de prototipos de las opciones que se enumeran a continuación. Hoy, usaremos streamlit con SAP BTP kyma runtime.

• Cuaderno Jupyter
• iluminado; Edición y prueba simples
• Frasco: Backend + Frontend
• Dash: biblioteca de panel de control de Python
• Voila: Visualización para Jupyter Notebook
• …

En lugar de usar Flask, Streamlit hace que crear y compartir aplicaciones de aprendizaje automático sea rápido y fácil sin necesidad de desarrollo de back-end ni solicitud http (enlace a página iluminada)

Solicitud

Usaremos las siguientes aplicaciones para implementar nuestra aplicación:

Arquitectura

Esta es una arquitectura técnica para crear aplicaciones de aprendizaje automático. Usaremos SAP BTP, el tiempo de ejecución de Kyma, que es un tiempo de ejecución de Kubernetes completamente administrado basado en el proyecto de origen oepn «Kyma». Para el contenedor del modelo, se supone que ya completó el entrenamiento del modelo de aprendizaje automático. Para los contenedores de aplicaciones, el aprendizaje automático preentrenado genera predicciones.

Arquitectura Técnica

requisitos previos

• Instalar Motor acoplable
• SAP BTP Kyma
• modelo pre-entrenado
• Compruebe la accesibilidad del puerto de red: puerto 8501
• requisitos.txt

tensorflow==2.9.1
streamlit
numpy==1.22.3         
pillow==9.2.0
Flask==2.1.1
keras==2.9.0
scipy==1.7.3
matplot

Pasos

Hay cuatro partes a seguir en estos pasos para crear una aplicación de aprendizaje automático en este tutorial.

1. Crear aplicación usando python
2. Construir ventana acoplable
3. Tiempo de ejecución de SAP BTP Kyma
4. Subir archivo yaml

1. Crear aplicación usando python

Crearemos una aplicación de python para obtener predicciones utilizando el modelo de aprendizaje automático cuando el usuario cargue una imagen.

1.1 Importar biblioteca

import tensorflow as tf
from PIL import Image, ImageOps
import numpy as np
import streamlit as st

st.write('''
# Banana Ripeness Detection 🍌
''')
st.write("A Image Classification Web App That Detects the Ripeness Stage of Banana")

file = st.file_uploader("", type=['jpg','png','jpeg'])

1.2 Código de predicción usando aprendizaje automático

Dependiendo del modelo preentrenado, necesitamos cargar el modelo y preprocesar los datos de la imagen.

def predict_stage(image_data,model):
    size = (224, 224)
    image = ImageOps.fit(image_data,size, Image.ANTIALIAS)
    image_array = np.array(image)
    normalized_image_array = (image_array.astype(np.float32) / 127.0) - 1
    data = np.ndarray(shape=(1, 224, 224, 3), dtype=np.float32)
    data[0] = normalized_image_array
    preds = ""
    prediction = model.predict(data)
    if np.argmax(prediction)==0:
        preds = f"Overripe😫"
    elif np.argmax(prediction)==1:
        preds = f"ripe😄"
    else :
        preds = f"Unripe😑"
    return preds

2. Construir ventana acoplable

2.1 Crear un contenedor Docker

De acuerdo con la Dockerfile, docker crea imágenes leyendo las instrucciones. Vamos a crear Dockerfile como los siguientes pasos:

# STEP 1: Install Python base image
FROM python:3.9-slim

# Step 2: Add requirements.txt file 
COPY requirements.txt /requirements.txt
#
# Step 3:  Install required pyhton dependencies from requirements file
RUN pip install -r requirements.txt

# Step 4: Copy source code in the current directory to the container
ADD . /app

COPY app.py ./app.py
COPY ripeness.h5 ./ripeness.h5

# Step 5: Install git 
RUN apt-get update && apt-get install -y \
    build-essential \
    software-properties-common \
    git \
    && rm -rf /var/lib/apt/lists/*

# If you have git repo, you can clone your code that lives in a remote repo to WORKDIR
# RUN git clone https://github.com/streamlit/streamlit-example.git .

# Step 6: Set working directory to previously added app directory
WORKDIR /app

# # Step 7: Expose the port is running on
EXPOSE 8501

# Step 8: Run the application
ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

2.2 Crear una imagen de Docker

Cuando ejecutas el siguiente comando, Dockerfile crear imagen acoplable. Puede cambiar el nombre en lugar de banana-ml/streamlit:último

docker build -t banana-ml/streamlit:latest .

2.3 Ejecutar el contenedor Docker

Podemos ejecutar el contenedor ejecutando:

docker run -p 8501:8501 banana-ml/streamlit:latest

2.4 Empuje de la ventana acoplable

Podemos insertar nuestra imagen de Docker en nuestro repositorio de Docker Hub ejecutando:

docker push banana-ml/streamlist:latest

3. Tiempo de ejecución de SAP BTP Kyma

3.1 Crear espacio de nombres desde SAP BTP Kyma

En este tutorial, creamos un espacio de nombres con plátano-ml de SAP BTP kyma.

Crear espacio de nombresGuardar espacio de nombres

3.2 Crear archivo yaml

Implementaremos el archivo yaml que incluye Tipo: Implementación, Servicio y APIRule en el mismo archivo: k8s/streamlit.yaml.

3.2.1 Despliegue

apiVersion: apps/v1
kind: Deployment
metadata:
  name: streamlit-deployment
  labels:
    app: streamlit
spec:
  replicas: 1
  selector:
    matchLabels:
      app: streamlit
  template:
    metadata:
      labels:
        app: streamlit
    spec:
      containers:
        - name: streamlit
          image: banana-ml/streamlit:latest
          imagePullPolicy: Always
          ports:
            - containerPort: 8501
          livenessProbe:
            httpGet:
              path: /healthz
              port: 8501
              scheme: HTTP
            timeoutSeconds: 1
          readinessProbe:
            httpGet:
              path: /healthz
              port: 8501
              scheme: HTTP
            timeoutSeconds: 1
          resources:
            limits:
              cpu: 1
              memory: 2Gi
            requests:
              cpu: 100m
              memory: 745Mi

3.2.2 Servicio

---
apiVersion: v1
kind: Service
metadata:
  name: streamlit-service
spec:
  type: LoadBalancer
  selector:
    app: streamlit
  ports:
    - name: streamlit-port
      protocol: TCP
      port: 8501
      targetPort: 8501

3.2.3 Regla API

La regla API nos permite exponer un servicio externamente. Obtendremos una URL como https://bananastreamlit-api.c xxxxxxx.kyma.shoot.live.k8s-hana.ondemand.com .

---
apiVersion: gateway.kyma-project.io/v1alpha1
kind: APIRule
metadata:
  name: bananastreamlit-api-rule
  namespace: banana-ml
  labels:
    app.kubernetes.io/name: bananastreamlit
spec:
  gateway: kyma-gateway.kyma-system.svc.cluster.local
  service:
    name: streamlit-service
    port: 8501
    host: bananastreamlit-api
  rules:
    - accessStrategies:
      - config: {}
        handler: allow 
      methods:
      - GET
      - POST
      path: /.*

4. Sube el archivo yaml

4.1 Exportar configuración de kube

Podemos descargar desde la descripción general del clúster usando Descargar Kubeconfig

export KUBECONFIG=/Users/.kube/kubeconfig.yaml

Descargar Kubeconfig

4.2 Subir archivo yaml

kubectl apply -f k8s/streamlit.yaml

4.3 Comprobar el despliegue

Espere hasta que la implementación sea exitosa desde Healthy Resources.

Recursos saludables

4.4 Comprobación y prueba con reglas API

Puede obtener la URL para acceder a la aplicación de aprendizaje automático.

Reglas de la API

Felicidades 👏👏👏

Ahora podemos crear nuestra genial aplicación de aprendizaje automático y también podemos compartirla con otras personas✨ ¡Espero que esta publicación te sea útil!

Referencia