Prevedi la probabilità di guasto della flotta di veicoli utilizzando Amazon SageMaker Jumpstart

Prevedi la probabilità di guasto dei veicoli usando Amazon SageMaker Jumpstart.

La manutenzione predittiva è fondamentale nelle industrie automobilistiche perché può evitare guasti meccanici improvvisi e attività di manutenzione reattiva che interrompono le operazioni. Prevedendo i guasti dei veicoli e pianificando la manutenzione e le riparazioni, si ridurrà il tempo di inattività, si migliorerà la sicurezza e si aumenteranno i livelli di produttività.

E se potessimo applicare tecniche di deep learning alle aree comuni che causano guasti ai veicoli, tempi di inattività imprevisti e costi di riparazione?

In questo post, ti mostriamo come addestrare e distribuire un modello per prevedere la probabilità di guasto di una flotta di veicoli utilizzando Amazon SageMaker JumpStart. SageMaker Jumpstart è l’hub di apprendimento automatico (ML) di Amazon SageMaker, che fornisce modelli pre-addestrati e disponibili pubblicamente per una vasta gamma di tipi di problemi per aiutarti a iniziare con l’ML. La soluzione descritta nel post è disponibile su GitHub.

Modelli di soluzione SageMaker JumpStart

SageMaker JumpStart fornisce soluzioni end-to-end con un solo clic per molti casi d’uso comuni di ML. Esplora i seguenti casi d’uso per ulteriori informazioni sui modelli di soluzione disponibili:

• Evidenzia il testo mentre viene pronunciato utilizzando Amazon Polly
• Un Cambiamento nel Meteo IA, Calcolo Accelerato Promettono Previsioni Più Veloci ed Efficienti
• XPENG lancia la G6 Coupe SUV per il mercato di massa

• Previsione della domanda
• Previsione del rating di credito
• Rilevamento delle frodi
• Visione artificiale
• Estrazione e analisi dei dati dai documenti
• Manutenzione predittiva
• Previsione del churn
• Raccomandazioni personalizzate
• Apprendimento per rinforzo
• Sanità e scienze della vita
• Prezzi finanziari

I modelli di soluzione SageMaker Jumpstart coprono una varietà di casi d’uso, ognuno dei quali offre diversi modelli di soluzione (la soluzione in questo post, Manutenzione Predittiva per Flotte di Veicoli, si trova nella sezione Soluzioni). Scegli il modello di soluzione che meglio si adatta al tuo caso d’uso dalla pagina iniziale di SageMaker JumpStart. Per ulteriori informazioni sulle soluzioni specifiche di ogni caso d’uso e su come lanciare una soluzione di SageMaker JumpStart, consulta i Modelli di Soluzione.

Panoramica della soluzione

La soluzione di manutenzione predittiva AWS per flotte automobilistiche applica tecniche di deep learning alle aree comuni che causano guasti ai veicoli, tempi di inattività imprevisti e costi di riparazione. Serve come primo blocco di costruzione per arrivare a una prova di concetto in un breve periodo di tempo. Questa soluzione contiene funzionalità di preparazione e visualizzazione dei dati all’interno di SageMaker e ti consente di addestrare e ottimizzare gli iperparametri dei modelli di deep learning per il tuo dataset. Puoi utilizzare i tuoi dati oppure provare la soluzione con un dataset sintetico come parte di questa soluzione. Questa versione elabora i dati dei sensori dei veicoli nel tempo. Una versione successiva elaborerà i dati dei record di manutenzione.

Il diagramma seguente mostra come puoi utilizzare questa soluzione con i componenti di SageMaker. Come parte della soluzione, vengono utilizzati i seguenti servizi:

• Amazon S3 – Utilizziamo Amazon Simple Storage Service (Amazon S3) per archiviare i dataset
• Notebook SageMaker – Utilizziamo un notebook per preprocessare e visualizzare i dati e per addestrare il modello di deep learning
• Endpoint SageMaker – Utilizziamo l’endpoint per distribuire il modello addestrato

Il flusso di lavoro include i seguenti passaggi:

