Predecir la probabilidad de fallo de la flota de vehículos utilizando Amazon SageMaker Jumpstart

'Predecir la probabilidad de fallo de vehículos con Amazon SageMaker Jumpstart'

El mantenimiento predictivo es crucial en las industrias automotrices porque puede evitar fallas mecánicas repentinas y actividades de mantenimiento reactivas que interrumpen las operaciones. Al predecir las fallas de los vehículos y programar el mantenimiento y las reparaciones, reducirá el tiempo de inactividad, mejorará la seguridad y aumentará los niveles de productividad.

¿Y si pudiéramos aplicar técnicas de aprendizaje profundo a áreas comunes que generan fallas en los vehículos, tiempo de inactividad no planificado y costos de reparación?

En esta publicación, le mostramos cómo entrenar e implementar un modelo para predecir la probabilidad de falla de una flota de vehículos utilizando Amazon SageMaker JumpStart. SageMaker JumpStart es el centro de aprendizaje automático (ML) de Amazon SageMaker, que proporciona modelos preentrenados y disponibles públicamente para una amplia gama de tipos de problemas para ayudarlo a comenzar con ML. La solución descrita en la publicación está disponible en GitHub.

Plantillas de solución de SageMaker JumpStart

SageMaker JumpStart ofrece soluciones de un clic de extremo a extremo para muchos casos de uso comunes de ML. Explore los siguientes casos de uso para obtener más información sobre las plantillas de solución disponibles:

• Destacar el texto mientras se está hablando utilizando Amazon Polly
• XPENG lanza el G6 Coupe SUV para el mercado general
• NVIDIA CEO, ejecutivos europeos de IA generativa discuten claves para el éxito.

• Pronóstico de demanda
• Predicción de calificación crediticia
• Detección de fraude
• Visión por computadora
• Extraer y analizar datos de documentos
• Mantenimiento predictivo
• Predicción de rotación
• Recomendaciones personalizadas
• Aprendizaje por refuerzo
• Salud y ciencias de la vida
• Precios financieros

Las plantillas de solución de SageMaker JumpStart cubren una variedad de casos de uso, bajo cada uno de los cuales se ofrecen varias plantillas de solución diferentes (la solución en esta publicación, Mantenimiento predictivo para flotas de vehículos, se encuentra en la sección Soluciones). Elija la plantilla de solución que mejor se adapte a su caso de uso en la página de inicio de SageMaker JumpStart. Para obtener más información sobre soluciones específicas en cada caso de uso y cómo lanzar una solución de SageMaker JumpStart, consulte las Plantillas de solución.

Descripción general de la solución

La solución de mantenimiento predictivo de AWS para flotas de vehículos aplica técnicas de aprendizaje profundo a áreas comunes que generan fallas en los vehículos, tiempo de inactividad no planificado y costos de reparación. Sirve como un bloque de construcción inicial para llegar a un prototipo en un corto período de tiempo. Esta solución contiene funcionalidad de preparación y visualización de datos dentro de SageMaker y le permite entrenar y optimizar los hiperparámetros de modelos de aprendizaje profundo para su conjunto de datos. Puede utilizar sus propios datos o probar la solución con un conjunto de datos sintéticos como parte de esta solución. Esta versión procesa datos de sensores de vehículos a lo largo del tiempo. Una versión posterior procesará datos de registros de mantenimiento.

El siguiente diagrama muestra cómo puede utilizar esta solución con los componentes de SageMaker. Como parte de la solución, se utilizan los siguientes servicios:

• Amazon S3: utilizamos Amazon Simple Storage Service (Amazon S3) para almacenar conjuntos de datos
• Notebook de SageMaker: utilizamos un notebook para preprocesar y visualizar los datos, y para entrenar el modelo de aprendizaje profundo
• Endpoint de SageMaker: utilizamos el endpoint para implementar el modelo entrenado

El flujo de trabajo incluye los siguientes pasos:

