Nu machine learning (ML) mainstream wordt en breder wordt toegepast, worden door ML aangedreven inferentietoepassingen steeds gebruikelijker om een ​​reeks complexe zakelijke problemen op te lossen. De oplossing voor deze complexe bedrijfsproblemen vereist vaak het gebruik van meerdere ML-modellen en -stappen. In dit bericht ziet u hoe u een ML-toepassing bouwt en host met aangepaste containers ingeschakeld Amazon Sage Maker.

Amazon SageMaker-aanbiedingen ingebouwde algoritmen en vooraf gebouwde SageMaker docker-images voor modelimplementatie. Maar als deze niet aan uw behoeften voldoen, kunt u uw eigen containers (BYOC) meenemen voor hosting op Amazon SageMaker.

Er zijn verschillende gebruiksscenario's waarbij gebruikers mogelijk BYOC nodig hebben voor hosting op Amazon SageMaker.

1. Aangepaste ML-frameworks of bibliotheken: als u van plan bent een ML-framework of bibliotheken te gebruiken die niet worden ondersteund door de ingebouwde algoritmen of vooraf gebouwde containers van Amazon SageMaker, dan moet u een aangepaste container maken.
2. Gespecialiseerde modellen: voor bepaalde domeinen of sectoren heb je mogelijk specifieke modelarchitecturen of op maat gemaakte voorverwerkingsstappen nodig die niet beschikbaar zijn in het ingebouwde Amazon SageMaker-aanbod.
3. Eigen algoritmen: als je je eigen eigen algoritmen intern hebt ontwikkeld, heb je een aangepaste container nodig om ze op Amazon SageMaker te implementeren.
4. Complexe inferentiepijplijnen: Als uw ML-inferentieworkflow gebruik maakt van aangepaste bedrijfslogica (een reeks complexe stappen die in een bepaalde volgorde moeten worden uitgevoerd), kan BYOC u helpen deze stappen efficiënter te beheren en te orkestreren.

Overzicht oplossingen

In deze oplossing laten we zien hoe u een seriële ML-inferentietoepassing op Amazon SageMaker kunt hosten met realtime eindpunten met behulp van twee aangepaste inferentiecontainers met de nieuwste scikit-learn en xgboost pakketjes.

De eerste container maakt gebruik van een scikit-learn model om onbewerkte gegevens om te zetten in uitgelichte kolommen. Het is van toepassing Standaardscaler voor numerieke kolommen en OneHotEncoder naar categorische.

De tweede container herbergt een voorgetraind XGboost model (dwz voorspeller). Het voorspellermodel accepteert de aanbevolen invoer- en uitvoervoorspellingen.

Als laatste zetten we de featurerizer en voorspeller in een pijplijn voor seriële inferentie naar een realtime eindpunt van Amazon SageMaker.

Hier volgen enkele verschillende overwegingen waarom u mogelijk afzonderlijke containers wilt hebben binnen uw inferentietoepassing.

• Ontkoppeling – Verschillende stappen van de pijplijn hebben een duidelijk gedefinieerd doel en moeten vanwege de onderliggende afhankelijkheden op afzonderlijke containers worden uitgevoerd. Dit helpt ook om de pijplijn goed gestructureerd te houden.
• Frameworks – Verschillende stappen van de pijplijn gebruiken specifieke geschikte kaders (zoals scikit of Spark ML) en moeten daarom op afzonderlijke containers worden uitgevoerd.
• Isolatie van bronnen – Verschillende stappen van de pijplijn hebben verschillende vereisten voor het verbruik van hulpbronnen en moeten daarom op afzonderlijke containers worden uitgevoerd voor meer flexibiliteit en controle.
• Onderhoud en upgrades – Vanuit operationeel oogpunt bevordert dit de functionele isolatie en kun je individuele stappen veel gemakkelijker blijven upgraden of aanpassen, zonder dat dit gevolgen heeft voor andere modellen.