1. Viene creato un estratto dei dati storici dal Sistema di Gestione Flotte contenente dati dei veicoli e registri dei sensori.
2. Dopo che il modello di ML è stato addestrato, l’artefatto del modello di SageMaker viene distribuito.
3. Il veicolo connesso invia registri dei sensori al core di AWS IoT (alternativamente, tramite un’interfaccia HTTP).
4. I registri dei sensori vengono conservati tramite Amazon Kinesis Data Firehose.
5. I registri dei sensori vengono inviati ad AWS Lambda per interrogare il modello e fare previsioni.
6. La Lambda invia i registri dei sensori all’inferenza del modello di Sagemaker per le previsioni.
7. Le previsioni vengono conservate in Amazon Aurora.
8. I risultati aggregati vengono visualizzati su un dashboard di Amazon QuickSight.
9. Vengono inviate notifiche in tempo reale sulla probabilità di guasto prevista al servizio di notifiche semplice di Amazon (Amazon SNS).
10. Amazon SNS invia le notifiche al veicolo connesso.

La soluzione è composta da sei notebook:

• 0_demo.ipynb – Una rapida anteprima della nostra soluzione
• 1_introduction.ipynb – Introduzione e panoramica della soluzione
• 2_data_preparation.ipynb – Preparare un dataset di esempio
• 3_data_visualization.ipynb – Visualizzare il nostro dataset di esempio
• 4_model_training.ipynb – Addestrare un modello sul nostro dataset di esempio per rilevare i guasti
• 5_results_analysis.ipynb – Analizzare i risultati del modello che abbiamo addestrato

Prerequisiti

Amazon SageMaker Studio è l’ambiente di sviluppo integrato (IDE) all’interno di SageMaker che ci fornisce tutte le funzionalità di ML di cui abbiamo bisogno in un’unica interfaccia. Prima di poter eseguire SageMaker JumpStart, è necessario configurare SageMaker Studio. Puoi saltare questo passaggio se hai già la tua versione di SageMaker Studio in esecuzione.

La prima cosa da fare prima di poter utilizzare qualsiasi servizio AWS è assicurarsi di essersi registrati e creato un account AWS. Quindi creiamo un utente amministratore e un gruppo. Per istruzioni su entrambi i passaggi, fare riferimento a Configurazione dei prerequisiti di Amazon SageMaker .

Il passaggio successivo è creare un dominio SageMaker. Un dominio imposta l’archiviazione e consente di aggiungere utenti per accedere a SageMaker. Per ulteriori informazioni, fare riferimento a Onboard to Amazon SageMaker Domain . Questa demo è creata nella regione AWS us-east-1.

Infine, avviamo SageMaker Studio. Per questo post, consigliamo di avviare un’applicazione di profilo utente. Per istruzioni, fare riferimento a Launch Amazon SageMaker Studio .

Per eseguire questa soluzione SageMaker JumpStart ed avere l’infrastruttura distribuita nel tuo account AWS, è necessario creare un’istanza attiva di SageMaker Studio (vedi Onboard to Amazon SageMaker Studio ). Quando la tua istanza è pronta, utilizza le istruzioni in SageMaker JumpStart per avviare la soluzione. Gli artefatti della soluzione sono inclusi in questo repository GitHub per riferimento.

Avvia la soluzione SageMaker Jumpstart

Per iniziare con la soluzione, segui i seguenti passaggi:

1. Nella console di SageMaker Studio, scegli JumpStart .
2. Nella scheda Solutions, scegli Predictive Maintenance for Vehicle Fleets .
3. Scegli Launch . Ci vogliono alcuni minuti per distribuire la soluzione.
4. Dopo che la soluzione è stata distribuita, scegli Open Notebook.

Se ti viene chiesto di selezionare un kernel, scegli PyTorch 1.8 Python 3.6 per tutti i notebook di questa soluzione.

Anteprima della soluzione

Prima di tutto lavoriamo sul notebook 0_demo.ipynb. In questo notebook, puoi ottenere una rapida anteprima di come sarà il risultato quando completi il notebook completo per questa soluzione.

Scegli Run e Run All Cells per eseguire tutte le celle in SageMaker Studio (o Cell e Run All in un’istanza di notebook SageMaker). Puoi eseguire tutte le celle in ciascun notebook una dopo l’altra. Assicurati che tutte le celle finiscano di elaborare prima di passare al notebook successivo.

Questa soluzione si basa su un file di configurazione per eseguire le risorse AWS fornite. Generiamo il file come segue:

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)