1. Se crea una extracción de datos históricos del Sistema de Gestión de Flotas que contiene datos de vehículos y registros de sensores.
2. Después de entrenar el modelo de ML, se implementa el artefacto del modelo de SageMaker.
3. El vehículo conectado envía registros de sensores a AWS IoT Core (alternativamente, a través de una interfaz HTTP).
4. Los registros de sensores se persisten a través de Amazon Kinesis Data Firehose.
5. Los registros de sensores se envían a AWS Lambda para consultas contra el modelo y realizar predicciones.
6. La función Lambda envía los registros de sensores para inferencia del modelo de SageMaker para realizar predicciones.
7. Las predicciones se persisten en Amazon Aurora.
8. Los resultados agregados se muestran en un panel de control de Amazon QuickSight.
9. Se envían notificaciones en tiempo real sobre la probabilidad de falla predicha a Amazon Simple Notification Service (Amazon SNS).
10. Amazon SNS envía las notificaciones de vuelta al vehículo conectado.

La solución consta de seis notebooks:

• 0_demo.ipynb: una vista previa rápida de nuestra solución
• 1_introduction.ipynb: introducción y descripción general de la solución
• 2_data_preparation.ipynb: preparar un conjunto de datos de muestra
• 3_data_visualization.ipynb: visualizar nuestro conjunto de datos de muestra
• 4_model_training.ipynb: entrenar un modelo en nuestro conjunto de datos de muestra para detectar fallas
• 5_results_analysis.ipynb: analizar los resultados del modelo que entrenamos

Prerrequisitos

Amazon SageMaker Studio es el entorno de desarrollo integrado (IDE) dentro de SageMaker que nos proporciona todas las características de ML que necesitamos en una sola interfaz. Antes de poder ejecutar SageMaker JumpStart, debemos configurar SageMaker Studio. Puede omitir este paso si ya tiene su propia versión de SageMaker Studio en funcionamiento.

Lo primero que debemos hacer antes de poder usar cualquier servicio de AWS es asegurarnos de haber registrado y creado una cuenta de AWS. Luego creamos un usuario administrativo y un grupo. Para obtener instrucciones sobre ambos pasos, consulte Configurar los requisitos previos de Amazon SageMaker.

El siguiente paso es crear un dominio de SageMaker. Un dominio configura todo el almacenamiento y le permite agregar usuarios para acceder a SageMaker. Para obtener más información, consulte Iniciar en el dominio de Amazon SageMaker.

Finalmente, inicie SageMaker Studio. Para esta publicación, recomendamos lanzar una aplicación de perfil de usuario. Para obtener instrucciones, consulte Lanzar Amazon SageMaker Studio.

Para ejecutar esta solución de SageMaker JumpStart y tener la infraestructura implementada en su cuenta de AWS, debe crear una instancia activa de SageMaker Studio (consulte Iniciar en Amazon SageMaker Studio). Cuando su instancia esté lista, use las instrucciones en SageMaker JumpStart para lanzar la solución. Los artefactos de la solución se incluyen en este repositorio de GitHub como referencia.

Lanzar la solución SageMaker Jumpstart

Para comenzar con la solución, complete los siguientes pasos:

1. En la consola de SageMaker Studio, elija JumpStart.
2. En la pestaña Soluciones, elija Mantenimiento predictivo para flotas de vehículos.
3. Elija Lanzar. La implementación de la solución lleva unos minutos.
4. Después de que se implemente la solución, elija Abrir cuaderno.

Si se le solicita seleccionar un kernel, elija PyTorch 1.8 Python 3.6 para todos los cuadernos de esta solución.

Vista previa de la solución

Primero trabajamos en el cuaderno 0_demo.ipynb. En este cuaderno, puede obtener una vista previa rápida de cómo se verá el resultado cuando complete el cuaderno completo para esta solución.

