Automatiseer een classificatiemodel voor gedeelde fietsen en scooters met Amazon SageMaker Autopilot

Amazon SageMaker-stuurautomaat maakt het voor organisaties mogelijk om snel een end-to-end machine learning (ML)-model en inferentiepijplijn te bouwen en te implementeren met slechts een paar regels code of zelfs zonder enige code helemaal mee Amazon SageMaker Studio. Autopilot ontlast het zware werk van het configureren van de infrastructuur en de tijd die nodig is om een ​​volledige pijplijn te bouwen, inclusief feature-engineering, modelselectie en afstemming van hyperparameters.

In dit bericht laten we zien hoe u met Autopilot van onbewerkte gegevens naar een robuuste en volledig geïmplementeerde gevolgtrekkingspijplijn kunt gaan.

Overzicht oplossingen

Wij gebruiken Lyft's openbare dataset over fietsen delen voor deze simulatie om te voorspellen of een gebruiker al dan niet deelneemt aan de Bike Share for All-programma. Dit is een eenvoudig binair classificatieprobleem.

We willen laten zien hoe gemakkelijk het is om een ​​geautomatiseerde en realtime gevolgtrekkingspijplijn te bouwen om gebruikers te classificeren op basis van hun deelname aan het Bike Share for All-programma. Daartoe simuleren we een end-to-end pijplijn voor gegevensopname en gevolgtrekking voor een denkbeeldig bikeshare-bedrijf dat actief is in de San Francisco Bay Area.

De architectuur is opgesplitst in twee delen: de opnamepijplijn en de gevolgtrekkingpijplijn.

We concentreren ons primair op de ML-pijplijn in het eerste deel van dit bericht en bespreken de pijplijn voor gegevensopname in het tweede deel.

Voorwaarden

Om dit voorbeeld te volgen, moet u aan de volgende vereisten voldoen:

1. Maak een nieuwe SageMaker-notebookinstantie.
2. Maak een Amazon Kinesis-gegevens Firehose leveringsstroom met een AWS Lambda transformatie functie. Voor instructies, zie Amazon Kinesis Firehose-gegevenstransformatie met AWS Lambda. Deze stap is optioneel en alleen nodig om gegevensstreaming te simuleren.

Gegevensverkenning

Laten we de dataset, die zich openbaar bevindt, downloaden en visualiseren Amazon eenvoudige opslagservice (Amazon S3) bucket en statische website:

# The dataset is located in a public bucket and static s3 website.
# https://www.lyft.com/bikes/bay-wheels/system-data import pandas as pd
import numpy as np
import os
from time import sleep !wget -q -O '201907-baywheels-tripdata.zip' https://s3.amazonaws.com/baywheels-data/201907-baywheels-tripdata.csv.zip
!unzip -q -o 201907-baywheels-tripdata.zip
csv_file = os.listdir('.')
data = pd.read_csv('201907-baywheels-tripdata.csv', low_memory=False)
data.head()

De volgende schermafbeelding toont een subset van de gegevens vóór de transformatie.

De laatste kolom met gegevens bevat het doel dat we willen voorspellen. Dit is een binaire variabele met een Ja- of Nee-waarde, die aangeeft of de gebruiker deelneemt aan het Bike Share for All-programma.

Laten we eens kijken naar de verdeling van onze doelvariabele voor eventuele onevenwichtigheden in de gegevens.

# For plotting
%matplotlib inline
import matplotlib.pyplot as plt
#!pip install seaborn # If you need this library
import seaborn as sns
display(sns.countplot(x='bike_share_for_all_trip', data=data))

Zoals blijkt uit de bovenstaande grafiek zijn de gegevens onevenwichtig: er nemen minder mensen deel aan het programma.

We moeten de gegevens in evenwicht brengen om een ​​vertekening van oververtegenwoordiging te voorkomen. Deze stap is optioneel omdat Autopilot ook een interne aanpak biedt om klassenonevenwichtigheid automatisch af te handelen, waarbij standaard een F1-scorevalidatiemetriek wordt gebruikt. Als u ervoor kiest de gegevens zelf in evenwicht te brengen, kunt u bovendien geavanceerdere technieken gebruiken voor het omgaan met klassenonevenwichtigheden, zoals VLOT or GAN.

Voor dit bericht downsamplen we de meerderheidsklasse (Nee) als een databalanceringstechniek:

De volgende code verrijkt de gegevens en onderbemonstert de oververtegenwoordigde klasse:

df = data.copy()
df.drop(columns=['rental_access_method'], inplace=True) df['start_time'] = pd.to_datetime(df['start_time'])
df['start_time'] = pd.to_datetime(df['end_time']) # Adding some day breakdown
df = df.assign(day_of_week=df.start_time.dt.dayofweek, hour_of_day=df.start_time.dt.hour, trip_month=df.start_time.dt.month)
# Breaking the day in 4 parts: ['morning', 'afternoon', 'evening']
conditions = [ (df['hour_of_day'] >= 5) & (df['hour_of_day'] < 12), (df['hour_of_day'] >= 12) & (df['hour_of_day'] < 18), (df['hour_of_day'] >= 18) & (df['hour_of_day'] < 21),
]
choices = ['morning', 'afternoon', 'evening']
df['part_of_day'] = np.select(conditions, choices, default='night')
df.dropna(inplace=True) # Downsampling the majority to rebalance the data
# We are getting about an even distribution
df.sort_values(by='bike_share_for_all_trip', inplace=True)
slice_pointe = int(df['bike_share_for_all_trip'].value_counts()['Yes'] * 2.1)
df = df[-slice_pointe:]
# The data is balanced now. Let's reshuffle the data
df = df.sample(frac=1).reset_index(drop=True)

We hebben onze categorische kenmerken bewust niet gecodeerd gelaten, inclusief onze binaire doelwaarde. Dit komt omdat Autopilot voor ons zorgt voor het coderen en decoderen van de gegevens als onderdeel van de automatische functie-engineering en pijplijnimplementatie, zoals we in de volgende sectie zien.

De volgende schermafbeelding toont een voorbeeld van onze gegevens.

De gegevens in de volgende grafieken zien er verder normaal uit, met een bimodale verdeling die de twee pieken voor de ochtenduren en de middagspits weergeeft, zoals je zou verwachten. Ook in het weekend en 's nachts zien we weinig activiteiten.

In het volgende gedeelte voeren we de gegevens in Autopilot in, zodat deze een experiment voor ons kan uitvoeren.

Bouw een binair classificatiemodel

Autopilot vereist dat we de invoer- en uitvoerbestemmingsbuckets specificeren. Het gebruikt de invoerbucket om de gegevens te laden en de uitvoerbucket om de artefacten op te slaan, zoals feature-engineering en de gegenereerde Jupyter-notebooks. We behouden 5% van de dataset om de prestaties van het model te evalueren en valideren nadat de training is voltooid en uploaden 95% van de dataset naar de S3-invoerbucket. Zie de volgende code:

import sagemaker
import boto3 # Let's define our storage.
# We will use the default sagemaker bucket and will enforce encryption bucket = sagemaker.Session().default_bucket() # SageMaker default bucket. #Encrypting the bucket
s3 = boto3.client('s3')
SSEConfig={ 'Rules': [ { 'ApplyServerSideEncryptionByDefault': { 'SSEAlgorithm': 'AES256', } }, ] }
s3.put_bucket_encryption(Bucket=bucket, ServerSideEncryptionConfiguration=SSEConfig) prefix = 'sagemaker-automl01' # prefix for ther bucket
role = sagemaker.get_execution_role() # IAM role object to use by SageMaker
sagemaker_session = sagemaker.Session() # Sagemaker API
region = sagemaker_session.boto_region_name # AWS Region # Where we will load our data input_path = "s3://{}/{}/automl_bike_train_share-1".format(bucket, prefix) output_path = "s3://{}/{}/automl_bike_output_share-1".format(bucket, prefix) # Spliting data in train/test set.
# We will use 95% of the data for training and the remainder for testing.
slice_point = int(df.shape[0] * 0.95) training_set = df[:slice_point] # 95%
testing_set = df[slice_point:] # 5% # Just making sure we have split it correctly
assert training_set.shape[0] + testing_set.shape[0] == df.shape[0] # Let's save the data locally and upload it to our s3 data location
training_set.to_csv('bike_train.csv')
testing_set.to_csv('bike_test.csv', header=False) # Uploading file the trasining set to the input bucket
sagemaker.s3.S3Uploader.upload(local_path='bike_train.csv', desired_s3_uri=input_path)

Nadat we de gegevens naar de invoerbestemming hebben geüpload, is het tijd om Autopilot te starten:

from sagemaker.automl.automl import AutoML
# You give your job a name and provide the s3 path where you uploaded the data
bike_automl_binary = AutoML(role=role, target_attribute_name='bike_share_for_all_trip', output_path=output_path, max_candidates=30)
# Starting the training bike_automl_binary.fit(inputs=input_path, wait=False, logs=False)