Abbiamo alcuni dati di input di serie temporali di esempio che consistono nella tensione e nella corrente della batteria di un veicolo nel tempo. Successivamente, caricare e visualizzare i dati di esempio. Come mostrato nelle seguenti schermate, i valori di tensione e corrente sono sull’asse Y e le letture (19 letture registrate) sono sull’asse X.

In precedenza abbiamo addestrato un modello su questi dati di tensione e corrente che predice la probabilità di guasto del veicolo e abbiamo implementato il modello come un endpoint in SageMaker. Chiameremo questo endpoint con alcuni dati di esempio per determinare la probabilità di guasto nel prossimo periodo di tempo.

Dati i dati di input di esempio, la probabilità predetta di guasto è 45.73%.

Per passare alla fase successiva, scegliere Fare clic qui per continuare.

Introduzione e panoramica della soluzione

Il notebook 1_introduction.ipynb fornisce una panoramica della soluzione e delle fasi, e una visione del file di configurazione che ha la definizione del contenuto, il periodo di campionamento dei dati, il conteggio di campioni di addestramento e di test, i parametri, la posizione e i nomi delle colonne per il contenuto generato.

Dopo aver esaminato questo notebook, è possibile passare alla fase successiva.

Preparare un set di dati di esempio

Prepariamo un set di dati di esempio nel notebook 2_data_preparation.ipynb.

Prima generiamo il file di configurazione per questa soluzione:

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

Le proprietà di configurazione sono le seguenti:

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

È possibile definire il proprio set di dati o utilizzare i nostri script per generare un set di dati di esempio:

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), "Copiare i propri dati in {}".format(config.fleet_info_fn)
assert os.path.exists(config.fleet_sensor_logs_fn), "Copiare i propri dati in {}".format(config.fleet_sensor_logs_fn)

Puoi unire insieme i dati del sensore e i dati dei veicoli della flotta:

pivot_data(config)
sample_dataset(config)

Ora possiamo passare alla visualizzazione dei dati.

Visualizza il nostro dataset di esempio

Visualizziamo il nostro dataset di esempio in 3_data_visualization.ipynb. Questa soluzione si basa su un file di configurazione per eseguire le risorse AWS fornite. Generiamo il file in modo simile al notebook precedente.

La seguente schermata mostra il nostro dataset.

Successivamente, creiamo il dataset:

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')

Ora che il dataset è pronto, visualizziamo le statistiche dei dati. La seguente schermata mostra la distribuzione dei dati in base alla marca del veicolo, al tipo di motore, alla classe del veicolo e al modello.

Confrontando i dati di log, analizziamo un esempio della tensione media in diversi anni per Make E e C (casuale).

La media di tensione e corrente è sull’asse Y e il numero di letture è sull’asse X.

• Valori possibili per log_target: [‘make’, ‘model’, ‘year’, ‘vehicle_class’, ‘engine_type’]
  • Valore assegnato casualmente a log_target: make
• Valori possibili per log_target_value1: [‘Make A’, ‘Make B’, ‘Make E’, ‘Make C’, ‘Make D’]
  • Valore assegnato casualmente a log_target_value1: Make B
• Valori possibili per log_target_value2: [‘Make A’, ‘Make B’, ‘Make E’, ‘Make C’, ‘Make D’]
  • Valore assegnato casualmente a log_target_value2: Make D

In base a quanto sopra, assumiamo log_target: make, log_target_value1: Make B e log_target_value2: Make D

I seguenti grafici analizzano la media dei dati di log.

I seguenti grafici visualizzano un esempio di diversi valori di log del sensore rispetto alla tensione e alla corrente.

Addestra un modello sul nostro dataset di esempio per rilevare gli errori

Nel notebook 4_model_training.ipynb, addestriamo un modello sul nostro dataset di esempio per rilevare gli errori.

Generiamo il file di configurazione in modo simile al notebook precedente e procediamo con la configurazione dell’addestramento:

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

# esegui in modalità locale su questa macchina, o come 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 il ruolo IAM arn: {}".format(role))
# esegui solo da un'istanza di notebook SageMaker
if local_mode:
    !/bin/bash ./setup.sh
cpu_or_gpu = 'gpu' if instance_type.startswith('ml.p') else 'cpu'

