Csökkentse a költségeket és a fejlesztési időt az Amazon SageMaker Pipelines helyi móddal

A robusztus és újrafelhasználható gépi tanulási (ML) folyamatok létrehozása összetett és időigényes folyamat lehet. A fejlesztők általában helyben tesztelik a feldolgozási és betanítási szkripteket, de magukat a folyamatokat általában a felhőben tesztelik. Egy teljes folyamat létrehozása és futtatása a kísérletezés során nemkívánatos általános költségeket és költségeket növel a fejlesztési életciklusban. Ebben a bejegyzésben részletezzük, hogyan használhatod Amazon SageMaker Pipelines helyi mód az ML folyamatok helyi futtatására, hogy csökkentse a folyamatfejlesztést és a futási időt, miközben csökkenti a költségeket. Miután a csővezetéket teljesen helyileg tesztelték, egyszerűen újrafuttathatja Amazon SageMaker kezelt erőforrások néhány soros kódmódosítással.

Az ML életciklusának áttekintése

Az ML új innovációinak és alkalmazásainak egyik fő mozgatórugója az adatok elérhetősége és mennyisége, valamint az olcsóbb számítási lehetőségek. Az ML számos területen bebizonyította, hogy képes megoldani a klasszikus big data és elemzési technikákkal korábban megoldhatatlan problémákat, és folyamatosan növekszik az adattudomány és az ML gyakorlói iránti kereslet. Az ML életciklusa nagyon magas szinten sok különböző részből áll, de egy ML modell felépítése általában a következő általános lépésekből áll:

1. Adatok tisztítása és előkészítése (funkciótervezés)
2. Modellképzés és tuning
3. Modell értékelés
4. Modell üzembe helyezés (vagy kötegelt átalakítás)

Az adat-előkészítési lépésben az adatok betöltése, masszírozása és az ML modell által elvárt bemeneti típusokká vagy jellemzőkké alakítása történik. Az adatok átalakításához szükséges szkriptek írása jellemzően iteratív folyamat, ahol a gyors visszacsatolási hurkok fontosak a fejlesztés felgyorsítása érdekében. Általában nem szükséges a teljes adatkészletet használni a funkciótervező szkriptek tesztelésekor, ezért használhatja a helyi mód funkció a SageMaker Processing. Ez lehetővé teszi a helyi futtatást és a kód iteratív frissítését egy kisebb adatkészlet használatával. Amikor a végső kód készen áll, elküldi a távoli feldolgozási feladatnak, amely a teljes adatkészletet használja, és a SageMaker által felügyelt példányokon fut.

A fejlesztési folyamat hasonló az adat-előkészítési lépéshez mind a modell betanítási, mind a modellértékelési lépések esetében. Az adattudósok a helyi mód funkció a SageMaker Training programban, hogy gyorsan iterálhasson kisebb adatkészletekkel helyileg, mielőtt az összes adatot felhasználná a SageMaker által kezelt ML-optimalizált példányokból álló fürtben. Ez felgyorsítja a fejlesztési folyamatot, és kiküszöböli a SageMaker által kezelt ML példányok kísérletezés közbeni futtatásának költségeit.

Ahogy egy szervezet ML érettsége növekszik, használhatja Amazon SageMaker csővezetékek ML folyamatok létrehozásához, amelyek összefűzik ezeket a lépéseket, összetettebb ML munkafolyamatokat hozva létre, amelyek feldolgozzák, betanítják és értékelik az ML modelleket. A SageMaker Pipelines egy teljesen felügyelt szolgáltatás az ML munkafolyamat különböző lépéseinek automatizálására, beleértve az adatbetöltést, az adatátalakítást, a modell betanítását és hangolását, valamint a modell üzembe helyezését. Egészen a közelmúltig helyileg is fejleszthette és tesztelhette szkriptjeit, de az ML-folyamatokat a felhőben kellett tesztelnie. Ez lassú és költséges folyamattá tette az ML-csővezetékek áramlásának és formájának iterációját. Mostantól a SageMaker Pipelines hozzáadott helyi mód funkciójával az ML-folyamatokat ugyanúgy iterálhatja és tesztelheti, mint ahogyan a feldolgozási és betanítási parancsfájlokat teszteli és iterálja. Futtathatja és tesztelheti a folyamatokat a helyi gépen, az adatok kis részhalmazának felhasználásával a folyamat szintaxisának és funkcióinak érvényesítésére.

SageMaker csővezetékek

