Guardar espacio de nombres
ai
· deployment
· Kyma
· SAP BTP
· SAPAI
· Streamlit
· Technical Articles
Cree aplicaciones de aprendizaje automático de forma rápida y sencilla con SAP BTP, Kyma y streamlit
By s4pcademy
¿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
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
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
matplotPasos
Hay cuatro partes a seguir en estos pasos para crear una aplicación de aprendizaje automático en este tutorial.
- Crear aplicación usando python
- Construir ventana acoplable
- Tiempo de ejecución de SAP BTP Kyma
- 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:latest3. 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.
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: 745Mi3.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: 85013.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!