Ora possiamo definire i dati e avviare l’ottimizzazione degli iperparametri:

%%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,  # regolalo in base alle tue esigenze
                        '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})

Analizza i risultati del modello che abbiamo addestrato

Nel notebook 5_results_analysis.ipynb, otteniamo i dati dal nostro lavoro di ottimizzazione degli iperparametri, visualizziamo le metriche di tutti i lavori per identificare il miglior lavoro e creiamo un endpoint per il miglior lavoro di addestramento.

Generiamo il file di configurazione simile al notebook precedente e visualizziamo le metriche di tutti i lavori. Il grafico seguente visualizza l’accuratezza del test rispetto all’epoca.

La seguente schermata mostra i lavori di ottimizzazione degli iperparametri che abbiamo eseguito.

Ora puoi visualizzare i dati del miglior lavoro di addestramento (tra i quattro lavori di addestramento) in base all’accuratezza del test (rosso).

Come possiamo vedere negli screenshot seguenti, la perdita del test diminuisce e l’AUC e l’accuratezza aumentano con le epoche.

In base alle visualizzazioni, possiamo ora creare un endpoint per il miglior lavoro di addestramento:

%%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

Dopo aver creato l’endpoint, possiamo testare il predittore passandogli dei log di sensori di esempio:

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("Dati l'input di esempio, la probabilità prevista di guasto è {:0.2f}%".format(100*(1.0-out[0])))

Dati di input di esempio, la probabilità prevista di fallimento è 34,60% .

Pulizia

Quando hai finito con questa soluzione, assicurati di eliminare tutte le risorse AWS indesiderate. Nella pagina Maintenance predittiva per flotte di veicoli, sotto Elimina soluzione , scegli Elimina tutte le risorse per eliminare tutte le risorse associate alla soluzione.

È necessario eliminare manualmente eventuali risorse extra che potresti aver creato in questo notebook. Alcuni esempi includono i bucket S3 extra (per il bucket predefinito della soluzione) e i punti di fine extra di SageMaker (utilizzando un nome personalizzato).

Personalizza la soluzione

La nostra soluzione è semplice da personalizzare. Per modificare le visualizzazioni dei dati di input, fare riferimento a sagemaker/3_data_visualization.ipynb . Per personalizzare l’apprendimento automatico, fare riferimento a sagemaker/source/train.py e sagemaker/source/dl_utils/network.py . Per personalizzare l’elaborazione del dataset, fare riferimento a sagemaker/1_introduction.ipynb su come definire il file di configurazione.

Inoltre, è possibile modificare la configurazione nel file di configurazione. La configurazione predefinita è la seguente:

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

Il file di configurazione ha i seguenti parametri:

• fleet_info_fn , fleet_sensor_logs_fn , fleet_dataset_fn , train_dataset_fn , e test_dataset_fn definiscono la posizione dei file del dataset
• vehicle_id_column , timestamp_column , target_column , e period_column definiscono le intestazioni delle colonne
• dataset_size , chunksize , processing_chunksize , period_ms , e window_length definiscono le proprietà del dataset

Conclusioni

In questo post, ti abbiamo mostrato come addestrare e distribuire un modello per prevedere la probabilità di fallimento di una flotta di veicoli utilizzando SageMaker JumpStart. La soluzione si basa su modelli di apprendimento automatico e deep learning e consente una vasta gamma di dati di input, inclusi dati di sensori che variano nel tempo. Poiché ogni veicolo ha una telemetria diversa, è possibile ottimizzare il modello fornito in base alla frequenza e al tipo di dati disponibili.

Per saperne di più su cosa puoi fare con SageMaker JumpStart, fare riferimento ai seguenti link:

• Automazione dell’ispezione visiva utilizzando Amazon SageMaker JumpStart
• Esecuzione dell’ottimizzazione del modello automatica con Amazon SageMaker JumpStart
• Iniziare con l’IA generativa su AWS utilizzando Amazon SageMaker JumpStart

Risorse

• Guida dello sviluppatore di Amazon SageMaker
• Guida dello sviluppatore di SageMaker JumpStart
• Eseguire l’ottimizzazione automatica del modello con SageMaker
• Soluzione di manutenzione predittiva SageMaker JumpStart