A SageMaker Pipelines teljesen automatizált módja az egyszerű vagy összetett ML munkafolyamatok futtatásának. A SageMaker Pipelines segítségével ML munkafolyamatokat hozhat létre egy könnyen használható Python SDK segítségével, majd vizualizálhatja és kezelheti a munkafolyamatokat a Amazon SageMaker Studio. Adattudományi csapatai hatékonyabbak és gyorsabban skálázhatók, ha tárolják és újra felhasználják a SageMaker Pipelinesben létrehozott munkafolyamat-lépéseket. Használhat előre elkészített sablonokat is, amelyek automatizálják az infrastruktúra és a lerakat létrehozását a modellek létrehozásához, teszteléséhez, regisztrálásához és üzembe helyezéséhez az ML környezetben. Ezek a sablonok automatikusan elérhetők a szervezet számára, és a következőkkel vannak kiépítve AWS szolgáltatáskatalógus termékeket.

A SageMaker Pipelines folyamatos integrációs és folyamatos üzembe helyezési (CI/CD) gyakorlatokat kínál az ML-be, mint például a fejlesztői és éles környezetek közötti paritás fenntartása, a verziókezelés, az igény szerinti tesztelés és a végpontok közötti automatizálás, amely segít az ML méretezésében. szervezet. A DevOps szakemberei tudják, hogy a CI/CD technikák használatának néhány fő előnye a termelékenység növekedése az újrafelhasználható komponensek révén, valamint a minőség javítása az automatizált tesztelés révén, ami gyorsabb megtérülést eredményez az üzleti célok elérése érdekében. Ezek az előnyök már elérhetőek az MLOps gyakorlói számára a SageMaker Pipelines segítségével az ML modellek betanításának, tesztelésének és telepítésének automatizálására. A helyi móddal most sokkal gyorsabban iterálhat, miközben folyamatban lévő szkripteket fejleszt. Vegye figyelembe, hogy a helyi folyamatpéldányok nem tekinthetők meg és nem futtathatók a Studio IDE-n belül; azonban hamarosan további megtekintési lehetőségek állnak rendelkezésre a helyi csővezetékekhez.

A SageMaker SDK általános célt biztosít helyi mód konfigurálása amely lehetővé teszi a fejlesztők számára a támogatott processzorok és becslések futtatását és tesztelését a helyi környezetükben. Használhatja a helyi módú képzést több AWS által támogatott keretképpel (TensorFlow, MXNet, Chainer, PyTorch és Scikit-Learn), valamint a saját maga által biztosított képekkel.

A SageMaker Pipelines, amely irányított aciklikus gráfot (DAG) hoz létre összehangolt munkafolyamat lépésekből, számos olyan tevékenységet támogat, amelyek az ML életciklus részét képezik. Helyi módban a következő lépések támogatottak:

• Munka lépéseinek feldolgozása – Egyszerűsített, felügyelt tapasztalat a SageMakerrel az adatfeldolgozási munkaterhelések futtatásához, mint például a funkciótervezés, az adatérvényesítés, a modellértékelés és a modellértelmezés
• Képzési munka lépései – Iteratív folyamat, amely megtanítja a modellt előrejelzések készítésére egy betanítási adatkészletből származó példák bemutatásával
• Hiperparaméter hangolási munkák – Automatizált módszer a legpontosabb modellt előállító hiperparaméterek értékelésére és kiválasztására
• Feltételes futási lépések – Egy lépés, amely feltételes ágak futtatását biztosítja egy folyamatban
• Modell lépés – A CreateModel argumentumokkal ez a lépés modellt hozhat létre az átalakítási lépésekben vagy a későbbi végpontként történő telepítéshez.
• A munkalépések átalakítása – Kötegelt átalakítási feladat, amely előrejelzéseket generál nagy adatkészletekből, és következtetéseket futtat, ha nincs szükség állandó végpontra
• Sikertelen lépések – Olyan lépés, amely leállítja a folyamatot, és sikertelennek jelöli

Megoldás áttekintése

Megoldásunk bemutatja a SageMaker Pipelines helyi módban történő létrehozásának és futtatásának alapvető lépéseit, ami azt jelenti, hogy helyi CPU-, RAM- és lemezerőforrásokat kell használni a munkafolyamat lépéseinek betöltéséhez és futtatásához. A helyi környezet futhat laptopon, olyan népszerű IDE-ket használva, mint a VSCode vagy a PyCharm, vagy a SageMaker üzemeltetheti klasszikus notebook példányokat használva.