Het enige dat we nodig hebben om te beginnen met experimenteren is het aanroepen van de fit() -methode. Autopilot heeft de invoer- en uitvoerlocatie S3 en de doelattribuutkolom nodig als vereiste parameters. Na verwerking van de functies belt Autopilot Automatische afstemming van SageMaker-modellen om de beste versie van een model te vinden door veel trainingstaken op uw dataset uit te voeren. We hebben de optionele parameter max_candidates toegevoegd om het aantal kandidaten te beperken tot 30. Dit is het aantal trainingstaken dat Autopilot lanceert met verschillende combinaties van algoritmen en hyperparameters om het beste model te vinden. Als u deze parameter niet opgeeft, wordt deze standaard ingesteld op 250.

We kunnen de voortgang van Autopilot observeren met de volgende code:

# Let's monitor the progress this will take a while. Go grup some coffe.
from time import sleep def check_job_status(): return bike_automl_binary.describe_auto_ml_job()['AutoMLJobStatus'] def discribe(): return bike_automl_binary.describe_auto_ml_job() while True: print (check_job_status(), discribe()['AutoMLJobSecondaryStatus'], end='** ') if check_job_status() in ["Completed", "Failed"]: if "Failed" in check_job_status(): print(discribe()['FailureReason']) break sleep(20)

Het duurt enige tijd om de training te voltooien. Laten we, terwijl deze actief is, eens kijken naar de Autopilot-workflow.

Gebruik de volgende code om de beste kandidaat te vinden:

# Let's take a look at the best candidate selected by AutoPilot
from IPython.display import JSON
def jsonView(obj, rootName=None): return JSON(obj, root=rootName, expanded=True) bestCandidate = bike_automl_binary.describe_auto_ml_job()['BestCandidate']
display(jsonView(bestCandidate['FinalAutoMLJobObjectiveMetric'], 'FinalAutoMLJobObjectiveMetric'))

De volgende schermafbeelding toont onze output.

Ons model behaalde een validatienauwkeurigheid van 96%, dus we gaan het inzetten. We zouden een voorwaarde kunnen toevoegen, zodat we het model alleen gebruiken als de nauwkeurigheid boven een bepaald niveau ligt.

Inferentie pijplijn

Laten we, voordat we ons model inzetten, eens kijken naar onze beste kandidaat en wat er in onze pijplijn gebeurt. Zie de volgende code:

display(jsonView(bestCandidate['InferenceContainers'], 'InferenceContainers'))

Het volgende diagram toont onze output.

Autopilot heeft het model gebouwd en verpakt in drie verschillende containers, die elk opeenvolgend een specifieke taak uitvoeren: transformeren, voorspellen en omgekeerd transformeren. Deze meerstaps gevolgtrekking is mogelijk met a SageMaker-inferentiepijplijn.

Een meerstapsinferentie kan ook meerdere inferentiemodellen aan elkaar koppelen. Eén container kan bijvoorbeeld presteren analyse van hoofdcomponenten voordat u de gegevens doorgeeft aan de XGBoost-container.

Implementeer de deductiepijplijn op een eindpunt

Het implementatieproces omvat slechts een paar regels code:

# We chose to difine an endpoint name.
from datetime import datetime as dt
today = str(dt.today())[:10]
endpoint_name='binary-bike-share-' + today
endpoint = bike_automl_binary.deploy(initial_instance_count=1, instance_type='ml.m5.xlarge', endpoint_name=endpoint_name, candidate=bestCandidate, wait=True)

Laten we ons eindpunt configureren voor voorspelling met een voorspeller:

from sagemaker.serializers import CSVSerializer
from sagemaker.deserializers import CSVDeserializer
csv_serializer = CSVSerializer()
csv_deserializer = CSVDeserializer()
# Initialize the predictor
predictor = sagemaker.predictor.Predictor(endpoint_name=endpoint_name, sagemaker_session=sagemaker.Session(), serializer=csv_serializer, deserializer=csv_deserializer )

Nu we ons eindpunt en onze voorspeller gereed hebben, is het tijd om de testgegevens die we opzij hebben gezet te gebruiken en de nauwkeurigheid van ons model te testen. We beginnen met het definiëren van een nutsfunctie die de gegevens regel voor regel naar ons inferentie-eindpunt verzendt en in ruil daarvoor een voorspelling krijgt. Omdat wij een XGBoost model laten we de doelvariabele vallen voordat we de CSV-regel naar het eindpunt verzenden. Bovendien hebben we de header uit het test-CSV verwijderd voordat we het bestand doorliepen, wat ook een andere vereiste is voor XGBoost op SageMaker. Zie de volgende code:

# The fuction takes 3 arguments: the file containing the test set,
# The predictor and finaly the number of lines to send for prediction.
# The function returns two Series: inferred and Actual.
def get_inference(file, predictor, n=1): infered = [] actual = [] with open(file, 'r') as csv: for i in range(n): line = csv.readline().split(',') #print(line) try: # Here we remove the target variable from the csv line before predicting observed = line.pop(14).strip('n') actual.append(observed) except: pass obj = ','.join(line) predicted = predictor.predict(obj)[0][0] infered.append(predicted) pd.Series(infered) data = {'Infered': pd.Series(infered), 'Observed': pd.Series(actual)} return pd.DataFrame(data=data) n = testing_set.shape[0] # The size of the testing data
inference_df = get_inference('bike_test.csv', predictor, n) inference_df['Binary_Result'] = (inference_df['Observed'] == inference_df['Infered'])
display(inference_df.head())

De volgende schermafbeelding toont onze output.

Laten we nu de nauwkeurigheid van ons model berekenen.

Zie de volgende code:

count_binary = inference_df['Binary_Result'].value_counts()
accuracy = count_binary[True]/n
print('Accuracy:', accuracy)

We halen een nauwkeurigheid van 92%. Dit is iets lager dan de 96% die tijdens de validatiestap werd verkregen, maar nog steeds hoog genoeg. We verwachten niet dat de nauwkeurigheid precies hetzelfde zal zijn, omdat de test wordt uitgevoerd met een nieuwe dataset.

Gegevensopname

We hebben de gegevens rechtstreeks gedownload en geconfigureerd voor training. In het echte leven moet u de gegevens mogelijk rechtstreeks vanaf het edge-apparaat naar het datameer sturen en SageMaker deze rechtstreeks vanuit het datameer naar de notebook laten laden.

Kinesis Data Firehose is een goede optie en de meest eenvoudige manier om op betrouwbare wijze streaminggegevens in datameren, datastores en analysetools te laden. Het kan streaminggegevens vastleggen, transformeren en laden in Amazon S3 en andere AWS-gegevensopslag.

Voor ons gebruiksscenario creëren we een Kinesis Data Firehose-leveringsstroom met een Lambda-transformatiefunctie om wat lichtgewicht gegevensopschoning uit te voeren terwijl deze de stroom doorkruist. Zie de volgende code:

# Data processing libraries
import pandas as pd # Data processing
import numpy as np
import base64
from io import StringIO def lambda_handler(event, context): output = [] print('Received', len(event['records']), 'Records') for record in event['records']: payload = base64.b64decode(record['data']).decode('utf-8') df = pd.read_csv(StringIO(payload), index_col=0) df.drop(columns=['rental_access_method'], inplace=True) df['start_time'] = pd.to_datetime(df['start_time']) df['start_time'] = pd.to_datetime(df['end_time']) # Adding some day breakdown df = df.assign(day_of_week=df.start_time.dt.dayofweek, hour_of_day=df.start_time.dt.hour, trip_month=df.start_time.dt.month) # Breaking the day in 4 parts: ['morning', 'afternoon', 'evening'] conditions = [ (df['hour_of_day'] >= 5) & (df['hour_of_day'] < 12), (df['hour_of_day'] >= 12) & (df['hour_of_day'] < 18), (df['hour_of_day'] >= 18) & (df['hour_of_day'] < 21), ] choices = ['morning', 'afternoon', 'evening'] df['part_of_day'] = np.select(conditions, choices, default='night') df.dropna(inplace=True) # Downsampling the majority to rebalance the data # We are getting about an even distribution df.sort_values(by='bike_share_for_all_trip', inplace=True) slice_pointe = int(df['bike_share_for_all_trip'].value_counts()['Yes'] * 2.1) df = df[-slice_pointe:] # The data is balanced now. Let's reshuffle the data df = df.sample(frac=1).reset_index(drop=True) data = base64.b64encode(bytes(df.to_csv(), 'utf-8')).decode("utf-8") output_record = { 'recordId': record['recordId'], 'result': 'Ok', 'data': data } output.append(output_record) print('Returned', len(output), 'Records') print('Event', event) return {'records': output}

Deze Lambda-functie voert een lichte transformatie uit van de gegevens die van de apparaten naar het datameer worden gestreamd. Er wordt een gegevensbestand in CSV-indeling verwacht.

Voor de opnamestap downloaden we de gegevens en simuleren we een datastroom naar Kinesis Data Firehose met een Lambda-transformatiefunctie en naar ons S3-datameer.

