Ordna Ray-baserade arbetsflöden för maskininlärning med Amazon SageMaker | Amazon webbtjänster

Maskininlärning (ML) blir allt mer komplex när kunder försöker lösa fler och mer utmanande problem. Denna komplexitet leder ofta till behovet av distribuerad ML, där flera maskiner används för att träna en enda modell. Även om detta möjliggör parallellisering av uppgifter över flera noder, vilket leder till accelererade träningstider, förbättrad skalbarhet och förbättrad prestanda, finns det betydande utmaningar med att effektivt använda distribuerad hårdvara. Dataforskare måste ta itu med utmaningar som datapartitionering, lastbalansering, feltolerans och skalbarhet. ML-ingenjörer måste hantera parallellisering, schemaläggning, fel och återförsök manuellt, vilket kräver komplex infrastrukturkod.

I det här inlägget diskuterar vi fördelarna med att använda Stråle och Amazon SageMaker för distribuerad ML, och tillhandahålla en steg-för-steg-guide om hur man använder dessa ramverk för att bygga och distribuera ett skalbart ML-arbetsflöde.

Ray, ett distribuerat datorramverk med öppen källkod, tillhandahåller ett flexibelt ramverk för distribuerad utbildning och servering av ML-modeller. Den abstraherar bort distribuerade systemdetaljer på låg nivå genom enkla, skalbara bibliotek för vanliga ML-uppgifter som dataförbearbetning, distribuerad träning, hyperparameterjustering, förstärkningsinlärning och modellservering.

SageMaker är en helt hanterad tjänst för att bygga, träna och distribuera ML-modeller. Ray integreras sömlöst med SageMaker-funktioner för att bygga och distribuera komplexa ML-arbetsbelastningar som är både effektiva och pålitliga. Kombinationen av Ray och SageMaker ger end-to-end-funktioner för skalbara ML-arbetsflöden och har följande markerade funktioner:

• Distribuerade aktörer och parallellitetskonstruktioner i Ray förenklar utvecklingen av distribuerade applikationer.
• Ray AI Runtime (AIR) minskar friktionen vid att gå från utveckling till produktion. Med Ray och AIR kan samma Python-kod skalas sömlöst från en bärbar dator till ett stort kluster.
• SageMakers hanterade infrastruktur och funktioner som bearbetningsjobb, träningsjobb och hyperparameterjusteringar kan använda Ray-bibliotek under för distribuerad datoranvändning.
• Amazon SageMaker-experiment gör det möjligt att snabbt iterera och hålla reda på försök.
• Amazon SageMaker Feature Store tillhandahåller ett skalbart arkiv för att lagra, hämta och dela ML-funktioner för modellträning.
• Utbildade modeller kan lagras, versioneras och spåras in Amazon SageMaker Model Registry för styrning och ledning.

• Amazon SageMaker-rörledningar tillåter orkestrering av hela ML-livscykeln från dataförberedelse och utbildning till modellimplementering som automatiserade arbetsflöden.

Lösningsöversikt

Det här inlägget fokuserar på fördelarna med att använda Ray och SageMaker tillsammans. Vi satte upp ett end-to-end Ray-baserat ML-arbetsflöde, orkestrerat med SageMaker Pipelines. Arbetsflödet inkluderar parallell inmatning av data i funktionslagret med hjälp av Ray-aktörer, dataförbehandling med Ray Data, träningsmodeller och hyperparameterjustering i skala med hjälp av Ray Train och hyperparameteroptimering (HPO), och slutligen modellutvärdering och registrering av modellen i en modellregistret.

För vår data använder vi ett syntetiskt husdataset som består av åtta funktioner (YEAR_BUILT, SQUARE_FEET, NUM_BEDROOM, NUM_BATHROOMS, LOT_ACRES, GARAGE_SPACES, FRONT_PORCHoch DECK) och vår modell kommer att förutsäga PRICE av huset.