A helyi mód lehetővé teszi az adattudósok számára a lépések összeillesztését, amelyek magukban foglalhatják a feldolgozási, képzési és értékelési feladatokat, és a teljes munkafolyamatot helyileg futtathatják. Ha végzett a helyi teszteléssel, újra futtathatja a folyamatot egy SageMaker által felügyelt környezetben, ha lecseréli a LocalPipelineSession tárgyat PipelineSession, amely konzisztenciát hoz az ML életciklusába.

Ehhez a notebook-mintához egy szabványos, nyilvánosan elérhető adatkészletet használunk, a UCI Machine Learning Abalone Dataset. A cél egy ML modell betanítása, amely meghatározza egy abalone csiga korát annak fizikai mérései alapján. Lényegében ez egy regressziós probléma.

A notebookminta futtatásához szükséges összes kód elérhető a GitHubon a következő helyen: amazon-sagemaker-példák adattár. Ebben a jegyzetfüzetmintában az egyes folyamatfolyamat-lépések külön-külön jönnek létre, majd össze vannak kötve a folyamat létrehozásához. A következő lépéseket hozzuk létre:

• Feldolgozási lépés (funkciótervezés)
• Képzési lépés (modellképzés)
• Feldolgozási lépés (modellértékelés)
• Feltétel lépés (modell pontosság)
• Modelllépés létrehozása (modell)
• Átalakítási lépés (kötegelt átalakítás)
• Modelllépés regisztrálása (modellcsomag)
• Sikertelen lépés (futtatás sikertelen)

A következő ábra szemlélteti csővezetékünket.

Előfeltételek

A bejegyzés követéséhez a következőkre lesz szüksége:

Miután ezek az előfeltételek adottak, a következő szakaszokban leírtak szerint futtathatja a mintajegyzetfüzetet.

Építsd meg a csővezetékedet

Ebben a jegyzetfüzetmintában használjuk SageMaker Script mód a legtöbb ML-folyamat esetében, ami azt jelenti, hogy a tényleges Python-kódot (scripteket) biztosítjuk a tevékenység végrehajtásához, és hivatkozást adunk át erre a kódra. A Script Mode nagy rugalmasságot biztosít a SageMaker feldolgozáson belüli viselkedés szabályozásához, mivel lehetővé teszi a kód testreszabását, miközben továbbra is kihasználja a SageMaker előre beépített konténereit, mint például az XGBoost vagy a Scikit-Learn. Az egyéni kód egy Python-szkriptfájlba kerül a magic paranccsal kezdődő cellák használatával %%writefile, mint a következők:

%%writefile code/evaluation.py

A helyi mód elsődleges engedélyezője a LocalPipelineSession objektum, amely a Python SDK-ból van példányosítva. A következő kódszegmensek bemutatják, hogyan hozhat létre SageMaker folyamatot helyi módban. Bár a helyi adatfolyam számos lépéséhez beállíthat helyi adatútvonalat, az Amazon S3 az alapértelmezett hely az átalakítás által kibocsátott adatok tárolására. Az új LocalPipelineSession Az objektum átadásra kerül a Python SDK-nak az ebben a bejegyzésben leírt SageMaker munkafolyamat API-hívások közül sok. Vegye figyelembe, hogy használhatja a local_pipeline_session változó az S3 alapértelmezett csoportjára és az aktuális régiónévre mutató hivatkozások lekéréséhez.

from sagemaker.workflow.pipeline_context import LocalPipelineSession

# Create a `LocalPipelineSession` object so that each 
# pipeline step will run locally
# To run this pipeline in the cloud, you must change 
# the `LocalPipelineSession()` to `PipelineSession()`
local_pipeline_session = LocalPipelineSession()
region = local_pipeline_session.boto_region_name

default_bucket = local_pipeline_session.default_bucket()
prefix = "sagemaker-pipelines-local-mode-example"

Mielőtt létrehoznánk az egyes folyamatlépéseket, beállítunk néhány, a folyamat által használt paramétert. Ezen paraméterek némelyike ​​karakterlánc-literál, míg mások az SDK által biztosított speciális felsorolt ​​típusokként jönnek létre. A felsorolt ​​gépelés biztosítja, hogy érvényes beállításokat kapjon a folyamat, mint például ez, amely a ConditionLessThanOrEqualTo lépj lejjebb:

mse_threshold = ParameterFloat(name="MseThreshold", default_value=7.0)

