Wdrażaj modele Amazon SageMaker Autopilot w bezserwerowych punktach końcowych wnioskowania

Autopilot Amazon SageMaker automatycznie buduje, trenuje i dostraja najlepsze modele uczenia maszynowego (ML) w oparciu o Twoje dane, jednocześnie pozwalając zachować pełną kontrolę i widoczność. Autopilot może również automatycznie wdrażać przeszkolone modele w punktach końcowych wnioskowania w czasie rzeczywistym.

Jeśli masz obciążenia ze skokowymi lub nieprzewidywalnymi wzorcami ruchu, które mogą tolerować zimne uruchamianie, wdrożenie modelu w bezserwerowym punkcie końcowym wnioskowania byłoby bardziej opłacalne.

Wnioskowanie bezserwerowe Amazon SageMaker to specjalnie zaprojektowana opcja wnioskowania, idealna dla obciążeń z nieprzewidywalnymi wzorcami ruchu i która toleruje zimne uruchamianie. W przeciwieństwie do punktu końcowego wnioskowania w czasie rzeczywistym, który jest wspierany przez długo działającą instancję obliczeniową, bezserwerowe punkty końcowe udostępniają zasoby na żądanie z wbudowanym automatycznym skalowaniem. Bezserwerowe punkty końcowe skalują się automatycznie na podstawie liczby przychodzących żądań i zmniejszają zasoby do zera, gdy nie ma żadnych przychodzących żądań, co pomaga zminimalizować koszty.

W tym poście pokazujemy, jak wdrażać modele przeszkolone przez rozwiązanie Autopilot w bezserwerowych punktach końcowych wnioskowania przy użyciu Biblioteki Boto3 dla Amazon Sage Maker.

Tryby szkolenia autopilota

Przed utworzeniem eksperymentu z autopilotem możesz zezwolić autopilotowi na automatyczne wybieranie trybu szkoleniowego lub możesz wybrać tryb szkoleniowy ręcznie.

Autopilot obsługuje obecnie trzy tryby szkolenia:

• Samochody – W oparciu o rozmiar zbioru danych, Autopilot automatycznie wybiera tryb ensembling lub HPO. W przypadku zestawów danych większych niż 100 MB Autopilot wybiera HPO; w przeciwnym razie wybiera zespół.
• Kompletowanie – Autopilot wykorzystuje AutoGluon technikę ensemblingu wykorzystującą układanie modeli i tworzy optymalny model predykcyjny.
• Optymalizacja hiperparametryczna (HPO) – Autopilot znajduje najlepszą wersję modelu, dostrajając hiperparametry za pomocą optymalizacji bayesowskiej lub optymalizacji multi-fidelity podczas uruchamiania zadań szkoleniowych na zbiorze danych. Tryb HPO wybiera algorytmy najbardziej odpowiednie dla Twojego zestawu danych i wybiera najlepszy zakres hiperparametrów do dostrojenia modeli.

Aby dowiedzieć się więcej o trybach szkolenia autopilota, patrz Tryby treningowe.

Omówienie rozwiązania

W tym poście używamy Marketing Banku UCI zestaw danych do przewidywania, czy klient zdecyduje się na lokatę terminową oferowaną przez bank. Jest to typ problemu z klasyfikacją binarną.

Uruchamiamy dwa zadania Autopilota za pomocą Biblioteki Boto3 dla SageMaker. Pierwsza praca wykorzystuje ensebling jako wybrany tryb szkolenia. Następnie wdrażamy wygenerowany pojedynczy model zespołu w bezserwerowym punkcie końcowym i wysyłamy żądania wnioskowania do tego hostowanego punktu końcowego.

Drugie zadanie wykorzystuje tryb szkolenia HPO. W przypadku typów problemów z klasyfikacją Autopilot generuje trzy kontenery wnioskowania. Wyodrębniamy te trzy kontenery wnioskowania i wdrażamy je w oddzielnych bezserwerowych punktach końcowych. Następnie wysyłamy żądania wnioskowania do tych hostowanych punktów końcowych.

Aby uzyskać więcej informacji na temat typów problemów z regresją i klasyfikacją, zobacz Definicje kontenerów wnioskowania dla typów problemów regresji i klasyfikacji.

Możemy również uruchamiać zadania Autopilota z poziomu Studio Amazon SageMaker interfejs użytkownika Jeśli uruchamiasz zadania z interfejsu użytkownika, pamiętaj o wyłączeniu Automatyczne wdrażanie opcja w Ustawienia wdrażania i zaawansowane Sekcja. W przeciwnym razie Autopilot wdroży najlepszego kandydata do punktu końcowego w czasie rzeczywistym.