Elija Ejecutar y Ejecutar todas las celdas para ejecutar todas las celdas en SageMaker Studio (o Celda y Ejecutar todas las celdas en una instancia de cuaderno de SageMaker). Puede ejecutar todas las celdas en cada cuaderno una tras otra. Asegúrese de que todas las celdas finalicen el procesamiento antes de pasar al siguiente cuaderno.

Esta solución depende de un archivo de configuración para ejecutar los recursos de AWS aprovisionados. Generamos el archivo de la siguiente manera:

import boto3
import os
import json

client = boto3.client('servicecatalog')
cwd = os.getcwd().split('/')
i= cwd.index('S3Downloads')
pp_name = cwd[i + 1]
pp = client.describe_provisioned_product(Name=pp_name)
record_id = pp['ProvisionedProductDetail']['LastSuccessfulProvisioningRecordId']
record = client.describe_record(Id=record_id)

keys = [ x['OutputKey'] for x in record['RecordOutputs'] if 'OutputKey' and 'OutputValue' in x]
values = [ x['OutputValue'] for x in record['RecordOutputs'] if 'OutputKey' and 'OutputValue' in x]
stack_output = dict(zip(keys, values))

with open(f'/root/S3Downloads/{pp_name}/stack_outputs.json', 'w') as f:
json.dump(stack_output, f)

Tenemos algunos datos de muestra de series temporales que consisten en la tensión de la batería y la corriente de la batería de un vehículo a lo largo del tiempo. A continuación, cargamos y visualizamos los datos de muestra. Como se muestra en las siguientes capturas de pantalla, los valores de tensión y corriente están en el eje Y y las lecturas (19 lecturas registradas) están en el eje X.

Anteriormente hemos entrenado un modelo con estos datos de tensión y corriente que predice la probabilidad de fallo del vehículo y hemos implementado el modelo como un punto de enlace en SageMaker. Llamaremos a este punto de enlace con algunos datos de muestra para determinar la probabilidad de fallo en el próximo período de tiempo.

Dados los datos de entrada de muestra, la probabilidad predicha de fallo es 45.73%.

Para pasar a la siguiente etapa, elige Haz clic aquí para continuar.

Introducción y descripción general de la solución

El cuaderno 1_introduction.ipynb proporciona una descripción general de la solución y las etapas, y ofrece una visión del archivo de configuración que contiene la definición de contenido, el período de muestreo de datos, el número de muestras de entrenamiento y prueba, los parámetros, la ubicación y los nombres de columna para el contenido generado.

Después de revisar este cuaderno, puedes pasar a la siguiente etapa.

Preparar un conjunto de datos de muestra

Preparamos un conjunto de datos de muestra en el cuaderno 2_data_preparation.ipynb.

Primero generamos el archivo de configuración para esta solución:

import boto3
import os
import json

client = boto3.client('servicecatalog')
cwd = os.getcwd().split('/')
i= cwd.index('S3Downloads')
pp_name = cwd[i + 1]
pp = client.describe_provisioned_product(Name=pp_name)
record_id = pp['ProvisionedProductDetail']['LastSuccessfulProvisioningRecordId']
record = client.describe_record(Id=record_id)

keys = [ x['OutputKey'] for x in record['RecordOutputs'] if 'OutputKey' and 'OutputValue' in x]
values = [ x['OutputValue'] for x in record['RecordOutputs'] if 'OutputKey' and 'OutputValue' in x]
stack_output = dict(zip(keys, values))

with open(f'/root/S3Downloads/{pp_name}/stack_outputs.json', 'w') as f:
json.dump(stack_output, f)
import os

from source.config import Config
from source.preprocessing import pivot_data, sample_dataset
from source.dataset import DatasetGenerator
config = Config(filename="config/config.yaml", fetch_sensor_headers=False)
config

Las propiedades de configuración son las siguientes:

