Telepítse az Amazon SageMaker Autopilot modelleket kiszolgáló nélküli következtetési végpontokhoz

Amazon SageMaker Autopilot automatikusan összeállítja, betanítja és hangolja a legjobb gépi tanulási (ML) modelleket az Ön adatai alapján, miközben lehetővé teszi a teljes irányítás és láthatóság fenntartását. Az Autopilot a betanított modelleket is automatikusan telepítheti a valós idejű következtetési végpontokhoz.

Ha olyan munkaterhelései vannak, amelyek tüskés vagy kiszámíthatatlan forgalmi mintázattal rendelkeznek, és elviselik a hidegindítást, akkor költséghatékonyabb lenne a modell telepítése egy kiszolgáló nélküli következtetési végpontra.

Amazon SageMaker szerver nélküli következtetés egy erre a célra kialakított következtetési lehetőség, amely ideális a kiszámíthatatlan forgalmi mintákkal járó munkaterhelésekhez, és képes elviselni a hidegindítást. A valós idejű következtetési végponttal ellentétben, amelyet egy régóta futó számítási példány támogat, a kiszolgáló nélküli végpontok igény szerint biztosítják az erőforrásokat a beépített automatikus méretezéssel. A kiszolgáló nélküli végpontok automatikusan skálázódnak a bejövő kérések száma alapján, és nullára csökkentik az erőforrásokat, ha nincsenek bejövő kérések, így minimalizálhatja költségeit.

Ebben a bejegyzésben bemutatjuk, hogyan lehet az Autopilot által betanított modelleket telepíteni kiszolgáló nélküli következtetési végpontokra a Boto3 könyvtárak mert Amazon SageMaker.

Autopilóta edzési módok

Az Autopilot kísérlet létrehozása előtt hagyhatja, hogy az Autopilot automatikusan válassza ki az edzési módot, vagy kiválaszthatja manuálisan is.

Az Autopilot jelenleg három edzési módot támogat:

• kocsi – Az adatkészlet mérete alapján az Autopilot automatikusan kiválasztja az összeállítási vagy a HPO módot. 100 MB-nál nagyobb adatkészletek esetén az Autopilot a HPO-t választja; egyébként az összeállítást választja.
• Összeállítás – Az Autopilot a AutoGluon összeállítási technikát modellhalmozás segítségével, és optimális prediktív modellt állít elő.
• Hiperparaméter optimalizálás (HPO) – Az Autopilot megtalálja a modell legjobb verzióját a hiperparaméterek Bayes-optimalizálással vagy többhűségű optimalizálással történő hangolásával, miközben oktatási feladatokat futtat az adatkészleten. A HPO mód kiválasztja az adatkészlet szempontjából legrelevánsabb algoritmusokat, és kiválasztja a hiperparaméterek legjobb tartományát a modellek hangolásához.

Ha többet szeretne megtudni az Autopilot edzési módokról, lásd: Képzési módok.

Megoldás áttekintése

Ebben a bejegyzésben a UCI Bank Marketing adatkészlet annak előrejelzésére, hogy az ügyfél előfizet-e a bank által kínált lekötött betétre. Ez egy bináris osztályozási problématípus.

Két Autopilot feladatot indítunk el a Boto3 könyvtárak a SageMaker számára. Az első munka az összeállítást használja választott képzési módként. Ezután telepítjük a generált egyegyüttes modellt egy kiszolgáló nélküli végpontra, és következtetési kéréseket küldünk erre a hosztolt végpontra.

A második munka a HPO képzési módot használja. Az osztályozási problématípusokhoz az Autopilot három következtetési tárolót generál. Kibontjuk ezt a három következtetési tárolót, és külön kiszolgáló nélküli végpontokhoz telepítjük őket. Ezután következtetési kéréseket küldünk ezekre a hosztolt végpontokra.

A regressziós és osztályozási problématípusokkal kapcsolatos további információkért lásd: Következtetési tároló definíciók regressziós és osztályozási problématípusokhoz.

Autopilot munkákat is indíthatunk a Amazon SageMaker Studio UI. Ha feladatokat indít el a felhasználói felületről, kapcsolja ki a Automatikus telepítés lehetőség a Üzembe helyezés és speciális beállítások szakasz. Ellenkező esetben az Autopilot a legjobb jelöltet telepíti egy valós idejű végpontra.

Előfeltételek

Győződjön meg arról, hogy a Boto3 legújabb verziója és a SageMaker Python csomagok telepítve vannak:

pip install -U boto3 sagemaker

Szükségünk van a SageMaker csomag verziójára >= 2.110.0 és Boto3 verzió >= boto3-1.24.84.

Indítson el egy Autopilot feladatot összeállítási móddal

Az Autopilot feladat elindításához a SageMaker Boto3 könyvtárak használatával a create_auto_ml_job API. Utána bemegyünk AutoMLJobConfig, InputDataConfigés AutoMLJobObjective bemenetként a create_auto_ml_job. Lásd a következő kódot:

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)

Az Autopilot visszaadja a BestCandidate modellobjektum, amely rendelkezik a InferenceContainers szükséges a modellek végpontok következtetéséhez való telepítéséhez. Ahhoz, hogy a BestCandidate az előző munkához a describe_automl_job funkció:

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)

Telepítse a betanított modellt

Most telepítjük az előző következtetési tárolót egy kiszolgáló nélküli végpontra. Az első lépés egy modell létrehozása a következtetési tárolóból, majd egy végpont konfiguráció létrehozása, amelyben megadjuk a MemorySizeInMB és a MaxConcurrency a kiszolgáló nélküli végpont értékeit a modellnévvel együtt. Végül létrehozunk egy végpontot a fent létrehozott végpont-konfigurációval.