Varje steg i ML-arbetsflödet är uppdelat i diskreta steg, med sitt eget skript som tar in- och utdataparametrar. I nästa avsnitt markerar vi nyckelkodavsnitt från varje steg. Hela koden finns på aws-samples-for-ray GitHub-förråd.

Förutsättningar

För att använda SageMaker Python SDK och köra koden som är kopplad till det här inlägget, behöver du följande förutsättningar:

Mata in data i SageMaker Feature Store

Det första steget i ML-arbetsflödet är att läsa källdatafilen från Amazon enkel lagringstjänst (Amazon S3) i CSV-format och mata in det i SageMaker Feature Store. SageMaker Feature Store är ett specialbyggt arkiv som gör det enkelt för team att skapa, dela och hantera ML-funktioner. Det förenklar upptäckt, återanvändning och delning av funktioner, vilket leder till snabbare utveckling, ökat samarbete inom kundteam och minskade kostnader.

Att mata in funktioner i funktionslagret innehåller följande steg:

1. Definiera en funktionsgrupp och skapa funktionsgruppen i funktionslagret.
2. Förbered källdata för funktionslagret genom att lägga till en händelsetid och post-ID för varje rad med data.
3. Ta in den förberedda informationen i funktionsgruppen genom att använda Boto3 SDK.

I det här avsnittet lyfter vi bara fram steg 3, eftersom detta är den del som involverar parallell bearbetning av intagsuppgiften med Ray. Du kan granska hela koden för denna process i GitHub repo.

Smakämnen ingest_features metod definieras i en klass som kallas Featurestore. Observera att Featurestore klass är inredd med @ray.remote. Detta indikerar att en instans av denna klass är en Ray-skådespelare, en tillståndsgivande och samtidig beräkningsenhet inom Ray. Det är en programmeringsmodell som låter dig skapa distribuerade objekt som upprätthåller ett internt tillstånd och som kan nås samtidigt av flera uppgifter som körs på olika noder i ett Ray-kluster. Skådespelare tillhandahåller ett sätt att hantera och kapsla in det föränderliga tillståndet, vilket gör dem värdefulla för att bygga komplexa, tillståndsfulla applikationer i en distribuerad miljö. Du kan också specificera resurskrav hos aktörer. I det här fallet, varje instans av FeatureStore klass kommer att kräva 0.5 processorer. Se följande kod:

@ray.remote(num_cpus=0.5)
class Featurestore: def ingest_features(self,feature_group_name, df, region): """ Ingest features to Feature Store Group Args: feature_group_name (str): Feature Group Name data_path (str): Path to the train/validation/test data in CSV format. """ ...

Du kan interagera med skådespelaren genom att ringa till remote operatör. I följande kod skickas det önskade antalet skådespelare in som ett inmatningsargument till manuset. Datan partitioneras sedan baserat på antalet aktörer och skickas till de avlägsna parallella processerna för att matas in i funktionslagret. Du kan ringa get på objektreferen för att blockera exekveringen av den aktuella uppgiften tills fjärrberäkningen är klar och resultatet är tillgängligt. När resultatet är tillgängligt, ray.get kommer att returnera resultatet och utförandet av den aktuella uppgiften kommer att fortsätta.

import modin.pandas as pd
import ray df = pd.read_csv(s3_path)
data = prepare_df_for_feature_store(df)
# Split into partitions
partitions = [ray.put(part) for part in np.array_split(data, num_actors)]
# Start actors and assign partitions in a loop
actors = [Featurestore.remote() for _ in range(args.num_actors)]
results = [] for actor, partition in zip(actors, input_partitions): results.append(actor.ingest_features.remote( args.feature_group_name, partition, args.region ) ) ray.get(results)

Förbered data för utbildning, validering och testning