Bovendien helpt het lokaal bouwen van de individuele containers bij het iteratieve proces van ontwikkelen en testen met favoriete tools en Integrated Development Environments (IDE's). Zodra de containers klaar zijn, kunt u ze inzetten in de AWS-cloud voor gevolgtrekking met behulp van Amazon SageMaker-eindpunten.

Volledige implementatie, inclusief codefragmenten, is beschikbaar in deze Github-repository hier.

Voorwaarden

Omdat we deze aangepaste containers eerst lokaal testen, moeten we Docker Desktop op uw lokale computer installeren. U moet bekend zijn met het bouwen van Docker-containers.

Je hebt ook een AWS-account nodig met toegang tot Amazon SageMaker, Amazon ECR en Amazon S3 om deze applicatie end-to-end te testen.

Zorg ervoor dat u de nieuwste versie van Boto3 en de Amazon SageMaker Python-pakketten geïnstalleerd:

pip install --upgrade boto3 sagemaker scikit-learn

Oplossingsoverzicht

Bouw een aangepaste featurizer-container

Om de eerste container, de featurizer container, te bouwen, trainen we a scikit-learn model om onbewerkte functies in het abalone gegevensset. Het voorverwerkingsscript gebruikt SimpleImputer voor het verwerken van ontbrekende waarden, Standaardscaler voor het normaliseren van numerieke kolommen, en OneHotEncoder voor het transformeren van categorische kolommen. Na het plaatsen van de transformator slaan we het model op baanlib formaat. Vervolgens comprimeren en uploaden we dit opgeslagen modelartefact naar een Amazon Simple Storage Service (Amazon S3) emmer.

Hier is een voorbeeldcodefragment dat dit demonstreert. Verwijzen naar featurerizer.ipynb voor volledige implementatie:

```python
numeric_features = list(feature_columns_names)
numeric_features.remove("sex")
numeric_transformer = Pipeline( steps=[ ("imputer", SimpleImputer(strategy="median")), ("scaler", StandardScaler()), ]
) categorical_features = ["sex"]
categorical_transformer = Pipeline( steps=[ ("imputer", SimpleImputer(strategy="constant", fill_value="missing")), ("onehot", OneHotEncoder(handle_unknown="ignore")), ]
) preprocess = ColumnTransformer( transformers=[ ("num", numeric_transformer, numeric_features), ("cat", categorical_transformer, categorical_features), ]
) # Call fit on ColumnTransformer to fit all transformers to X, y
preprocessor = preprocess.fit(df_train_val) # Save the processor model to disk
joblib.dump(preprocess, os.path.join(model_dir, "preprocess.joblib"))
```

Om vervolgens een aangepaste inferentiecontainer voor het featurizer-model te maken, bouwen we een Docker-image met nginx-, gunicorn-, flask-pakketten, samen met andere vereiste afhankelijkheden voor het featurizer-model.

Nginx, gunicorn en de Flask-app zullen dienen als model-serveerstapel op realtime eindpunten van Amazon SageMaker.

Wanneer we aangepaste containers voor hosting op Amazon SageMaker aanbieden, moeten we ervoor zorgen dat het inferentiescript de volgende taken uitvoert nadat het in de container is gelanceerd:

1. Modelbelasting: Inferentiescript (preprocessing.py) zou moeten verwijzen /opt/ml/model map om het model in de container te laden. Modelartefacten in Amazon S3 worden gedownload en op de container op het pad gemonteerd /opt/ml/model.
2. Omgevingsvariabelen: Als u aangepaste omgevingsvariabelen wilt doorgeven aan de container, moet u deze opgeven tijdens de Model creatiestap of tijdens Endpoint creatie vanuit een trainingsbaan.
3. API-vereisten: Het Inference-script moet beide implementeren /ping en /invocations routes als een Flask-applicatie. De /ping API wordt gebruikt voor gezondheidscontroles, terwijl de /invocations API verwerkt gevolgtrekkingsverzoeken.
4. Logboekregistratie: Uitvoerlogboeken in het inferentiescript moeten naar standaarduitvoer worden geschreven (stdout) en standaardfout (stderr) stromen. Deze logboeken worden vervolgens gestreamd naar Amazon Cloud Watch door Amazon SageMaker.

Hier is een fragment van preprocessing.py die de uitvoering ervan laten zien /ping en /invocations.

Verwijzen naar voorbewerking.py onder de featurizer-map voor volledige implementatie.

```python
def load_model(): # Construct the path to the featurizer model file ft_model_path = os.path.join(MODEL_PATH, "preprocess.joblib") featurizer = None try: # Open the model file and load the featurizer using joblib with open(ft_model_path, "rb") as f: featurizer = joblib.load(f) print("Featurizer model loaded", flush=True) except FileNotFoundError: print(f"Error: Featurizer model file not found at {ft_model_path}", flush=True) except Exception as e: print(f"Error loading featurizer model: {e}", flush=True) # Return the loaded featurizer model, or None if there was an error return featurizer def transform_fn(request_body, request_content_type): """ Transform the request body into a usable numpy array for the model. This function takes the request body and content type as input, and returns a transformed numpy array that can be used as input for the prediction model. Parameters: request_body (str): The request body containing the input data. request_content_type (str): The content type of the request body. Returns: data (np.ndarray): Transformed input data as a numpy array. """ # Define the column names for the input data feature_columns_names = [ "sex", "length", "diameter", "height", "whole_weight", "shucked_weight", "viscera_weight", "shell_weight", ] label_column = "rings" # Check if the request content type is supported (text/csv) if request_content_type == "text/csv": # Load the featurizer model featurizer = load_model() # Check if the featurizer is a ColumnTransformer if isinstance( featurizer, sklearn.compose._column_transformer.ColumnTransformer ): print(f"Featurizer model loaded", flush=True) # Read the input data from the request body as a CSV file df = pd.read_csv(StringIO(request_body), header=None) # Assign column names based on the number of columns in the input data if len(df.columns) == len(feature_columns_names) + 1: # This is a labelled example, includes the ring label df.columns = feature_columns_names + [label_column] elif len(df.columns) == len(feature_columns_names): # This is an unlabelled example. df.columns = feature_columns_names # Transform the input data using the featurizer data = featurizer.transform(df) # Return the transformed data as a numpy array return data else: # Raise an error if the content type is unsupported raise ValueError("Unsupported content type: {}".format(request_content_type)) @app.route("/ping", methods=["GET"])
def ping(): # Check if the model can be loaded, set the status accordingly featurizer = load_model() status = 200 if featurizer is not None else 500 # Return the response with the determined status code return flask.Response(response="n", status=status, mimetype="application/json") @app.route("/invocations", methods=["POST"])
def invocations(): # Convert from JSON to dict print(f"Featurizer: received content type: {flask.request.content_type}") if flask.request.content_type == "text/csv": # Decode input data and transform input = flask.request.data.decode("utf-8") transformed_data = transform_fn(input, flask.request.content_type) # Format transformed_data into a csv string csv_buffer = io.StringIO() csv_writer = csv.writer(csv_buffer) for row in transformed_data: csv_writer.writerow(row) csv_buffer.seek(0) # Return the transformed data as a CSV string in the response return flask.Response(response=csv_buffer, status=200, mimetype="text/csv") else: print(f"Received: {flask.request.content_type}", flush=True) return flask.Response( response="Transformer: This predictor only supports CSV data", status=415, mimetype="text/plain", )
```

Bouw een Docker-image met featurizer en modelserving-stack

Laten we nu een Dockerfile bouwen met behulp van een aangepaste basisimage en de vereiste afhankelijkheden installeren.

Hiervoor gebruiken wij python:3.9-slim-buster als basisafbeelding. U kunt dit wijzigen in elke andere basisafbeelding die relevant is voor uw gebruiksscenario.

Vervolgens kopiëren we de nginx-configuratie, het gunicorn-webservergatewaybestand en het inferentiescript naar de container. We maken ook een Python-script genaamd serve dat nginx- en gunicorn-processen op de achtergrond start en het inferentiescript (dat wil zeggen preprocessing.py Flask-toepassing) instelt als het toegangspunt voor de container.

Hier is een fragment van het Dockerbestand voor het hosten van het featurizer-model. Voor volledige implementatie zie Dockerfile voor featurerizer map.

```docker
FROM python:3.9-slim-buster
… # Copy requirements.txt to /opt/program folder
COPY requirements.txt /opt/program/requirements.txt # Install packages listed in requirements.txt
RUN pip3 install --no-cache-dir -r /opt/program/requirements.txt # Copy contents of code/ dir to /opt/program
COPY code/ /opt/program/ # Set working dir to /opt/program which has the serve and inference.py scripts
WORKDIR /opt/program # Expose port 8080 for serving
EXPOSE 8080 ENTRYPOINT ["python"] # serve is a python script under code/ directory that launches nginx and gunicorn processes
CMD [ "serve" ]
```

Test de aangepaste gevolgtrekkingsafbeelding lokaal met featurizer

Bouw en test nu de aangepaste inferentiecontainer met featurizer lokaal, met behulp van Amazon SageMaker lokale modus. De lokale modus is perfect voor het testen van uw verwerkings-, training- en inferentiescripts zonder taken op Amazon SageMaker te starten. Nadat u de resultaten van uw lokale tests heeft bevestigd, kunt u de trainings- en inferentiescripts eenvoudig met minimale wijzigingen aanpassen voor implementatie op Amazon SageMaker.

Om de aangepaste imagerizer-image lokaal te testen, bouwt u eerst de image met behulp van de eerder gedefinieerde Dockerfile. Start vervolgens een container door de map te koppelen die het featurizer-model bevat (preprocess.joblib) naar de /opt/ml/model map in de container. Wijs bovendien poort 8080 toe van de container naar de host.

Eenmaal gelanceerd, kunt u gevolgtrekkingsverzoeken sturen naar http://localhost:8080/invocations.

Om de container te bouwen en te starten, opent u een terminal en voert u de volgende opdrachten uit.

Houd er rekening mee dat u de <IMAGE_NAME>, zoals weergegeven in de volgende code, met de afbeeldingsnaam van uw container.

Bij de volgende opdracht wordt er ook van uitgegaan dat het getraind scikit-learn model (preprocess.joblib) is aanwezig onder een map met de naam models.

```shell
docker build -t <IMAGE_NAME> .
``` ```shell
docker run –rm -v $(pwd)/models:/opt/ml/model -p 8080:8080 <IMAGE_NAME>
```

Nadat de container operationeel is, kunnen we beide testen /ping en /aanroepingen routes met behulp van curl-opdrachten.

Voer de onderstaande opdrachten uit vanaf een terminal

```shell
# test /ping route on local endpoint
curl http://localhost:8080/ping # send raw csv string to /invocations. Endpoint should return transformed data
curl --data-raw 'I,0.365,0.295,0.095,0.25,0.1075,0.0545,0.08,9.0' -H 'Content-Type: text/csv' -v http://localhost:8080/invocations
```

Wanneer ruwe (ongetransformeerde) gegevens worden verzonden naar http://localhost:8080/invocations, reageert het eindpunt met getransformeerde gegevens.

U zou een antwoord moeten zien dat lijkt op het volgende:

```shell
* Trying 127.0.0.1:8080...
* Connected to localhost (127.0.0.1) port 8080 (#0)
> POST /invocations HTTP/1.1
> Host: localhost: 8080
> User-Agent: curl/7.87.0
> Accept: */*
> Content -Type: text/csv
> Content -Length: 47
>
* Mark bundle as not supporting multiuse
> HTTP/1.1 200 OK
> Server: nginx/1.14.2
> Date: Sun, 09 Apr 2023 20:47:48 GMT
> Content -Type: text/csv; charset=utf-8
> Content -Length: 150
> Connection: keep -alive
-1.3317586042173168, -1.1425409076053987, -1.0579488602777858, -1.177706547272754, -1.130662184748842,
* Connection #0 to host localhost left intact
```

We beëindigen nu de actieve container en taggen en pushen vervolgens de lokale aangepaste afbeelding naar een privé Amazon Elastic Container Registry (Amazon ECR) opslagplaats.

Zie de volgende opdrachten om in te loggen bij Amazon ECR, die de lokale afbeelding tagt met het volledige Amazon ECR-afbeeldingspad en de afbeelding vervolgens naar Amazon ECR pusht. Zorg ervoor dat u vervangt region en account variabelen die bij uw omgeving passen.

```shell
# login to ecr with your credentials
aws ecr get-login-password - -region "${region}" |
docker login - -username AWS - -password-stdin ${account}".dkr.ecr."${region}".amazonaws.com # tag and push the image to private Amazon ECR
docker tag ${image} ${fullname}
docker push $ {fullname} ```

Verwijzen naar maak een opslagplaats en een afbeelding naar Amazon ECR pushen AWS-opdrachtregelinterface (AWS CLI) opdrachten voor meer informatie.

Optionele stap:

Optioneel kunt u een live test uitvoeren door het featurizer-model te implementeren op een realtime eindpunt met de aangepaste docker-image in Amazon ECR. Verwijzen naar featurerizer.ipynb notebook voor de volledige implementatie van het bouwen, testen en pushen van de aangepaste image naar Amazon ECR.

Amazon SageMaker initialiseert het inferentie-eindpunt en kopieert de modelartefacten naar het /opt/ml/model map in de container. Zien Hoe SageMaker uw modelartefacten laadt.

Bouw een aangepaste XGBoost-voorspellercontainer

Voor het bouwen van de XGBoost-inferentiecontainer volgen we soortgelijke stappen als bij het bouwen van de afbeelding voor de featurizer-container:

1. Vooraf getraind downloaden XGBoost model van Amazon S3.
2. Maak de inference.py script dat het vooraf getrainde bestand laadt XGBoost model, converteert de getransformeerde invoergegevens ontvangen van featurizer, en converteert naar XGBoost.DMatrix formaat, loopt predict op de booster en retourneert voorspellingen in json-indeling.
3. Scripts en configuratiebestanden die de modelservingstack vormen (dat wil zeggen nginx.conf, wsgi.py en serve blijven hetzelfde en behoeven geen wijziging.
4. Wij gebruiken Ubuntu:18.04 als basisimage voor het Dockerfile. Dit is geen voorwaarde. We gebruiken de ubuntu-basisimage om aan te tonen dat containers met elke basisimage kunnen worden gebouwd.
5. De stappen voor het bouwen van de klant-docker-image, het lokaal testen van de image en het pushen van de geteste image naar Amazon ECR blijven hetzelfde als voorheen.

Kortheidshalve, aangezien de stappen vergelijkbaar zijn zoals eerder getoond; hieronder tonen wij echter alleen de gewijzigde codering.

Ten eerste, de inference.py script. Hier is een fragment dat de implementatie laat zien van /ping en /invocations. Verwijzen naar gevolgtrekking.py onder de voorspeller map voor volledige implementatie van dit bestand.

```python
@app.route("/ping", methods=["GET"])
def ping(): """ Check the health of the model server by verifying if the model is loaded. Returns a 200 status code if the model is loaded successfully, or a 500 status code if there is an error. Returns: flask.Response: A response object containing the status code and mimetype. """ status = 200 if model is not None else 500 return flask.Response(response="n", status=status, mimetype="application/json") @app.route("/invocations", methods=["POST"])
def invocations(): """ Handle prediction requests by preprocessing the input data, making predictions, and returning the predictions as a JSON object. This function checks if the request content type is supported (text/csv; charset=utf-8), and if so, decodes the input data, preprocesses it, makes predictions, and returns the predictions as a JSON object. If the content type is not supported, a 415 status code is returned. Returns: flask.Response: A response object containing the predictions, status code, and mimetype. """ print(f"Predictor: received content type: {flask.request.content_type}") if flask.request.content_type == "text/csv; charset=utf-8": input = flask.request.data.decode("utf-8") transformed_data = preprocess(input, flask.request.content_type) predictions = predict(transformed_data) # Return the predictions as a JSON object return json.dumps({"result": predictions}) else: print(f"Received: {flask.request.content_type}", flush=True) return flask.Response( response=f"XGBPredictor: This predictor only supports CSV data; Received: {flask.request.content_type}", status=415, mimetype="text/plain", ) ```

Hier is een fragment van het Docker-bestand voor het hosten van het voorspellermodel. Voor volledige implementatie zie Dockerfile onder de map Voorspeller.

```docker
FROM ubuntu:18.04 … # install required dependencies including flask, gunicorn, xgboost etc.,
RUN pip3 --no-cache-dir install flask gunicorn gevent numpy pandas xgboost # Copy contents of code/ dir to /opt/program
COPY code /opt/program # Set working dir to /opt/program which has the serve and inference.py scripts
WORKDIR /opt/program # Expose port 8080 for serving
EXPOSE 8080 ENTRYPOINT ["python"] # serve is a python script under code/ directory that launches nginx and gunicorn processes
CMD ["serve"]
```

Vervolgens gaan we door met het bouwen, testen en pushen van dit aangepaste voorspellerimage naar een privérepository in Amazon ECR. Verwijzen naar voorspeller.ipynb notebook voor volledige implementatie van het bouwen, testen en pushen van de aangepaste image naar Amazon ECR.

Implementeer een pijplijn voor seriële inferentie

Nadat we zowel de featurizer- als de voorspellende afbeeldingen hebben getest en naar Amazon ECR hebben gepusht, uploaden we nu onze modelartefacten naar een Amazon S3-bucket.

Vervolgens maken we twee modelobjecten: één voor de featurizer (d.w.z, preprocess.joblib) en andere voor de predictor (d.w.z, xgboost-model) door de aangepaste afbeeldings-uri op te geven die we eerder hebben gebouwd.

Hier is een fragment dat dat laat zien. Verwijzen naar seriële-inferentie-pipeline.ipynb voor volledige implementatie.

```python
suffix = f"{str(uuid4())[:5]}-{datetime.now().strftime('%d%b%Y')}" # Featurizer Model (SKLearn Model)
image_name = "<FEATURIZER_IMAGE_NAME>"
sklearn_image_uri = f"{account_id}.dkr.ecr.{region}.amazonaws.com/{image_name}:latest" featurizer_model_name = f""<FEATURIZER_MODEL_NAME>-{suffix}"
print(f"Creating Featurizer model: {featurizer_model_name}")
sklearn_model = Model( image_uri=featurizer_ecr_repo_uri, name=featurizer_model_name, model_data=featurizer_model_data, role=role,
) # Full name of the ECR repository
predictor_image_name = "<PREDICTOR_IMAGE_NAME>"
predictor_ecr_repo_uri
= f"{account_id}.dkr.ecr.{region}.amazonaws.com/{predictor_image_name}:latest" # Predictor Model (XGBoost Model)
predictor_model_name = f"""<PREDICTOR_MODEL_NAME>-{suffix}"
print(f"Creating Predictor model: {predictor_model_name}")
xgboost_model = Model( image_uri=predictor_ecr_repo_uri, name=predictor_model_name, model_data=predictor_model_data, role=role,
)
```

Om deze containers serieel in te zetten, maken we eerst een PijpleidingModel object en geef de . door featurizer model en de predictor model naar een Python-lijstobject in dezelfde volgorde.

Vervolgens bellen wij met de .deploy() methode op de PijpleidingModel waarbij het exemplaartype en het aantal exemplaren worden opgegeven.

```python
from sagemaker.pipeline import PipelineModel pipeline_model_name = f"Abalone-pipeline-{suffix}" pipeline_model = PipelineModel( name=pipeline_model_name, role=role, models=[sklearn_model, xgboost_model], sagemaker_session=sm_session,
) print(f"Deploying pipeline model {pipeline_model_name}...")
predictor = pipeline_model.deploy( initial_instance_count=1, instance_type="ml.m5.xlarge",
)
```

In dit stadium implementeert Amazon SageMaker de pijplijn voor seriële inferentie naar een realtime eindpunt. We wachten tot het eindpunt is bereikt InService.

We kunnen het eindpunt nu testen door enkele gevolgtrekkingsverzoeken naar dit live-eindpunt te sturen.

Verwijzen naar seriële-inferentie-pipeline.ipynb voor volledige implementatie.

Opruimen

Nadat u klaar bent met testen, volgt u de instructies in het opruimgedeelte van het notitieblok om de bronnen in dit bericht te verwijderen om onnodige kosten te voorkomen. Verwijzen naar Amazon SageMaker-prijzen voor meer informatie over de kosten van de gevolgtrekkingsinstanties.

```python
# Delete endpoint, model
try: print(f"Deleting model: {pipeline_model_name}") predictor.delete_model()
except Exception as e: print(f"Error deleting model: {pipeline_model_name}n{e}") pass try: print(f"Deleting endpoint: {endpoint_name}") predictor.delete_endpoint()
except Exception as e: print(f"Error deleting EP: {endpoint_name}n{e}") pass ```

Conclusie

In dit bericht liet ik zien hoe we een seriële ML-inferentietoepassing kunnen bouwen en implementeren met behulp van aangepaste inferentiecontainers voor realtime eindpunten op Amazon SageMaker.

Deze oplossing laat zien hoe klanten op een kostenefficiënte manier hun eigen aangepaste containers kunnen meenemen voor hosting op Amazon SageMaker. Met de BYOC-optie kunnen klanten snel hun ML-applicaties bouwen en aanpassen voor implementatie op Amazon SageMaker.

We raden u aan deze oplossing uit te proberen met een dataset die relevant is voor de Key Performance Indicators (KPI's) van uw bedrijf. Hierin kunt u de gehele oplossing raadplegen GitHub-repository.

Referenties

Over de auteur

Praveen Chamarthi is een Senior AI/ML-specialist bij Amazon Web Services. Hij is gepassioneerd door AI/ML en alles wat met AWS te maken heeft. Hij helpt klanten in heel Amerika om ML-workloads efficiënt op AWS te schalen, te innoveren en uit te voeren. In zijn vrije tijd houdt Praveen van lezen en geniet hij van sciencefictionfilms.

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• PlatoData.Network Verticale generatieve AI. Versterk jezelf. Toegang hier.
• PlatoAiStream. Web3-intelligentie. Kennis versterkt. Toegang hier.
• PlatoESG. carbon, CleanTech, Energie, Milieu, Zonne, Afvalbeheer. Toegang hier.
• Plato Gezondheid. Intelligentie op het gebied van biotech en klinische proeven. Toegang hier.
• Bron: https://aws.amazon.com/blogs/machine-learning/build-and-deploy-ml-inference-applications-from-scratch-using-amazon-sagemaker/