Wymagania wstępne

Upewnij się, że masz zainstalowaną najnowszą wersję pakietów Boto3 i SageMaker Python:

pip install -U boto3 sagemaker

Potrzebujemy wersji pakietu SageMaker >= 2.110.0 i wersja Boto3 >= boto3-1.24.84.

Uruchom zadanie Autopilota w trybie składania

Aby uruchomić zadanie Autopilota przy użyciu bibliotek SageMaker Boto3, używamy utwórz_auto_ml_zadanie API. Następnie przechodzimy AutoMLJobConfig, InputDataConfig, AutoMLJobObjective jako wejścia do create_auto_ml_job. Zobacz następujący kod:

bucket = session.default_bucket()
role = sagemaker.get_execution_role()
prefix = "autopilot/bankadditional"
sm_client = boto3.Session().client(service_name='sagemaker',region_name=region)

timestamp_suffix = strftime('%d%b%Y-%H%M%S', gmtime())
automl_job_name = f"uci-bank-marketing-{timestamp_suffix}"
max_job_runtime_seconds = 3600
max_runtime_per_job_seconds = 1200
target_column = "y"
problem_type="BinaryClassification"
objective_metric = "F1"
training_mode = "ENSEMBLING"

automl_job_config = {
    'CompletionCriteria': {
      'MaxRuntimePerTrainingJobInSeconds': max_runtime_per_job_seconds,
      'MaxAutoMLJobRuntimeInSeconds': max_job_runtime_seconds
    },    
    "Mode" : training_mode
}

automl_job_objective= { "MetricName": objective_metric }

input_data_config = [
    {
      'DataSource': {
        'S3DataSource': {
          'S3DataType': 'S3Prefix',
          'S3Uri': f's3://{bucket}/{prefix}/raw/bank-additional-full.csv'
        }
      },
      'TargetAttributeName': target_column
    }
  ]

output_data_config = {
	    'S3OutputPath': f's3://{bucket}/{prefix}/output'
	}


sm_client.create_auto_ml_job(
				AutoMLJobName=auto_ml_job_name,
				InputDataConfig=input_data_config,
				OutputDataConfig=output_data_config,
				AutoMLJobConfig=automl_job_config,
				ProblemType=problem_type,
				AutoMLJobObjective=automl_job_objective,
				RoleArn=role)

Autopilot zwraca BestCandidate obiekt modelu, który ma InferenceContainers wymagane do wdrożenia modeli w punktach końcowych wnioskowania. Aby uzyskać BestCandidate dla poprzedniego zadania używamy describe_automl_job funkcjonować:

job_response = sm_client.describe_auto_ml_job(AutoMLJobName=automl_job_name)
best_candidate = job_response['BestCandidate']
inference_container = job_response['BestCandidate']['InferenceContainers'][0]
print(inference_container)

Wdróż przeszkolony model

Teraz wdrażamy poprzedni kontener wnioskowania w bezserwerowym punkcie końcowym. Pierwszym krokiem jest utworzenie modelu z kontenera wnioskowania, a następnie utworzenie konfiguracji punktu końcowego, w której określamy MemorySizeInMB i MaxConcurrency wartości dla bezserwerowego punktu końcowego wraz z nazwą modelu. Na koniec tworzymy punkt końcowy z konfiguracją punktu końcowego utworzoną powyżej.

Polecamy wybrać swój rozmiar pamięci punktu końcowego w zależności od rozmiaru modelu. Rozmiar pamięci powinien być co najmniej tak duży, jak rozmiar twojego modelu. Bezserwerowy punkt końcowy ma minimalny rozmiar pamięci RAM wynoszący 1024 MB (1 GB), a maksymalny rozmiar pamięci RAM, jaki można wybrać, to 6144 MB (6 GB).

Dostępne rozmiary pamięci to 1024 MB, 2048 MB, 3072 MB, 4096 MB, 5120 MB lub 6144 MB.

Aby pomóc określić, czy bezserwerowy punkt końcowy jest właściwą opcją wdrożenia z punktu widzenia kosztów i wydajności, zachęcamy do zapoznania się z SageMaker Bezserwerowy zestaw narzędzi do analizy porównawczej wnioskowania, który testuje różne konfiguracje punktów końcowych i porównuje najbardziej optymalną z porównywalnym wystąpieniem hostingu w czasie rzeczywistym.