I det här steget använder vi Ray Dataset för att effektivt dela upp, transformera och skala vår datauppsättning som förberedelse för maskininlärning. Ray Dataset tillhandahåller ett standardsätt att ladda distribuerad data till Ray, vilket stöder olika lagringssystem och filformat. Den har API:er för vanliga ML-dataförbehandlingsoperationer som parallella transformationer, blandning, gruppering och aggregering. Ray Dataset hanterar även operationer som kräver stateful installation och GPU-acceleration. Det integreras smidigt med andra databehandlingsbibliotek som Spark, Pandas, NumPy och mer, såväl som ML-ramverk som TensorFlow och PyTorch. Detta gör det möjligt att bygga end-to-end datapipelines och ML-arbetsflöden ovanpå Ray. Målet är att göra distribuerad databehandling och ML enklare för praktiker och forskare.

Låt oss titta på delar av skripten som utför denna dataförbearbetning. Vi börjar med att ladda data från funktionsbutiken:

def load_dataset(feature_group_name, region): """ Loads the data as a ray dataset from the offline featurestore S3 location Args: feature_group_name (str): name of the feature group Returns: ds (ray.data.dataset): Ray dataset the contains the requested dat from the feature store """ session = sagemaker.Session(boto3.Session(region_name=region)) fs_group = FeatureGroup( name=feature_group_name, sagemaker_session=session ) fs_data_loc = fs_group.describe().get("OfflineStoreConfig").get("S3StorageConfig").get("ResolvedOutputS3Uri") # Drop columns added by the feature store # Since these are not related to the ML problem at hand cols_to_drop = ["record_id", "event_time","write_time", "api_invocation_time", "is_deleted", "year", "month", "day", "hour"] ds = ray.data.read_parquet(fs_data_loc) ds = ds.drop_columns(cols_to_drop) print(f"{fs_data_loc} count is {ds.count()}") return ds

Vi delar sedan upp och skalar data med hjälp av abstraktioner på högre nivå som är tillgängliga från ray.data bibliotek:

def split_dataset(dataset, train_size, val_size, test_size, random_state=None): """ Split dataset into train, validation and test samples Args: dataset (ray.data.Dataset): input data train_size (float): ratio of data to use as training dataset val_size (float): ratio of data to use as validation dataset test_size (float): ratio of data to use as test dataset random_state (int): Pass an int for reproducible output across multiple function calls. Returns: train_set (ray.data.Dataset): train dataset val_set (ray.data.Dataset): validation dataset test_set (ray.data.Dataset): test dataset """ # Shuffle this dataset with a fixed random seed. shuffled_ds = dataset.random_shuffle(seed=random_state) # Split the data into train, validation and test datasets train_set, val_set, test_set = shuffled_ds.split_proportionately([train_size, val_size]) return train_set, val_set, test_set def scale_dataset(train_set, val_set, test_set, target_col): """ Fit StandardScaler to train_set and apply it to val_set and test_set Args: train_set (ray.data.Dataset): train dataset val_set (ray.data.Dataset): validation dataset test_set (ray.data.Dataset): test dataset target_col (str): target col Returns: train_transformed (ray.data.Dataset): train data scaled val_transformed (ray.data.Dataset): val data scaled test_transformed (ray.data.Dataset): test data scaled """ tranform_cols = dataset.columns() # Remove the target columns from being scaled tranform_cols.remove(target_col) # set up a standard scaler standard_scaler = StandardScaler(tranform_cols) # fit scaler to training dataset print("Fitting scaling to training data and transforming dataset...") train_set_transformed = standard_scaler.fit_transform(train_set) # apply scaler to validation and test datasets print("Transforming validation and test datasets...") val_set_transformed = standard_scaler.transform(val_set) test_set_transformed = standard_scaler.transform(test_set) return train_set_transformed, val_set_transformed, test_set_transformed

De bearbetade tåg-, validerings- och testdatauppsättningarna lagras i Amazon S3 och kommer att skickas som indataparametrar till efterföljande steg.