fleet_info_fn=data/example_fleet_info.csv
fleet_sensor_logs_fn=data/example_fleet_sensor_logs.csv
vehicle_id_column=vehicle_id
timestamp_column=timestamp
target_column=target
period_ms=30000
dataset_size=25000
window_length=20
chunksize=10000
processing_chunksize=2500
fleet_dataset_fn=data/processed/fleet_dataset.csv
train_dataset_fn=data/processed/train_dataset.csv
test_dataset_fn=data/processed/test_dataset.csv
period_column=period_ms

Puedes definir tu propio conjunto de datos o utilizar nuestros scripts para generar un conjunto de datos de muestra:

if should_generate_data:
    fleet_statistics_fn = "data/generation/fleet_statistics.csv"
    generator = DatasetGenerator(fleet_statistics_fn=fleet_statistics_fn,
                                 fleet_info_fn=config.fleet_info_fn, 
                                 fleet_sensor_logs_fn=config.fleet_sensor_logs_fn, 
                                 period_ms=config.period_ms, 
                                 )
    generator.generate_dataset()

assert os.path.exists(config.fleet_info_fn), "Por favor, copia tus datos a {}".format(config.fleet_info_fn)
assert os.path.exists(config.fleet_sensor_logs_fn), "Por favor, copia tus datos a {}".format(config.fleet_sensor_logs_fn)

Puedes fusionar los datos del sensor y los datos de los vehículos de la flota juntos:

pivot_data(config)
sample_dataset(config)

Ahora podemos pasar a la visualización de datos.

Visualizar nuestro conjunto de datos de muestra

Visualizamos nuestro conjunto de datos de muestra en 3_data_vizualization.ipynb. Esta solución se basa en un archivo de configuración para ejecutar los recursos de AWS provisionados. Generemos un archivo similar al cuaderno anterior.

La siguiente captura de pantalla muestra nuestro conjunto de datos.

A continuación, construyamos el conjunto de datos:

train_ds = PMDataset_torch(
    config.train_dataset_fn,
    sensor_headers=config.sensor_headers,
    target_column=config.target_column,
    standardize=True)

properties = train_ds.vehicle_properties_headers.copy()
properties.remove('vehicle_id')
properties.remove('timestamp')
properties.remove('period_ms')

Ahora que el conjunto de datos está listo, visualicemos las estadísticas de los datos. La siguiente captura de pantalla muestra la distribución de los datos según la marca del vehículo, el tipo de motor, la clase del vehículo y el modelo.

Comparando los datos del registro, veamos un ejemplo de la media de voltaje en diferentes años para las marcas E y C (al azar).

La media de voltaje y corriente está en el eje Y y el número de lecturas está en el eje X.

• Valores posibles para log_target: [‘marca’, ‘modelo’, ‘año’, ‘clase_vehículo’, ‘tipo_motor’]
  • Valor asignado al azar para log_target: marca
• Valores posibles para log_target_value1: [‘Marca A’, ‘Marca B’, ‘Marca E’, ‘Marca C’, ‘Marca D’]
  • Valor asignado al azar para log_target_value1: Marca B
• Valores posibles para log_target_value2: [‘Marca A’, ‘Marca B’, ‘Marca E’, ‘Marca C’, ‘Marca D’]
  • Valor asignado al azar para log_target_value2: Marca D

Basándonos en lo anterior, asumimos log_target: marca, log_target_value1: Marca B y log_target_value2: Marca D

Los siguientes gráficos desglosan la media de los datos del registro.

Los siguientes gráficos visualizan un ejemplo de diferentes valores de registro de los sensores en función del voltaje y la corriente.

Entrenar un modelo en nuestro conjunto de datos de muestra para detectar fallas

En el cuaderno 4_model_training.ipynb, entrenamos un modelo en nuestro conjunto de datos de muestra para detectar fallas.

Generemos el archivo de configuración similar al cuaderno anterior y luego procedamos con la configuración de entrenamiento:

sage_session = sagemaker.session.Session()
s3_bucket = sagemaker_configs["S3Bucket"]  
s3_output_path = 's3://{}/'.format(s3_bucket)
print("Ruta del cubo S3: {}".format(s3_output_path))