Egy adatfeldolgozási lépés létrehozásához, amelyet itt jellemző tervezés végrehajtására használunk, a SKLearnProcessor az adatkészlet betöltéséhez és átalakításához. Elhaladunk a local_pipeline_session változót az osztálykonstruktorhoz, amely arra utasítja a munkafolyamat lépését, hogy helyi módban fusson:

from sagemaker.sklearn.processing import SKLearnProcessor

framework_version = "1.0-1"

sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=instance_type,
    instance_count=processing_instance_count,
    base_job_name="sklearn-abalone-process",
    role=role,
    sagemaker_session=local_pipeline_session,
)

Ezután létrehozzuk az első tényleges folyamatlépést, a ProcessingStep objektum, a SageMaker SDK-ból importálva. A processzor argumentumait egy hívás visszaadja a SKLearnProcessor run() metódus. Ez a munkafolyamat-lépés a notebook vége felé mutató egyéb lépésekkel kombinálva jelzi a folyamaton belüli működési sorrendet.

from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep

processor_args = sklearn_processor.run(
    inputs=[
        ProcessingInput(source=input_data, destination="/opt/ml/processing/input"),
    ],
    outputs=[
        ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
        ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
        ProcessingOutput(output_name="test", source="/opt/ml/processing/test"),
    ],
    code="code/preprocessing.py",
)

step_process = ProcessingStep(name="AbaloneProcess", step_args=processor_args)

Ezután kódot biztosítunk egy betanítási lépés létrehozásához, először a SageMaker SDK használatával szabványos becslő példányosításával. Ugyanazt adjuk át local_pipeline_session xgb_train nevű változót a becslőhöz, mint a sagemaker_session érv. Mivel egy XGBoost modellt szeretnénk betanítani, érvényes kép URI-t kell létrehoznunk a következő paraméterek megadásával, beleértve a keretrendszert és számos verzióparamétert:

from sagemaker.estimator import Estimator
from sagemaker.inputs import TrainingInput

model_path = f"s3://{default_bucket}/{prefix}/model"
image_uri = sagemaker.image_uris.retrieve(
    framework="xgboost",
    region=region,
    version="1.5-1",
    py_version="py3",
    instance_type=instance_type,
)

xgb_train = Estimator(
    image_uri=image_uri,
    entry_point="code/abalone.py",
    instance_type=instance_type,
    instance_count=training_instance_count,
    output_path=model_path,
    role=role,
    sagemaker_session=local_pipeline_session,
)

Opcionálisan hívhatunk például további becslő módszereket is set_hyperparameters(), hiperparaméter-beállítások biztosításához a betanítási munkához. Most, hogy beállítottunk egy becslőt, készen állunk a tényleges képzési lépés létrehozására. Még egyszer importáljuk a TrainingStep osztály a SageMaker SDK könyvtárból:

from sagemaker.workflow.steps import TrainingStep

step_train = TrainingStep(name="AbaloneTrain", step_args=train_args)

Ezután építünk egy másik feldolgozási lépést a modellértékelés végrehajtásához. Ez úgy történik, hogy a ScriptProcessor példány és átadva a local_pipeline_session objektum paraméterként:

from sagemaker.processing import ScriptProcessor

script_eval = ScriptProcessor(
    image_uri=image_uri,
    command=["python3"],
    instance_type=instance_type,
    instance_count=processing_instance_count,
    base_job_name="script-abalone-eval",
    role=role,
    sagemaker_session=local_pipeline_session,
)

A betanított modell telepítésének engedélyezéséhez vagy a SageMaker valós idejű végpont vagy kötegelt transzformációhoz létre kell hoznunk a Model objektumot a modell melléktermékeinek, a megfelelő kép-URI-nak és opcionálisan az egyéni következtetési kódunknak a átadásával. Akkor ezt átadjuk Model tiltakozik a ModelStep, amely hozzáadódik a helyi csővezetékhez. Lásd a következő kódot:

from sagemaker.model import Model

model = Model(
    image_uri=image_uri,
    model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
    source_dir="code",
    entry_point="inference.py",
    role=role,
    sagemaker_session=local_pipeline_session,
)

from sagemaker.workflow.model_step import ModelStep

step_create_model = ModelStep(name="AbaloneCreateModel", 
    step_args=model.create(instance_type=instance_type)
)