Utför modellträning och hyperparameteroptimering

Med vår data förbehandlad och redo för modellering är det dags att träna några ML-modeller och finjustera deras hyperparametrar för att maximera prediktiv prestanda. Vi använder XGBoost-Ray, en distribuerad backend för XGBoost byggd på Ray som möjliggör träning av XGBoost-modeller på stora datamängder genom att använda flera noder och GPU:er. Det ger enkla drop-in-ersättningar för XGBoosts tåg- och förutsägnings-API:er samtidigt som den hanterar komplexiteten med distribuerad datahantering och utbildning under huven.

För att möjliggöra distribution av träningen över flera noder använder vi en hjälpklass som heter RayHelper. Som visas i följande kod använder vi resurskonfigurationen för träningsjobbet och väljer den första värden som huvudnod:

class RayHelper(): def __init__(self, ray_port:str="9339", redis_pass:str="redis_password"): .... self.resource_config = self.get_resource_config() self.head_host = self.resource_config["hosts"][0] self.n_hosts = len(self.resource_config["hosts"])

Vi kan använda värdinformationen för att bestämma hur Ray ska initieras för var och en av träningsjobbsinstanserna:

def start_ray(self): head_ip = self._get_ip_from_host() # If the current host is the host choosen as the head node # run `ray start` with specifying the --head flag making this is the head node if self.resource_config["current_host"] == self.head_host: output = subprocess.run(['ray', 'start', '--head', '-vvv', '--port', self.ray_port, '--redis-password', self.redis_pass, '--include-dashboard', 'false'], stdout=subprocess.PIPE) print(output.stdout.decode("utf-8")) ray.init(address="auto", include_dashboard=False) self._wait_for_workers() print("All workers present and accounted for") print(ray.cluster_resources()) else: # If the current host is not the head node, # run `ray start` with specifying ip address as the head_host as the head node time.sleep(10) output = subprocess.run(['ray', 'start', f"--address={head_ip}:{self.ray_port}", '--redis-password', self.redis_pass, "--block"], stdout=subprocess.PIPE) print(output.stdout.decode("utf-8")) sys.exit(0)

När ett träningsjobb startas kan ett Ray-kluster initieras genom att anropa start_ray() metod på en instans av RayHelper:

if __name__ == '__main__': ray_helper = RayHelper() ray_helper.start_ray() args = read_parameters() sess = sagemaker.Session(boto3.Session(region_name=args.region))

Vi använder sedan XGBoost-tränaren från XGBoost-Ray för träning:

def train_xgboost(ds_train, ds_val, params, num_workers, target_col = "price") -> Result: """ Creates a XGBoost trainer, train it, and return the result. Args: ds_train (ray.data.dataset): Training dataset ds_val (ray.data.dataset): Validation dataset params (dict): Hyperparameters num_workers (int): number of workers to distribute the training across target_col (str): target column Returns: result (ray.air.result.Result): Result of the training job """ train_set = RayDMatrix(ds_train, 'PRICE') val_set = RayDMatrix(ds_val, 'PRICE') evals_result = {} trainer = train( params=params, dtrain=train_set, evals_result=evals_result, evals=[(val_set, "validation")], verbose_eval=False, num_boost_round=100, ray_params=RayParams(num_actors=num_workers, cpus_per_actor=1), ) output_path=os.path.join(args.model_dir, 'model.xgb') trainer.save_model(output_path) valMAE = evals_result["validation"]["mae"][-1] valRMSE = evals_result["validation"]["rmse"][-1] print('[3] #011validation-mae:{}'.format(valMAE)) print('[4] #011validation-rmse:{}'.format(valRMSE)) local_testing = False try: load_run(sagemaker_session=sess) except: local_testing = True if not local_testing: # Track experiment if using SageMaker Training with load_run(sagemaker_session=sess) as run: run.log_metric('validation-mae', valMAE) run.log_metric('validation-rmse', valRMSE)

