Exportación y ejecución de un cerebro entrenado
- Duración total estimada: 15 minutos
- Tiempo activo: 10 minutos
- Tiempo de exportación:5 minutos
Use la función de exportación de cerebro para empaquetar el cerebro entrenado como un servicio contenedorizado que se pueda ejecutar en cualquier lugar donde esté instalado Docker, incluida la máquina local.
Nota
Bonsai export admite las siguientes arquitecturas de procesador:
- x64:sistemas AMD e Intel en hardware de 64 o 32 bits (sistemas Linux de uso general)
- arm64 (v8): sistemas RISC de 64 bits (Raspberry Pi 3 y versiones posteriores, Linux, sistemas industriales más recientes)
- arm32 (v7): sistemas RISC de 32 bits (Raspberry Pi 1, Raspberry Pi 2, Linux, sistemas industriales más antiguos)
Antes de comenzar
- Debe tener la CLI de Azure instalada.
- Debe tener Docker instalado en la máquina local. Docker Community Edition está disponible para Windows, Linux y MacOS.
- Debe tener acceso de lectura y escritura a Azure Container Registry (ACR) . Bonsai proporciona un ACR predeterminado al aprovisionar un área de trabajo en el mismo grupo de recursos que el área de trabajo.
- Debe tener un cerebro completo y totalmente entrenado.
Paso 1: Exportación del cerebro como una imagen de Docker
- Inicie sesión en el Bonsai UI.
- Seleccione el cerebro y la versión con los que desea trabajar.
- Navegue al panel Entrenar.
- Haga clic en el botón Export brain (Exportar cerebro).
- En el cuadro de diálogo que aparece:
- Proporcione un nombre para el cerebro exportado.
- Seleccione la arquitectura de procesador en la que se ejecutará el cerebro.
Captura de pantalla del panel del cerebro de exportación con la Bonsai arquitectura x64 seleccionada".
Una imagen del cerebro exportado se empaqueta como un contenedor de Docker, se guarda en el ACR asociado al área de trabajo y se agrega a la lista de cerebros disponibles en Exported Brains (Cerebros exportados) en el menú de la izquierda.
Bonsai muestra los cerebros exportados por el nombre que asigna durante la exportación. El nombre completo de la imagen en ACR es BRAIN_NAME:VERSION-OS_TYPE-ARCHITECTURE, donde:
- BRAIN_NAME es el nombre legible que se asigna al cerebro durante la exportación.
- VERSION es la versión del cerebro que eligió para exportar.
- OS_TYPE es el sistema operativo establecido durante la exportación.
- ARCHITECTURE es la arquitectura de procesador que seleccionó durante la exportación.
Paso 2: Descarga y ejecución del contenedor de Docker
Para descargar el cerebro exportado:
- Inicie sesión en Azure Container Registry con la CLI de Azure:
az login az acr login --name ACR_NAME - Capture la imagen contenedorizada del cerebro y guárdela en la máquina local:
docker pull \ WORKSPACE_NAME.azurecr.io/WORKSPACE_ID/BRAIN_NAME:VERSION-OS_TYPE-ARCHITECTURE - Ejecute el contenedor como un servidor local:
docker run \ --detach \ --publish 5000:5000 \ --name CONTAINER_NAME \ WORKSPACE_NAME.azurecr.io/WORKSPACE_ID/BRAIN_NAME:VERSION-OS_TYPE-ARCHITECTURE
- ACR_NAME:nombre de la instancia Azure Container Registry (ACR).
- WORKSPACE_NAME:el nombre que agregó al área de trabajo cuando se aprovisionó.
- WORKSPACE_ID:el identificador de recurso asignado por Azure del área de trabajo.
- CONTAINER_NAME: nombre legible para el contenedor de Docker local.
La marca detach inicia el contenedor en segundo plano sin bloquear el terminal. La marca publish indica a Docker que enrute el tráfico del puerto 5000 del contenedor al puerto 5000 del equipo local (localhost:5000).
Sugerencia
Puede copiar los comandos de descarga y ejecución con todos los marcadores de posición rellenados automáticamente desde la interfaz de Bonsai usuario:
- Haga clic en el menú de opciones ( ... ) junto al cerebro exportado que desea descargar.
- Seleccione View download info (Ver información de descarga) para mostrar los comandos de Bash.
Paso 3: Comprobación del estado del contenedor
Puede comprobar el estado del contenedor local con el comando docker ps o docker logs.
El comando docker ps muestra el estado de todos los contenedores en ejecución de forma predeterminada.
Los cerebros contenedorizados que se ejecutan correctamente se mostrarán con el estado "Arriba" e indicarán cuánto tiempo lleva ejecutándose el contenedor:
> docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
1310dba590e3 cfe62aa00691 "predict -m /saved_m…" 2 days ago Up 34 hours 0.0.0.0:5000->5000/tcp CONTAINER_NAME
Paso 4: Conversación con el cerebro exportado
Una vez que el contenedor se está ejecutando, puede comunicarse con el cerebro mediante programación mediante Brain API y el puerto 5000 del host local ( ).
Por ejemplo, suponga que tiene las siguientes definiciones en el archivo Inkling:
inkling "2.0"
using Math
using Goal
# Pole and track constants
const TrackLength = 0.5
const MaxPoleAngle = (12 * Math.Pi) / 180
# State info from the simulator
type SimState {
CartPosition: number, # Position of cart in meters
CartVelocity: number, # Velocity of cart in meters/sec
PoleAngle: number, # Current angle of pole in radians
PoleAngularVelocity: number, # Angular velocity of the pole in radians/sec
}
# Possible action results
type SimAction {
# Amount of force in x direction to apply to the cart.
Command: number<-1 .. 1>
}
# Define a concept graph with a single concept
graph (input: SimState): SimAction {
concept BalancePole(input): SimAction {
curriculum {
source simulator (Action: SimAction): SimState {
package "Cartpole"
}
# The objective of training is expressed as a goal with two
# objectives: keep the pole from falling over and stay on the track
goal (State: SimState) {
avoid `Fall Over`:
Math.Abs(State.pole_angle) in Goal.RangeAbove(MaxPoleAngle)
avoid `Out Of Range`:
Math.Abs(State.cart_position) in Goal.RangeAbove(TrackLength / 2)
}
}
}
}
La llamada API tendría el siguiente aspecto:
import requests
import json
# General variables
url = "http://localhost:5000"
predictPath = "/v2/clients/{clientId}/predict"
headers = {
"Content-Type": "application/json"
}
# Set a random UUID for the client.
# The same client ID will be used for every call
myClientId = str(uuid.uuid4())
# Build the endpoint reference
endpoint = url + predictPath.replace("{clientId}", myClientId)
# Set the request variables
requestBody = {
"state": {
"CartPosition": 3,
"CartVelocity": 1.5,
"PoleAngle": 0.75,
"PoleAngularVelocity": 0.1
}
}
# Send the POST request
response = requests.post(
endpoint,
data = json.dumps(requestBody),
headers = headers
)
# Extract the JSON response
prediction = response.json()
# Access the JSON result: full response object
print(prediction)
# Access the JSON result: all concepts
print(prediction['concepts'])
# Access the JSON result: specific field
print(prediction['concepts']['BalancePole']['action']['Command'])
La llamada API tendría el siguiente aspecto:
import requests
import json
# General variables
url = "http://localhost:5000"
predictionPath = "/v1/prediction"
headers = {
"Content-Type": "application/json"
}
# Build the endpoint reference
endpoint = url + predictionPath
# Set the request variables
requestBody = {
"CartPosition": 3,
"CartVelocity": 1.5,
"PoleAngle": 0.75,
"PoleAngularVelocity": 0.1
}
# Send the POST request
response = requests.post(
endpoint,
data = json.dumps(requestBody),
headers = headers
)
# Extract the JSON response
prediction = response.json()
# Access the JSON result: full response object
print(prediction)
# Access the JSON result: specific field
print(prediction['Command'])
Sugerencia
El contenedor servirá los detalles de la API para el cerebro, incluidos los objetos de solicitud y respuesta personalizados en http://localhost:5000/v1/doc/index.html
Script 5: Limpieza
Detenga el contenedor de Docker cuando termine de trabajar con el cerebro localmente.
Para detener el cerebro, use el comando docker ps para obtener el identificador del contenedor local y el comando docker stop CONTAINER_ID para detener el contenedor asociado.
> docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
1310dba590e3 cfe62aa00691 "predict -m /saved_m…" 2 days ago Up 34 hours 0.0.0.0:5000->5000/tcp CONTAINER_NAME
> docker stop 1310dba590e3