Ezután létrehozunk egy kötegelt átalakítási lépést, amelyben elküldjük a jellemzővektorok halmazát, és következtetést hajtunk végre. Először létre kell hoznunk a Transformer tárgyat, és adja át a local_pipeline_session paramétert hozzá. Ezután létrehozzuk a TransformStep, adja át a szükséges argumentumokat, és adja hozzá ezt a folyamat definíciójához:

from sagemaker.transformer import Transformer

transformer = Transformer(
    model_name=step_create_model.properties.ModelName,
    instance_type=instance_type,
    instance_count=transform_instance_count,
    output_path=f"s3://{default_bucket}/{prefix}/transform",
    sagemaker_session=local_pipeline_session,
)

from sagemaker.workflow.steps import TransformStep

transform_args = transformer.transform(transform_data, content_type="text/csv")

step_transform = TransformStep(name="AbaloneTransform", step_args=transform_args)

Végül egy elágazási feltételt szeretnénk hozzáadni a munkafolyamathoz, hogy csak akkor futtassuk a kötegelt transzformációt, ha a modellértékelés eredményei megfelelnek a kritériumainknak. Ezt a feltételt a hozzáadásával jelezhetjük ConditionStep egy adott feltételtípussal, mint pl ConditionLessThanOrEqualTo. Ezután felsoroljuk a két ág lépéseit, lényegében meghatározva a folyamat if/else vagy igaz/hamis ágait. Az if_steps a ConditionStep (step_create_model, step_transform) futnak, amikor a feltétel kiértékelődik True.

from sagemaker.workflow.conditions import ConditionLessThanOrEqualTo
from sagemaker.workflow.condition_step import ConditionStep
from sagemaker.workflow.functions import JsonGet

cond_lte = ConditionLessThanOrEqualTo(
    left=JsonGet(
        step_name=step_eval.name,
        property_file=evaluation_report,
        json_path="regression_metrics.mse.value",),
    right=mse_threshold,
)

step_cond = ConditionStep(
    name="AbaloneMSECond",
    conditions=[cond_lte],
    if_steps=[step_create_model, step_transform],
    else_steps=[step_fail],
)

A következő diagram ezt a feltételes ágat és a kapcsolódó if/else lépéseket szemlélteti. Csak egy ág fut, a modellértékelési lépés eredménye alapján a feltétellépésben összehasonlítva.

Most, hogy minden lépésünket meghatároztuk, és az alapul szolgáló osztálypéldányokat létrehoztuk, egyesíthetjük őket egy folyamatba. Megadunk néhány paramétert, és alapvetően meghatározzuk a működési sorrendet, egyszerűen felsorolva a lépéseket a kívánt sorrendben. Vegye figyelembe, hogy a TransformStep nem jelenik meg itt, mert ez a feltételes lépés célpontja, és a lépés argumentumaként lett megadva a ConditionalStep korábban.

from sagemaker.workflow.pipeline import Pipeline

pipeline_name = f"LocalModelPipeline"
pipeline = Pipeline(
    name=pipeline_name,
    parameters=[
        input_data,
        mse_threshold,
    ],
    steps=[step_process, step_train, step_eval, step_cond],
    sagemaker_session=local_pipeline_session,
)

A folyamat futtatásához két módszert kell meghívnia: pipeline.upsert(), amely feltölti a folyamatot az alapul szolgáló szolgáltatásba, és pipeline.start(), amely elindítja a csővezetéket. Számos egyéb módszert is használhat a futás állapotának lekérdezésére, a folyamat lépéseinek felsorolására és még sok másra. Mivel a helyi módú folyamatmenetet használtuk, ezek a lépések mind helyileg futnak a processzoron. A start metódus alatti cellakimenet a folyamat kimenetét mutatja:

pipeline.upsert(role_arn=role)
execution = pipeline.start()

A cellakimenet alján a következőhöz hasonló üzenetnek kell megjelennie:

Pipeline execution d8c3e172-089e-4e7a-ad6d-6d76caf987b7 SUCCEEDED

Visszatérés a kezelt erőforrásokhoz

Miután megerősítettük, hogy a folyamat hiba nélkül fut, és elégedettek vagyunk a folyamattal és formájával, újra létrehozhatjuk a folyamatot, de a SageMaker által kezelt erőforrásokkal, és újrafuttathatjuk. Az egyetlen szükséges változtatás a PipelineSession tárgy helyett LocalPipelineSession:

ból ből sagemaker.workflow.pipeline_context LocalPipelineSession importálása
from sagemaker.workflow.pipeline_context import PipelineSession

local_pipeline_session = LocalPipelineSession()
pipeline_session = PipelineSession()