Pamiętaj, że bezserwerowe punkty końcowe akceptują tylko SingleModel dla kontenerów wnioskowania. Autopilot w trybie ensembling generuje pojedynczy model, dzięki czemu możemy wdrożyć ten kontener modelu w punkcie końcowym. Zobacz następujący kod:

# Create Model
	model_response = sm_client.create_model(
				ModelName=model_name,
				ExecutionRoleArn=role,
				Containers=[inference_container]
	)

# Create Endpoint Config
	epc_response = sm_client.create_endpoint_config(
		EndpointConfigName = endpoint_config_name,
		ProductionVariants=[
			{
				"ModelName": model_name,
				"VariantName": "AllTraffic",
				"ServerlessConfig": {
					"MemorySizeInMB": memory,
					"MaxConcurrency": max_concurrency
				}
			}
		]
	)

# Create Endpoint
	ep_response = sm_client.create_endpoint(
		EndpointName=endpoint_name,
		EndpointConfigName=endpoint_config_name
	)

Gdy punkt końcowy wnioskowania bezserwerowego to InService, możemy przetestować punkt końcowy, wysyłając żądanie wnioskowania i obserwować prognozy. Poniższy diagram ilustruje architekturę tej konfiguracji.

Pamiętaj, że możemy wysłać surowe dane jako ładunek do punktu końcowego. Model zespołowy generowany przez Autopilota automatycznie łączy wszystkie wymagane etapy transformacji cech i odwrotnej transformacji etykiet, wraz z modelem algorytmu i pakietami, w jeden model.

Wyślij żądanie wnioskowania do przeszkolonego modelu

Użyj następującego kodu, aby wysłać wnioskowanie na temat modelu wytrenowanego przy użyciu trybu składania:

from sagemaker.predictor import Predictor
from sagemaker.serializers import CSVSerializer


payload = "34,blue-collar,married,basic.4y,no,no,no,telephone,may,tue,800,4,999,0,nonexistent,1.1,93.994,-36.4,4.857,5191.0"

predictor = Predictor(
        endpoint_name=endpoint,
        sagmaker_session=session,
        serializer=CSVSerializer(),
    )

prediction = predictor.predict(payload).decode(‘utf-8’)
print(prediction)

Uruchom zadanie autopilota w trybie HPO

W trybie HPO, dla CompletionCriteriapoza tym MaxRuntimePerTrainingJobInSeconds i MaxAutoMLJobRuntimeInSeconds, moglibyśmy również określić MaxCandidates aby ograniczyć liczbę kandydatów, których wygeneruje praca Autopilota. Należy pamiętać, że są to parametry opcjonalne i są ustawione tylko w celu ograniczenia czasu wykonywania zadania w celu demonstracji. Zobacz następujący kod:

training_mode = "HYPERPARAMETER_TUNING"

automl_job_config["Mode"] = training_mode
automl_job_config["CompletionCriteria"]["MaxCandidates"] = 15
hpo_automl_job_name =  f"{model_prefix}-HPO-{timestamp_suffix}"

response = sm_client.create_auto_ml_job(
					  AutoMLJobName=hpo_automl_job_name,
					  InputDataConfig=input_data_config,
					  OutputDataConfig=output_data_config,
					  AutoMLJobConfig=automl_job_config,
					  ProblemType=problem_type,
					  AutoMLJobObjective=automl_job_objective,
					  RoleArn=role,
					  Tags=tags_config
				)

Aby uzyskać BestCandidate dla poprzedniego zadania możemy ponownie użyć funkcji describe_automl_job funkcjonować:

job_response = sm_client.describe_auto_ml_job(AutoMLJobName=automl_job_name)
best_candidate = job_response['BestCandidate']
inference_containers = job_response['BestCandidate']['InferenceContainers']
print(inference_containers)

Wdróż przeszkolony model

Autopilot w trybie HPO dla typu problemu klasyfikacyjnego generuje trzy kontenery wnioskowania.

Pierwszy kontener obsługuje kroki przekształcania funkcji. Następnie kontener algorytmu generuje plik predicted_label z największym prawdopodobieństwem. Na koniec kontener wnioskowania po przetwarzaniu wykonuje odwrotną transformację na przewidywanej etykiecie i odwzorowuje ją na oryginalną etykietę. Aby uzyskać więcej informacji, patrz Definicje kontenerów wnioskowania dla typów problemów regresji i klasyfikacji.

Wyodrębniamy te trzy kontenery wnioskowania i wdrażamy je w oddzielnych bezserwerowych punktach końcowych. W celu wnioskowania wywołujemy kolejno punkty końcowe, wysyłając najpierw ładunek do kontenera transformacji funkcji, następnie przekazując dane wyjściowe z tego kontenera do kontenera algorytmu, a na końcu przekazując dane wyjściowe z poprzedniego kontenera wnioskowania do kontenera przetwarzania końcowego, który wyświetla przewidywaną etykietę.