Observera att när du instansierar trainer, vi passerar RayParams, som tar antalet skådespelare och antal processorer per skådespelare. XGBoost-Ray använder denna information för att fördela träningen över alla noder kopplade till Ray-klustret.

Vi skapar nu ett XGBoost-estimatorobjekt baserat på SageMaker Python SDK och använder det för HPO-jobbet.

Ordna de föregående stegen med SageMaker Pipelines

För att bygga ett skalbart och återanvändbart ML-arbetsflöde från början till slut måste vi använda ett CI/CD-verktyg för att orkestrera de föregående stegen i en pipeline. SageMaker Pipelines har direkt integration med SageMaker, SageMaker Python SDK och SageMaker Studio. Denna integration låter dig skapa ML-arbetsflöden med en lättanvänd Python SDK och sedan visualisera och hantera ditt arbetsflöde med SageMaker Studio. Du kan också spåra historiken för dina data inom pipelineexekveringen och ange steg för cachning.

SageMaker Pipelines skapar en Directed Acyclic Graph (DAG) som inkluderar steg som behövs för att bygga ett ML-arbetsflöde. Varje pipeline är en serie sammanlänkade steg orkestrerade av databeroende mellan stegen och kan parametriseras, så att du kan tillhandahålla indatavariabler som parametrar för varje körning av pipelinen. SageMaker Pipelines har fyra typer av pipelineparametrar: ParameterString, ParameterInteger, ParameterFloatoch ParameterBoolean. I det här avsnittet parametriserar vi några av indatavariablerna och ställer in steg-cachekonfigurationen:

processing_instance_count = ParameterInteger( name='ProcessingInstanceCount', default_value=1
)
feature_group_name = ParameterString( name='FeatureGroupName', default_value='fs-ray-synthetic-housing-data'
)
bucket_prefix = ParameterString( name='Bucket_Prefix', default_value='aws-ray-mlops-workshop/feature-store'
)
rmse_threshold = ParameterFloat(name="RMSEThreshold", default_value=15000.0) train_size = ParameterString( name='TrainSize', default_value="0.6"
)
val_size = ParameterString( name='ValidationSize', default_value="0.2"
)
test_size = ParameterString( name='TestSize', default_value="0.2"
) cache_config = CacheConfig(enable_caching=True, expire_after="PT12H")

Vi definierar två bearbetningssteg: ett för SageMaker Feature Store-intag, det andra för databeredning. Detta bör likna de tidigare stegen som beskrivits tidigare. Den enda nya kodraden är ProcessingStep efter stegens definition, vilket gör att vi kan ta bearbetningsjobbets konfiguration och inkludera den som ett pipelinesteg. Vi specificerar vidare beroendet av databeredningssteget på SageMaker Feature Store-intagssteget. Se följande kod:

feature_store_ingestion_step = ProcessingStep( name='FeatureStoreIngestion', step_args=fs_processor_args, cache_config=cache_config
) preprocess_dataset_step = ProcessingStep( name='PreprocessData', step_args=processor_args, cache_config=cache_config
)
preprocess_dataset_step.add_depends_on([feature_store_ingestion_step])

På liknande sätt, för att bygga ett modelltränings- och inställningssteg, måste vi lägga till en definition av TuningStep efter modellträningsstegets kod för att tillåta oss att köra SageMaker hyperparameterjustering som ett steg i pipelinen:

tuning_step = TuningStep( name="HPTuning", tuner=tuner, inputs={ "train": TrainingInput( s3_data=preprocess_dataset_step.properties.ProcessingOutputConfig.Outputs[ "train" ].S3Output.S3Uri, content_type="text/csv" ), "validation": TrainingInput( s3_data=preprocess_dataset_step.properties.ProcessingOutputConfig.Outputs[ "validation" ].S3Output.S3Uri, content_type="text/csv" ) }, cache_config=cache_config,
)
tuning_step.add_depends_on([preprocess_dataset_step])