Ez tájékoztatja a szolgáltatást, hogy futtasson minden lépést, amely erre a munkamenet-objektumra hivatkozik a SageMaker felügyelt erőforrásain. Tekintettel a kis változtatásra, csak a szükséges kódmódosításokat szemléltetjük a következő kódcellában, de ugyanazt a változtatást minden cellán végre kell hajtani a local_pipeline_session tárgy. A változtatások azonban minden cellában azonosak, mert csak a local_pipeline_session objektum a pipeline_session tárgy.

from sagemaker.sklearn.processing import SKLearnProcessor

framework_version = "1.0-1"

sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=instance_type,
    instance_count=processing_instance_count,
    base_job_name="sklearn-abalone-process",
    role=role,
    sagemaker_session=pipeline_session,  # non-local session
)

Miután a helyi munkamenet objektum mindenhol le lett cserélve, újra létrehozzuk a folyamatot, és futtatjuk a SageMaker által kezelt erőforrásokkal:

from sagemaker.workflow.pipeline import Pipeline

pipeline_name = f"LocalModelPipeline"
pipeline = Pipeline(
    name=pipeline_name,
    parameters=[
        input_data,
        mse_threshold,
    ],
    steps=[step_process, step_train, step_eval, step_cond],
    sagemaker_session=pipeline_session, # non-local session
)

pipeline.upsert(role_arn=role)
execution = pipeline.start()

Tisztítsuk meg

Ha rendben szeretné tartani a Studio környezetet, a következő módszerekkel törölheti a SageMaker folyamatot és a modellt. A teljes kód a mintában található jegyzetfüzet.

# delete models 
sm_client = boto3.client("sagemaker")
model_prefix="AbaloneCreateModel"
delete_models(sm_client, model_prefix)

# delete managed pipeline
pipeline_to_delete = 'SM-Managed-Pipeline'
delete_sagemaker_pipeline(sm_client, pipeline_to_delete)

Következtetés

Egészen a közelmúltig használhatta a SageMaker Processing és SageMaker Training helyi módú szolgáltatását a feldolgozási és betanítási szkriptek helyi iterálására, mielőtt futtatná azokat az összes adaton a SageMaker által felügyelt erőforrásokkal. A SageMaker Pipelines új helyi módú funkciójával az ML-szakemberek mostantól ugyanazt a módszert alkalmazhatják az ML-folyamataikon való iteráció során, és összeilleszthetik a különböző ML-munkafolyamatokat. Amikor a folyamat készen áll a termelésre, a SageMaker felügyelt erőforrásokkal való futtatásához mindössze néhány sornyi kódmódosítás szükséges. Ez csökkenti a folyamat közbeni futási időt, ami gyorsabb folyamatfejlesztéshez vezet gyorsabb fejlesztési ciklusokkal, miközben csökkenti a SageMaker által kezelt erőforrások költségeit.

Ha többet szeretne megtudni, látogasson el Amazon SageMaker csővezetékek or Használja a SageMaker Pipelines-t a munkáinak helyi futtatásához.

A szerzőkről

Hargis Pál erőfeszítéseit a gépi tanulásra összpontosította több vállalatnál, köztük az AWS-nél, az Amazonnál és a Hortonworksnél. Élvezi a technológiai megoldások építését, és megtanítja az embereket, hogyan tudják a legtöbbet kihozni belőlük. Az AWS-nél betöltött szerepe előtt az Amazon Exports and Expansions vezető építészeként segítette az amazon.com-ot a nemzetközi vásárlók élményének javításában. Paul szereti segíteni az ügyfeleknek a gépi tanulási kezdeményezéseik kiterjesztésében a valós problémák megoldása érdekében.

Niklas Pálma megoldástervező a stockholmi AWS-nél, Svédországban, ahol segíti az ügyfeleket az északi országokban, hogy sikeresek legyenek a felhőben. Különösen szenvedélyes a szerver nélküli technológiák, az IoT és a gépi tanulás mellett. A munkán kívül Niklas lelkes sífutó és snowboardos, valamint mesteri tojásfőző.

Kirit Thadaka egy ML Solutions Architect, aki a SageMaker Service SA csapatában dolgozik. Mielőtt csatlakozott volna az AWS-hez, Kirit korai szakaszban induló mesterséges intelligenciával foglalkozó vállalkozásokban dolgozott, majd egy ideig tanácsadóként különböző szerepkörökben MI-kutatásban, MLOps-ban és műszaki vezetésben dolgozott.