# ejecutar en local_mode en esta máquina o como un SageMaker TrainingJob
local_mode = False

if local_mode:
    instance_type = 'local'
else:
    instance_type = sagemaker_configs["SageMakerTrainingInstanceType"]
    
role = sagemaker.get_execution_role()
print("Usando el rol IAM arn: {}".format(role))
# solo se ejecuta desde una instancia de cuaderno SageMaker
if local_mode:
    !/bin/bash ./setup.sh
cpu_or_gpu = 'gpu' if instance_type.startswith('ml.p') else 'cpu'

Ahora podemos definir los datos e iniciar la optimización de hiperparámetros:

%%time

estimator = PyTorch(entry_point="train.py",
                    source_dir='source',                    
                    role=role,
                    dependencies=["source/dl_utils"],
                    instance_type=instance_type,
                    instance_count=1,
                    output_path=s3_output_path,
                    framework_version="1.5.0",
                    py_version='py3',
                    base_job_name=job_name_prefix,
                    metric_definitions=metric_definitions,
                    hyperparameters= {
                        'epoch': 100,  # ajústalo según tus necesidades
                        'target_column': config.target_column,
                        'sensor_headers': json.dumps(config.sensor_headers),
                        'train_input_filename': os.path.basename(config.train_dataset_fn),
                        'test_input_filename': os.path.basename(config.test_dataset_fn),
                        }
                     )

if local_mode:
    estimator.fit({'train': training_data, 'test': testing_data})
%%time

tuner = HyperparameterTuner(estimator,
                            objective_metric_name='test_auc',
                            objective_type='Maximize',
                            hyperparameter_ranges=hyperparameter_ranges,
                            metric_definitions=metric_definitions,
                            max_jobs=max_jobs,
                            max_parallel_jobs=max_parallel_jobs,
                            base_tuning_job_name=job_name_prefix)
tuner.fit({'train': training_data, 'test': testing_data})

Analizar los resultados del modelo que entrenamos

En el cuaderno 5_results_analysis.ipynb, obtenemos datos de nuestro trabajo de ajuste de hiperparámetros, visualizamos las métricas de todos los trabajos para identificar el mejor trabajo y construimos un punto final para el mejor trabajo de entrenamiento.

Generemos ahora el archivo de configuración similar al cuaderno anterior y visualicemos las métricas de todos los trabajos. El siguiente gráfico visualiza la precisión de prueba versus época.

La siguiente captura de pantalla muestra los trabajos de ajuste de hiperparámetros que ejecutamos.

Ahora puedes visualizar los datos del mejor trabajo de entrenamiento (de los cuatro trabajos de entrenamiento) basado en la precisión de prueba (rojo).

Como podemos ver en las siguientes capturas de pantalla, la pérdida de prueba disminuye y el AUC y la precisión aumentan con las épocas.

Con base en las visualizaciones, ahora podemos construir un punto final para el mejor trabajo de entrenamiento:

%%time

role = sagemaker.get_execution_role()

model = PyTorchModel(model_data=model_artifact,
                     role=role,
                     entry_point="inference.py",
                     source_dir="source/dl_utils",
                     framework_version='1.5.0',
                     py_version = 'py3',
                     name=sagemaker_configs["SageMakerModelName"],
                     code_location="s3://{}/endpoint".format(s3_bucket)
                    )

endpoint_instance_type = sagemaker_configs["SageMakerInferenceInstanceType"]

predictor = model.deploy(initial_instance_count=1, instance_type=endpoint_instance_type, endpoint_name=sagemaker_configs["SageMakerEndpointName"])

def custom_np_serializer(data):
    return json.dumps(data.tolist())
    
def custom_np_deserializer(np_bytes, content_type='application/x-npy'):
    out = np.array(json.loads(np_bytes.read()))
    return out

predictor.serializer = custom_np_serializer
predictor.deserializer = custom_np_deserializer

Después de construir el punto final, podemos probar el predictor pasándole registros de sensor de muestra:

import botocore

config = botocore.config.Config(read_timeout=200)
runtime = boto3.client('runtime.sagemaker', config=config)

data = np.ones(shape=(1, 20, 2)).tolist()
payload = json.dumps(data)

response = runtime.invoke_endpoint(EndpointName=sagemaker_configs["SageMakerEndpointName"],
ContentType='application/json',
Body=payload)
out = json.loads(response['Body'].read().decode())[0]

print("Dado los datos de entrada de muestra, la probabilidad predicha de falla es del {:0.2f}%".format(100*(1.0-out[0])))

Dada la muestra de datos de entrada, la probabilidad predicha de falla es 34.60%.

Limpieza

Cuando hayas terminado con esta solución, asegúrate de eliminar todos los recursos no deseados de AWS. En la página Mantenimiento predictivo para flotas de vehículos, debajo de Eliminar solución, elige Eliminar todos los recursos para eliminar todos los recursos asociados con la solución.

Debes eliminar manualmente los recursos adicionales que hayas creado en esta libreta. Algunos ejemplos incluyen los buckets S3 adicionales (para el bucket predeterminado de la solución) y los puntos de enlace de SageMaker adicionales (usando un nombre personalizado).

Personalizar la solución

Nuestra solución es fácil de personalizar. Para modificar las visualizaciones de los datos de entrada, consulta sagemaker/3_data_visualization.ipynb . Para personalizar el aprendizaje automático, consulta sagemaker/source/train.py y sagemaker/source/dl_utils/network.py . Para personalizar el procesamiento del conjunto de datos, consulta sagemaker/1_introduction.ipynb para obtener información sobre cómo definir el archivo de configuración.

Además, puedes cambiar la configuración en el archivo de configuración. La configuración predeterminada es la siguiente:

fleet_info_fn=data/example_fleet_info.csv
fleet_sensor_logs_fn=data/example_fleet_sensor_logs.csv
vehicle_id_column=vehicle_id
timestamp_column=timestamp
target_column=target
period_ms=30000
dataset_size=10000
window_length=20
chunksize=10000
processing_chunksize=1000
fleet_dataset_fn=data/processed/fleet_dataset.csv
train_dataset_fn=data/processed/train_dataset.csv
test_dataset_fn=data/processed/test_dataset.csv
period_column=period_ms

El archivo de configuración tiene los siguientes parámetros:

• fleet_info_fn, fleet_sensor_logs_fn, fleet_dataset_fn, train_dataset_fn y test_dataset_fn definen la ubicación de los archivos de conjunto de datos
• vehicle_id_column, timestamp_column, target_column y period_column definen los encabezados de las columnas
• dataset_size, chunksize, processing_chunksize, period_ms y window_length definen las propiedades del conjunto de datos

Conclusión

En esta publicación, te mostramos cómo entrenar e implementar un modelo para predecir la probabilidad de falla de una flota de vehículos utilizando SageMaker JumpStart. La solución se basa en modelos de aprendizaje automático y aprendizaje profundo y permite una amplia variedad de datos de entrada, incluidos datos de sensores variables en el tiempo. Debido a que cada vehículo tiene una telemetría diferente, puedes ajustar el modelo proporcionado a la frecuencia y tipo de datos que tengas.

Para obtener más información sobre lo que puedes hacer con SageMaker JumpStart, consulta lo siguiente:

• Automatización de inspección visual utilizando Amazon SageMaker JumpStart
• Ejecución de ajuste automático de modelos con Amazon SageMaker JumpStart
• Comienza con la IA generativa en AWS utilizando Amazon SageMaker JumpStart

Recursos

• Guía del desarrollador de Amazon SageMaker
• Guía del desarrollador de SageMaker JumpStart
• Realiza un ajuste automático de modelos con SageMaker
• Solución de mantenimiento predictivo de SageMaker JumpStart

We will continue to update Zepes; if you have any questions or suggestions, please contact us!