Efter trimningssteget väljer vi att registrera den bästa modellen i SageMaker Model Registry. För att kontrollera modellkvaliteten implementerar vi en minimikvalitetsgrind som jämför den bästa modellens objektiva mätvärde (RMSE) mot en tröskel som definieras som pipelinens indataparameter rmse_threshold. För att göra denna utvärdering skapar vi ytterligare ett bearbetningssteg för att köra en utvärderingsmanus. Resultatet av modellutvärderingen kommer att lagras som en egenskapsfil. Egenskapsfiler är särskilt användbara när man analyserar resultaten av ett bearbetningssteg för att bestämma hur andra steg ska köras. Se följande kod:

# Specify where we'll store the model evaluation results so that other steps can access those results
evaluation_report = PropertyFile( name='EvaluationReport', output_name='evaluation', path='evaluation.json',
) # A ProcessingStep is used to evaluate the performance of a selected model from the HPO step. # In this case, the top performing model is evaluated. evaluation_step = ProcessingStep( name='EvaluateModel', processor=evaluation_processor, inputs=[ ProcessingInput( source=tuning_step.get_top_model_s3_uri( top_k=0, s3_bucket=bucket, prefix=s3_prefix ), destination='/opt/ml/processing/model', ), ProcessingInput( source=preprocess_dataset_step.properties.ProcessingOutputConfig.Outputs['test'].S3Output.S3Uri, destination='/opt/ml/processing/test', ), ], outputs=[ ProcessingOutput( output_name='evaluation', source='/opt/ml/processing/evaluation' ), ], code='./pipeline_scripts/evaluate/script.py', property_files=[evaluation_report],
)

Vi definierar en ModelStep för att registrera den bästa modellen i SageMaker Model Registry i vår pipeline. Om den bästa modellen inte klarar vår förutbestämda kvalitetskontroll, specificerar vi dessutom en FailStep för att mata ut ett felmeddelande:

register_step = ModelStep( name='RegisterTrainedModel', step_args=model_registry_args
) metrics_fail_step = FailStep( name="RMSEFail", error_message=Join(on=" ", values=["Execution failed due to RMSE >", rmse_threshold]),
)

Därefter använder vi en ConditionStep för att utvärdera om modellregistreringssteget eller felsteget ska tas nästa gång i pipelinen. I vårt fall kommer den bästa modellen att registreras om dess RMSE-poäng är lägre än tröskeln.

# Condition step for evaluating model quality and branching execution
cond_lte = ConditionLessThanOrEqualTo( left=JsonGet( step_name=evaluation_step.name, property_file=evaluation_report, json_path='regression_metrics.rmse.value', ), right=rmse_threshold,
)
condition_step = ConditionStep( name='CheckEvaluation', conditions=[cond_lte], if_steps=[register_step], else_steps=[metrics_fail_step],
)

Slutligen orkestrerar vi alla definierade steg i en pipeline:

pipeline_name = 'synthetic-housing-training-sm-pipeline-ray'
step_list = [ feature_store_ingestion_step, preprocess_dataset_step, tuning_step, evaluation_step, condition_step ] training_pipeline = Pipeline( name=pipeline_name, parameters=[ processing_instance_count, feature_group_name, train_size, val_size, test_size, bucket_prefix, rmse_threshold ], steps=step_list
) # Note: If an existing pipeline has the same name it will be overwritten.
training_pipeline.upsert(role_arn=role_arn)

Föregående pipeline kan visualiseras och exekveras direkt i SageMaker Studio, eller exekveras genom att anropa execution = training_pipeline.start(). Följande figur illustrerar rörledningsflödet.

Dessutom kan vi granska linjen av artefakter som genereras av pipelineexekveringen.