Javasoljuk, hogy válassza ki a sajátját végpont memória mérete a modell méretének megfelelően. A memória méretének legalább akkorának kell lennie, mint a modell mérete. A kiszolgáló nélküli végpont minimális RAM-mérete 1024 MB (1 GB), a választható maximális RAM-méret pedig 6144 MB (6 GB).

A választható memóriaméretek: 1024 MB, 2048 MB, 3072 MB, 4096 MB, 5120 MB vagy 6144 MB.

Annak eldöntéséhez, hogy a kiszolgáló nélküli végpont a megfelelő telepítési lehetőség-e költség és teljesítmény szempontjából, javasoljuk, hogy tekintse meg a SageMaker Serverless Inference Benchmarking Toolkit, amely különböző végpont-konfigurációkat tesztel, és összehasonlítja a legoptimálisabbat egy összehasonlítható valós idejű tárhelypéldánnyal.

Vegye figyelembe, hogy a kiszolgáló nélküli végpontokat csak elfogadják SingleModel következtetési tárolókhoz. Az összeállítási módban az Autopilot egyetlen modellt hoz létre, így ezt a modelltárolót úgy tudjuk telepíteni, ahogy van a végponton. Lásd a következő kódot:

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

Amikor a kiszolgáló nélküli következtetés végpontja az InService, tesztelhetjük a végpontot egy következtetési kérés elküldésével, és megfigyelhetjük az előrejelzéseket. A következő ábra szemlélteti ennek a beállításnak az architektúráját.

Vegye figyelembe, hogy nyers adatokat küldhetünk hasznos adatként a végponthoz. Az Autopilot által generált együttes modell automatikusan egyetlen modellbe integrálja az összes szükséges jellemző-transzformációs és inverz címketranszformációs lépést, valamint az algoritmusmodellt és a csomagokat.

Következtetési kérés küldése a betanított modellnek

Használja a következő kódot, hogy következtetéseket küldjön az összeállítási módban betanított modelljére:

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)

Indítson el egy Autopilot Job-ot HPO móddal

HPO módban a CompletionCriteria, kívül MaxRuntimePerTrainingJobInSeconds és a MaxAutoMLJobRuntimeInSeconds, is megadhatnánk a MaxCandidates hogy korlátozza az Autopilot-munka által generált jelöltek számát. Vegye figyelembe, hogy ezek nem kötelező paraméterek, és csak a demonstrációs feladat futási idejének korlátozására vannak beállítva. Lásd a következő kódot:

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
				)

A BestCandidate az előző munkához ismét használhatjuk a describe_automl_job funkció:

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)

Telepítse a betanított modellt

Az osztályozási probléma típusának HPO módú autopilotja három következtetési tárolót generál.

Az első tároló kezeli a jellemző-átalakítási lépéseket. Ezután az algoritmustároló generálja a predicted_label a legnagyobb valószínűséggel. Végül az utófeldolgozási következtetéstároló inverz transzformációt hajt végre az előre jelzett címkén, és leképezi az eredeti címkére. További információkért lásd: Következtetési tároló definíciók regressziós és osztályozási problématípusokhoz.

Kibontjuk ezt a három következtetési tárolót, és külön kiszolgáló nélküli végpontokra helyezzük üzembe. Következtetéshez a végpontokat sorban hívjuk meg úgy, hogy a hasznos terhelést először a jellemző-transzformációs tárolóba küldjük, majd ebből a tárolóból átadjuk a kimenetet az algoritmus tárolójába, végül pedig az előző következtetési tároló kimenetét az utófeldolgozási tárolóba. amely az előrejelzett címkét adja ki.

A következő ábra szemlélteti ennek a beállításnak az architektúráját.

Kivonjuk a három következtetési tárolót a BestCandidate a következő kóddal:

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)

Következtetési kérés küldése a betanított modellnek

Következtetés céljából a hasznos terhet sorban küldjük el: először a jellemző-transzformációs tárolóba, majd a modelltárolóba, végül az inverz címkés transzformációs tárolóba.

Lásd a következő kódot:

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

A példa teljes megvalósítása a következő jupyterben érhető el jegyzetfüzet.

Tisztítsuk meg

Az erőforrások megtisztításához törölheti a létrehozott kiszolgáló nélküli végpontokat, végpont-konfigurációkat és modelleket:

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

Következtetés

Ebben a bejegyzésben bemutattuk, hogyan telepíthetjük az Autopilot által generált modelleket ensemble és HPO módban is kiszolgáló nélküli következtetési végpontokra. Ez a megoldás felgyorsíthatja a költséghatékony és teljes körűen felügyelt ML szolgáltatások, például az Autopilot használatának és előnyeinek kihasználását, hogy nyers adatokból gyorsan modelleket állítson elő, majd telepítse azokat teljesen felügyelt szerver nélküli következtetési végpontokon a beépített automatikus skálázással a költségek csökkentése érdekében. .

Javasoljuk, hogy próbálja ki ezt a megoldást az üzleti KPI-k szempontjából releváns adatkészlettel. A Jupyter notebookban megvalósított megoldást a GitHub repo.

További hivatkozások

A szerzőről

Praveen Chamarthi az Amazon Web Services vezető AI/ML szakértője. Szenvedélye az AI/ML és minden AWS. Amerika-szerte segít ügyfeleinek az ML-munkaterhelések AWS-en való hatékony skálázásában, innovációjában és kezelésében. Szabadidejében Praveen szeret olvasni, és szereti a sci-fi filmeket.