Laten we het streamen van een paar regels simuleren:

# Saving the data in one file.
file = '201907-baywheels-tripdata.csv' data.to_csv(file) # Stream the data 'n' lines at a time.
# Only run this for a minute and stop the cell
def streamer(file, n): with open(file, 'r') as csvfile: header = next(csvfile) data = header counter = 0 loop = True while loop == True: for i in range(n): line = csvfile.readline() data+=line # We reached the end of the csv file. if line == '': loop = False counter+=n # Use your kinesis streaming name stream = client.put_record(DeliveryStreamName='firehose12-DeliveryStream-OJYW71BPYHF2', Record={"Data": bytes(data, 'utf-8')}) data = header print( file, 'HTTPStatusCode: '+ str(stream['ResponseMetadata']['HTTPStatusCode']), 'csv_lines_sent: ' + str(counter), end=' -*- ') sleep(random.randrange(1, 3)) return
# Streaming for 500 lines at a time. You can change this number up and down.
streamer(file, 500) # We can now load our data as a DataFrame because it’s streamed into the S3 data lake:
# Getting data from s3 location where it was streamed.
STREAMED_DATA = 's3://firehose12-deliverybucket-11z0ya3patrod/firehose/2020'
csv_uri = sagemaker.s3.S3Downloader.list(STREAMED_DATA)
in_memory_string = [sagemaker.s3.S3Downloader.read_file(file) for file in csv_uri]
in_memory_csv = [pd.read_csv(StringIO(file), index_col=0) for file in in_memory_string]
display(df.tail())

Opruimen

Het is belangrijk om alle bronnen die in deze oefening worden gebruikt te verwijderen om de kosten te minimaliseren. De volgende code verwijdert het SageMaker-inferentie-eindpunt dat we hebben gemaakt, evenals de trainings- en testgegevens die we hebben geüpload:

#Delete the s3 data
predictor.delete_endpoint() # Delete s3 data
s3 = boto3.resource('s3')
ml_bucket = sagemaker.Session().default_bucket()
delete_data = s3.Bucket(ml_bucket).objects.filter(Prefix=prefix).delete()

Conclusie

ML-ingenieurs, datawetenschappers en softwareontwikkelaars kunnen Autopilot gebruiken om een ​​inferentiepijplijn te bouwen en te implementeren met weinig tot geen ML-programmeerervaring. Autopilot bespaart tijd en middelen door gebruik te maken van best practices op het gebied van datawetenschap en ML. Grote organisaties kunnen nu hun technische middelen verschuiven van infrastructuurconfiguratie naar het verbeteren van modellen en het oplossen van zakelijke gebruiksscenario's. Startups en kleinere organisaties kunnen met weinig tot geen ML-expertise aan de slag met machine learning.

Om aan de slag te gaan met SageMaker Autopilot, zie de product pagina of open SageMaker Autopilot binnen SageMaker Studio.

We raden u ook aan meer te leren over andere belangrijke functies die SageMaker te bieden heeft, zoals de Amazon SageMaker Feature Store, die integreert met Amazon SageMaker-pijpleidingen om geautomatiseerde ML-workflows te maken, functies te zoeken en te ontdekken en deze opnieuw te gebruiken. U kunt meerdere Autopilot-simulaties uitvoeren met verschillende functie- of doelvarianten in uw dataset. U kunt dit ook benaderen als een dynamisch voertuigallocatieprobleem, waarbij uw model de voertuigvraag probeert te voorspellen op basis van tijd (zoals tijdstip of dag van de week) of locatie, of een combinatie van beide.

Over de auteurs

Doug Mbaya is een Senior Solution architect met een focus op data en analytics. Doug werkt nauw samen met AWS-partners en helpt hen data- en analyseoplossingen in de cloud te integreren. Dougs eerdere ervaring omvat onder meer het ondersteunen van AWS-klanten in het segment van het delen van ritten en het bezorgen van eten.

Valerio Perrone is een Applied Science Manager die werkt aan Amazon SageMaker Automatic Model Tuning en Autopilot.

• Coinsmart. Europa's beste Bitcoin- en crypto-uitwisseling.
• Platoblockchain. Web3 Metaverse Intelligentie. Kennis versterkt. GRATIS TOEGANG.
• CryptoHawk. Altcoin-radar. Gratis proefversie.
• Bron: https://aws.amazon.com/blogs/machine-learning/automate-a-shared-bikes-and-scooters-classification-model-with-amazon-sagemaker-autopilot/