from sagemaker.lineage.visualizer import LineageTableVisualizer viz = LineageTableVisualizer(sagemaker.session.Session())
for execution_step in reversed(execution.list_steps()): print(execution_step) display(viz.show(pipeline_execution_step=execution_step)) time.sleep(5)

Distribuera modellen

Efter att den bästa modellen har registrerats i SageMaker Model Registry via en pipelinekörning, distribuerar vi modellen till en realtidsslutpunkt genom att använda SageMakers fullt hanterade modelldistributionsmöjligheter. SageMaker har andra modelldistributionsalternativ för att möta behoven i olika användningsfall. För detaljer, se Distribuera modeller för slutledning när du väljer rätt alternativ för ditt användningsfall. Låt oss först få modellen registrerad i SageMaker Model Registry:

xgb_regressor_model = ModelPackage( role_arn, model_package_arn=model_package_arn, name=model_name
)

Modellens nuvarande status är PendingApproval. Vi måste ställa in dess status till Approved före implementering:

sagemaker_client.update_model_package( ModelPackageArn=xgb_regressor_model.model_package_arn, ModelApprovalStatus='Approved'
) xgb_regressor_model.deploy( initial_instance_count=1, instance_type='ml.m5.xlarge', endpoint_name=endpoint_name
)

Städa upp

När du är klar med experimentet, kom ihåg att rensa resurserna för att undvika onödiga avgifter. För att rensa bort, radera realtidsslutpunkten, modellgruppen, pipeline och funktionsgruppen genom att anropa API:erna Ta bort slutpunkt, Ta bortModelPackageGroup, DeletePipelineoch DeleteFeatureGroup, respektive, och stäng av alla SageMaker Studio-anteckningsbokinstanser.

Slutsats

Det här inlägget demonstrerade en steg-för-steg-genomgång om hur man använder SageMaker Pipelines för att orkestrera Ray-baserade ML-arbetsflöden. Vi visade också förmågan hos SageMaker Pipelines att integrera med tredjeparts ML-verktyg. Det finns olika AWS-tjänster som stödjer Ray-arbetsbelastningar på ett skalbart och säkert sätt för att säkerställa hög prestanda och operativ effektivitet. Nu är det din tur att utforska dessa kraftfulla funktioner och börja optimera dina arbetsflöden för maskininlärning med Amazon SageMaker Pipelines och Ray. Vidta åtgärder idag och lås upp den fulla potentialen i dina ML-projekt!

---

Om författaren

Raju Rangan är Senior Solutions Architect på Amazon Web Services (AWS). Han arbetar med statligt sponsrade enheter och hjälper dem att bygga AI/ML-lösningar med hjälp av AWS. När du inte pysslar med molnlösningar får du se honom umgås med familjen eller slå birdies i en livlig omgång badminton med vänner.

Sherry Ding är en senior AI/ML-specialistlösningsarkitekt på Amazon Web Services (AWS). Hon har lång erfarenhet av maskininlärning med en doktorsexamen i datavetenskap. Hon arbetar främst med kunder inom den offentliga sektorn med olika AI/ML-relaterade affärsutmaningar, och hjälper dem att påskynda sin maskininlärningsresa i AWS-molnet. När hon inte hjälper kunder tycker hon om utomhusaktiviteter.

• SEO-drivet innehåll och PR-distribution. Bli förstärkt idag.
• PlatoData.Network Vertical Generative Ai. Styrka dig själv. Tillgång här.
• PlatoAiStream. Web3 Intelligence. Kunskap förstärkt. Tillgång här.
• Platoesg. Kol, CleanTech, Energi, Miljö, Sol, Avfallshantering. Tillgång här.
• PlatoHealth. Biotech och kliniska prövningar Intelligence. Tillgång här.
• BlockOffsets. Modernisera miljökompensation ägande. Tillgång här.
• Källa: https://aws.amazon.com/blogs/machine-learning/orchestrate-ray-based-machine-learning-workflows-using-amazon-sagemaker/