Poniższy diagram ilustruje architekturę tej konfiguracji.

Wyodrębniamy trzy kontenery wnioskowania z pliku BestCandidate z następującym kodem:

job_response = sm_client.describe_auto_ml_job(AutoMLJobName=automl_job_name)
inference_containers = job_response['BestCandidate']['InferenceContainers']

models = list()
endpoint_configs = list()
endpoints = list()

# For brevity, we've encapsulated create_model, create endpoint_config and create_endpoint as helper functions
for idx, container in enumerate(inference_containers):
    (status, model_arn) = create_autopilot_model(
								    sm_client,
								    automl_job_name,
            						role,
								    container,
								    idx)
    model_name = model_arn.split('/')[1]
    models.append(model_name)

    endpoint_config_name = f"epc-{model_name}"
    endpoint_name = f"ep-{model_name}"
    (status, epc_arn) = create_serverless_endpoint_config(
								    sm_client,
								    endpoint_config_name,
								    model_name,
            						memory=2048,
								    max_concurrency=10)
	endpoint_configs.append(endpoint_config_name)

	response = create_serverless_endpoint(
								    sm_client,
								    endpoint_name,
								    endpoint_config_name)
	endpoints.append(endpoint_name)

Wyślij żądanie wnioskowania do przeszkolonego modelu

Aby wnioskować, wysyłamy ładunek w sekwencji: najpierw do kontenera transformacji funkcji, następnie do kontenera modelu, a na końcu do kontenera transformacji etykiety odwrotnej.

Zobacz następujący kod:

from sagemaker.predictor import Predictor
from sagemaker.serializers import CSVSerializer

payload = "51,technician,married,professional.course,no,yes,no,cellular,apr,thu,687,1,0,1,success,-1.8,93.075,-47.1,1.365,5099.1"


for _, endpoint in enumerate(endpoints):
    try:
        print(f"payload: {payload}")
        predictor = Predictor(
            endpoint_name=endpoint,
            sagemaker_session=session,
            serializer=CSVSerializer(),
        )
        prediction = predictor.predict(payload)
        payload=prediction
    except Exception as e:
        print(f"Error invoking Endpoint; {endpoint} n {e}")
        break

Pełna implementacja tego przykładu jest dostępna w następującym pliku jupyter notatnik.

Sprzątać

Aby wyczyścić zasoby, możesz usunąć utworzone bezserwerowe punkty końcowe, konfiguracje punktów końcowych i modele:

sm_client = boto3.Session().client(service_name='sagemaker',region_name=region)

for _, endpoint in enumerate(endpoints):
    try:
        sm_client.delete_endpoint(EndpointName=endpoint)
    except Exception as e:
        print(f"Exception:n{e}")
        continue
        
for _, endpoint_config in enumerate(endpoint_configs):
    try:
        sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config)
    except Exception as e:
        print(f"Exception:n{e}")
        continue

for _, autopilot_model in enumerate(models):
    try:
        sm_client.delete_model(ModelName=autopilot_model)
    except Exception as e:
        print(f"Exception:n{e}")
        continue

Wnioski

W tym poście pokazaliśmy, w jaki sposób możemy wdrażać modele generowane przez Autopilota zarówno w trybie zespołowym, jak i HPO w bezserwerowych punktach końcowych wnioskowania. To rozwiązanie może przyspieszyć korzystanie z ekonomicznych i w pełni zarządzanych usług uczenia maszynowego, takich jak Autopilot, w celu szybkiego generowania modeli z nieprzetworzonych danych, a następnie wdrażania ich we w pełni zarządzanych bezserwerowych punktach końcowych wnioskowania z wbudowanym automatycznym skalowaniem w celu obniżenia kosztów .

Zachęcamy do wypróbowania tego rozwiązania z zestawem danych odpowiadającym KPI Twojej firmy. Możesz odwołać się do rozwiązania zaimplementowanego w notatniku Jupyter w GitHub repo.

Dodatkowe referencje

O autorze

Praveen Chamarthi jest starszym specjalistą AI/ML w Amazon Web Services. Jest pasjonatem AI/ML i wszystkich rzeczy związanych z AWS. Pomaga klientom w obu Amerykach skalować, wprowadzać innowacje i wydajnie obsługiwać obciążenia ML w AWS. W wolnym czasie Praveen uwielbia czytać i oglądać filmy science-fiction.