Customise Amazon Nova in Amazon SageMaker AI utilizing Direct Desire Optimization

On the AWS Summit in New York City, we launched a comprehensive suite of model customization capabilities for Amazon Nova basis fashions. Obtainable as ready-to-use recipes on Amazon SageMaker AI, you should utilize them to adapt Nova Micro, Nova Lite, and Nova Professional throughout the mannequin coaching lifecycle, together with pre-training, supervised fine-tuning, and alignment.

On this multi-post collection, we are going to discover these customization recipes and supply a step-by-step implementation information. We’re beginning with Direct Desire Optimization (DPO, an alignment method that provides a simple approach to tune mannequin outputs along with your preferences. DPO makes use of prompts paired with two responses—one most popular over the opposite—to information the mannequin towards outputs that higher replicate your required tone, type, or pointers. You may implement this method utilizing both parameter-efficient or full mannequin DPO, based mostly in your information quantity and price concerns. The personalized fashions may be deployed to Amazon Bedrock for inference utilizing provisioned throughput. The parameter-efficient model helps on-demand inference. Nova customization recipes can be found in SageMaker training jobs and SageMaker HyperPod, providing you with flexibility to pick the setting that most closely fits your infrastructure and scale necessities.

On this put up, we current a streamlined strategy to customizing Amazon Nova Micro with SageMaker coaching jobs.

Resolution overview

The workflow for utilizing Amazon Nova recipes with SageMaker coaching jobs, as illustrated within the accompanying diagram, consists of the next steps:

1. The consumer selects a selected Nova customization recipe which gives complete configurations to manage Amazon Nova coaching parameters, mannequin settings, and distributed coaching methods. You should use the default configurations optimized for the SageMaker AI setting or customise them to experiment with completely different settings.
2. The consumer submits an API request to the SageMaker AI management airplane, passing the Amazon Nova recipe configuration.
3. SageMaker makes use of the coaching job launcher script to run the Nova recipe on a managed compute cluster.
4. Based mostly on the chosen recipe, SageMaker AI provisions the required infrastructure, orchestrates distributed coaching, and, upon completion, robotically decommissions the cluster.

This streamlined structure delivers a totally managed consumer expertise, so you’ll be able to rapidly outline Amazon Nova coaching parameters and choose your most popular infrastructure utilizing easy recipes, whereas SageMaker AI handles the end-to-end infrastructure administration—inside a pay-as-you-go pricing mannequin that’s solely billed for the web coaching time in seconds.

The personalized Amazon Nova mannequin is subsequently deployed on Amazon Bedrock utilizing the createcustommodel API inside Bedrock – and might combine with native tooling equivalent to Amazon Bedrock Knowledge Bases, Amazon Bedrock Guardrails, and Amazon Bedrock Agents.

Enterprise Use Case – Implementation Stroll-through

On this put up, we deal with adapting the Amazon Nova Micro mannequin to optimize structured perform calling for application-specific agentic workflows. We exhibit how this strategy can optimize Amazon Nova fashions for domain-specific use circumstances by a 81% improve in F1 rating and as much as 42% positive factors in ROUGE metrics. These enhancements make the fashions extra environment friendly in addressing a wide selection of enterprise functions, equivalent to enabling buyer assist AI assistants to intelligently escalate queries, powering digital assistants for scheduling and workflow automation, and automating decision-making in sectors like ecommerce and monetary companies.

As proven within the following diagram, our strategy makes use of DPO to align the Amazon Nova mannequin with human preferences by presenting the mannequin with pairs of responses—one most popular by human annotators and one much less most popular—based mostly on a given consumer question and accessible software actions. The mannequin is educated with the nvidia/When2Call dataset to extend the chance of the tool_call response, which aligns with the enterprise objective of automating backend actions when applicable. Over many such examples, the Amazon Nova mannequin learns not simply to generate right function-calling syntax, but in addition to make nuanced choices about when and methods to invoke instruments in advanced workflows—bettering its utility in enterprise functions like buyer assist automation, workflow orchestration, and clever digital assistants.

When coaching is full, we consider the fashions utilizing SageMaker coaching jobs with the suitable analysis recipe. An analysis recipe is a YAML configuration file that defines how your Amazon Nova massive language mannequin (LLM) analysis job can be executed. Utilizing this analysis recipe, we measure each the mannequin’s task-specific efficiency and its alignment with the specified agent behaviors, so we are able to quantitatively assess the effectiveness of our customization strategy. The next diagram illustrates how these levels may be carried out as two separate coaching job steps. For every step, we use built-in integration with Amazon CloudWatch to entry logs and monitor system metrics, facilitating strong observability. After the mannequin is educated and evaluated, we deploy the mannequin utilizing the Amazon Bedrock Customized Mannequin Import performance as a part of step 3.

Stipulations

You have to full the next stipulations earlier than you’ll be able to run the Amazon Nova Micro mannequin fine-tuning pocket book:

1. Make the next quota increase requests for SageMaker AI. For this use case, you will have to request a minimal of two p5.48xlarge occasion (with 8 x NVIDIA H100 GPUs) and scale to extra p5.48xlarge cases (relying on time-to-train and cost-to-train trade-offs in your use case). On the Service Quotas console, request the next SageMaker AI quotas:
   • P5 cases (p5.48xlarge) for coaching job utilization: 2
2. (Elective) You may create an Amazon SageMaker Studio area (check with Use quick setup for Amazon SageMaker AI) to entry Jupyter notebooks with the previous position. (You should use JupyterLab in your native setup, too.)
3. Create an AWS Identity and Access Management (IAM) role with managed insurance policies AmazonSageMakerFullAccess, AmazonS3FullAccess, and AmazonBedrockFullAccess to offer required entry to SageMaker AI and Amazon Bedrock to run the examples.
4. Assign the next coverage because the trust relationship to your IAM position:

{
    "Model": "2012-10-17",
    "Assertion": [
        {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
                "Service": [
                    "bedrock.amazonaws.com",
                    "sagemaker.amazonaws.com"
                ]
            },
            "Motion": "sts:AssumeRole"
        }
    ]
}

3. Clone the GitHub repository with the belongings for this deployment. This repository consists of a pocket book that references coaching belongings:

   git clone https://github.com/aws-samples/sagemaker-distributed-training-workshop.git
   
   cd sagemaker-distributed-training-workshop/18_sagemaker_training_recipes/nova

Subsequent, we run the pocket book nova-micro-dpo-peft.ipynb to fine-tune the Amazon Nova mannequin utilizing DPO, and PEFT on SageMaker coaching jobs.

Put together the dataset

To arrange the dataset, you might want to load the nvidia/When2Call dataset. This dataset gives synthetically generated consumer queries, software choices, and annotated preferences based mostly on actual eventualities, to coach and consider AI assistants on making optimum tool-use choices in multi-step eventualities.

Full the next steps to format the enter in a chat completion format, and configure the information channels for SageMaker coaching jobs on Amazon Simple Storage Service (Amazon S3):

1. Load the nvidia/When2Call dataset:

from datasets import load_dataset
dataset = load_dataset("nvidia/When2Call", "train_pref", cut up="prepare")

The DPO method requires a dataset containing the next:

• Person prompts (e.g., “Write an expert e-mail asking for a elevate”)
• Most popular outputs (preferrred responses)
• Non-preferred outputs (undesirable responses)

The next code is an instance from the unique dataset:

2. As a part of information preprocessing, we convert the information into the format required by Amazon Nova Micro, as proven within the following code. For examples and particular constraints of the Amazon Nova format, see Preparing data for fine-tuning Understanding models.

For the total information conversion code, see here.

3. Cut up the dataset into prepare and take a look at datasets:

from datasets import Dataset, DatasetDict
from random import randint

...

dataset = DatasetDict(
    {"prepare": train_dataset, "take a look at": test_dataset, "val": val_dataset}
)
train_dataset = dataset["train"].map(
    prepare_dataset, remove_columns=train_dataset.options
)

test_dataset = dataset["test"].map(
    prepare_dataset, remove_columns=test_dataset.options
)

4. Put together the coaching and take a look at datasets for the SageMaker coaching job by saving them as .jsonl information, which is required by SageMaker HyperPod recipes for Amazon Nova, and setting up the Amazon S3 paths the place these information can be uploaded:

...

train_dataset.to_json("./information/prepare/dataset.jsonl")
test_dataset.to_json("./information/take a look at/dataset.jsonl")


s3_client.upload_file(
    "./information/prepare/dataset.jsonl", bucket_name, f"{input_path}/prepare/dataset.jsonl"
)
s3_client.upload_file(
    "./information/take a look at/dataset.jsonl", bucket_name, f"{input_path}/take a look at/dataset.jsonl"
)

DPO coaching utilizing SageMaker coaching jobs

To fine-tune the mannequin utilizing DPO and SageMaker coaching jobs with recipes, we use the PyTorch Estimator class. Begin by setting the fine-tuning workload with the next steps:

1. Choose the occasion sort and the container picture for the coaching job:

instance_type = "ml.p5.48xlarge" 
instance_count = 2

image_uri = (
    f"708977205387.dkr.ecr.{sagemaker_session.boto_session.region_name}.amazonaws.com/nova-fine-tune-repo:SM-TJ-DPO-latest"
)

2. Create the PyTorch Estimator to encapsulate the coaching setup from a particular Amazon Nova recipe:

from sagemaker.pytorch import PyTorch

# outline Coaching Job Identify
job_name = "train-nova-micro-dpo"

recipe_overrides = {
    "training_config": {
        "coach": {"max_epochs": 1},
        "mannequin": {
            "dpo_cfg": {"beta": 0.1},
            "peft": {
                "peft_scheme": "lora",
                "lora_tuning": {
                    "loraplus_lr_ratio": 16.0,
                    "alpha": 128,
                    "adapter_dropout": 0.01,
                },
            },
        },
    },
}

estimator = PyTorch(
    output_path=f"s3://{bucket_name}/{job_name}",
    base_job_name=job_name,
    position=position,
    instance_count=instance_count,
    instance_type=instance_type,
    training_recipe=recipe,
    recipe_overrides=recipe_overrides,
    max_run=18000,
    sagemaker_session=sess,
    image_uri=image_uri,
    disable_profiler=True,
    debugger_hook_config=False,
)

You may level to the precise recipe with the training_recipe parameter and override the recipe by offering a dictionary as recipe_overrides parameter.

The PyTorch Estimator class simplifies the expertise by encapsulating code and coaching setup instantly from the chosen recipe.

On this instance, training_recipe: fine-tuning/nova/dpo-peft-nova-micro-v1 is defining the DPO fine-tuning setup with PEFT method

3. Arrange the enter channels for the PyTorch Estimator by creating an TrainingInput objects from the offered S3 bucket paths for the coaching and take a look at datasets:

from sagemaker.inputs import TrainingInput

train_input = TrainingInput(
    s3_data=train_dataset_s3_path,
    distribution="FullyReplicated",
    s3_data_type="Converse",
)
test_input = TrainingInput(
    s3_data=test_dataset_s3_path,
    distribution="FullyReplicated",
    s3_data_type="Converse",
)

4. Submit the coaching job utilizing the match perform name on the created Estimator:

estimator.match(inputs={"prepare": train_input, "validation": test_input}, wait=True)

You may monitor the job instantly out of your pocket book output. You can even refer the SageMaker AI console, which reveals the standing of the job and the corresponding CloudWatch logs for governance and observability, as proven within the following screenshots.

SageMaker coaching jobs console

SageMaker coaching jobs system metrics

After the job is full, the educated mannequin weights can be accessible in an escrow S3 bucket. This safe bucket is managed by Amazon and makes use of particular entry controls. You may entry the paths shared in manifest information which might be saved in a buyer S3 bucket as a part of the coaching course of.

Consider the fine-tuned mannequin utilizing the analysis recipe

To evaluate mannequin efficiency towards benchmarks or {custom} datasets, we are able to use the Nova analysis recipes and SageMaker coaching jobs to execute an analysis workflow, by pointing to the mannequin educated within the earlier step. Amongst a number of supported benchmarks, equivalent to mmlu, math, gen_qa, and llm_judge, within the following steps we’re going to present two choices for  gen_qa and llm_judge duties, which permit us to guage response accuracy, precision and mannequin inference high quality with the chance to make use of our personal dataset and evaluate outcomes with the bottom mannequin on Amazon Bedrock.

Possibility A: Consider gen_qa activity

1. Use the code within the to arrange the dataset, structured within the following format as required by the analysis recipe:

{
    "system": "(Elective) String containing the system immediate that units the conduct, position, or character of the mannequin",
    "question": "String containing the enter immediate",
    "response": "String containing the anticipated mannequin output"
}

2. Save the dataset as .jsonl information, which is required by Amazon Nova analysis recipes, and add them to the Amazon S3 path:

# Save datasets to s3
val_dataset.to_json("./information/val/gen_qa.jsonl")

s3_client.upload_file(
    "./information/val/gen_qa.jsonl", bucket_name, f"{input_path}/val/gen_qa.jsonl"
)
...

3. Create the analysis recipe pointing to educated mannequin, validation information, and the analysis metrics relevant to your use case:

model_path = ""

recipe_content = f"""
run:
  identify: nova-micro-gen_qa-eval-job
  model_type: amazon.nova-micro-v1:0:128k
  model_name_or_path: {model_path}
  replicas: 1
  data_s3_path: {val_dataset_s3_path} # Required, enter information s3 location

analysis:
  activity: gen_qa
  technique: gen_qa
  metric: all
    
inference:
  max_new_tokens: 4096
  top_p: 0.9
  temperature: 0.1
"""

with open("eval-recipe.yaml", "w") as f:
  f.write(recipe_content)

4. Choose the occasion sort, the container picture for the analysis job, and outline the checkpoint path the place the mannequin can be saved. The really helpful occasion varieties for the Amazon Nova analysis recipes are:  ml.g5.12xlarge for Amazon Nova Micro and Amazon Nova Lite, and ml.g5.48xlarge for Amazon Nova Professional:

instance_type = "ml.g5.12xlarge" 
instance_count = 1

image_uri = (
    f"708977205387.dkr.ecr.{sagemaker_session.boto_session.region_name}.amazonaws.com/nova-evaluation-repo:SM-TJ-Eval-latest"
)

5. Create the PyTorch Estimator to encapsulate the analysis setup from the created recipe:

from sagemaker.pytorch import PyTorch

# outline Coaching Job Identify
job_name = "train-nova-micro-eval"

estimator = PyTorch(
    output_path=f"s3://{bucket_name}/{job_name}",
    base_job_name=job_name,
    position=position,
    instance_count=instance_count,
    instance_type=instance_type,
    training_recipe="./eval-recipe.yaml",
    max_run=18000,
    sagemaker_session=sagemaker_session,
    image_uri=image_uri,
    disable_profiler=True,
    debugger_hook_config=False,
)

6. Arrange the enter channels for PyTorch Estimator by creating an TrainingInput objects from the offered S3 bucket paths for the validation dataset:

from sagemaker.inputs import TrainingInput

eval_input = TrainingInput(
    s3_data=val_dataset_s3_path,
    distribution="FullyReplicated",
    s3_data_type="S3Prefix",
)

7. Submit the coaching job:

estimator.match(inputs={"prepare": eval_input}, wait=False)

Analysis metrics can be saved by the SageMaker coaching Job in your S3 bucket, below the desired output_path.

The next determine and accompanying desk present the analysis outcomes towards the bottom mannequin for the gen_qa activity:

Possibility B: Consider llm_judge activity

1. For the llm_judge activity, construction the dataset with the under format, the place response_A represents the bottom reality and response_B represents our personalized mannequin output:

{
    "immediate": "String containing the enter immediate and directions",
    "response_A": "String containing the bottom reality output",
    "response_B": "String containing the personalized mannequin output"
}

2. Following the identical strategy described for the gen_qa activity, create an analysis recipe particularly for the llm_judge activity, by specifying decide as technique:

recipe_content = f"""
run:
  identify: nova-micro-llm-judge-eval-job
  model_type: amazon.nova-micro-v1:0:128k
  model_name_or_path: "nova-micro/prod"
  ...

analysis:
  activity: llm_judge
  technique: decide
  metric: all

...
"""

The whole implementation together with dataset preparation, recipe creation, and job submission steps, check with the pocket book nova-micro-dpo-peft.ipynb.

The next determine reveals the outcomes for the llm_judge activity:

This graph reveals the desire percentages when utilizing an LLM as a decide to guage mannequin efficiency throughout two completely different comparisons. In Graph 1, the fine-tuned mannequin outperformed the bottom reality with 66% desire versus 34%, whereas in Graph 2, the bottom mannequin achieved 56% desire in comparison with the bottom reality’s 44%.

Summarized analysis outcomes

Our fine-tuned mannequin delivers important enhancements on the tool-calling activity, outperforming the bottom mannequin throughout all key analysis metrics. Notably, the F1 rating elevated by 81%, whereas the F1 Quasi rating improved by 35%, reflecting a considerable enhance in each precision and recall. By way of lexical overlap, the mannequin demonstrated enhanced accuracy in matching generated solutions to reference texts —instruments to invoke and construction of the invoked perform— reaching positive factors of 39% and 42% for ROUGE-1 and ROUGE-2 scores, respectively. The llm_judge analysis additional validates these enhancements, with the fine-tuned mannequin outputs being most popular in 66.2% towards the bottom reality outputs. These complete outcomes throughout a number of analysis frameworks affirm the effectiveness of our fine-tuning strategy in elevating mannequin efficiency for real-world eventualities.

Deploy the mannequin on Amazon Bedrock

To deploy the fine-tuned mannequin, we are able to use the Amazon Bedrock CreateCustomModel API and use Bedrock On-demand inference with the native mannequin invocation instruments. To deploy the mannequin, full the next steps:

1. Create a {custom} mannequin, by pointing to the mannequin checkpoints saved within the escrow S3 bucket:

...
model_path = ""
# Outline identify for imported mannequin
imported_model_name = "nova-micro-sagemaker-dpo-peft"

request_params = {
    "modelName": imported_model_name,
    "modelSourceConfig": {"s3DataSource": {"s3Uri": model_path}},
    "roleArn": position,
    "clientRequestToken": "NovaRecipeSageMaker",
}
# Create the mannequin import 
response = bedrock.create_custom_model(**request_params)

2. Monitor the mannequin standing. Wait till the mannequin reaches the standing ACTIVE or FAILED:

from IPython.show import clear_output
import time

whereas True:
    response = bedrock.list_custom_models(sortBy='CreationTime',sortOrder="Descending")
    model_summaries = response["modelSummaries"]
    standing = ""
    for mannequin in model_summaries:
        if mannequin["modelName"] == imported_model_name:
            standing = mannequin["modelStatus"].higher()
            model_arn = mannequin["modelArn"]
            print(f'{mannequin["modelStatus"].higher()} {mannequin["modelArn"]} ...')
            if standing in ["ACTIVE", "FAILED"]:
                break
    if standing in ["ACTIVE", "FAILED"]:
        break
    clear_output(wait=True)
    time.sleep(10)

When the mannequin import is full, you will notice it accessible by way of the AWS CLI:

aws bedrock list-custom-models
{
    "modelSummaries": [
        {
            "modelArn": "arn:aws:bedrock:us-east-1: 123456789101:custom-model/imported/abcd1234efgh",
            "modelName": "nova-micro-sagemaker-dpo-peft",
            "creationTime": "2025-07-16T12:52:39.348Z",
            "baseModelArn": "arn:aws:bedrock:us-east-1::foundation-model/amazon.nova-micro-v1:0:128k",
            "baseModelName": "",
            "customizationType": "IMPORTED",
            "ownerAccountId": "123456789101",
            "modelStatus": "Active"
        }
    ]
}

3. Configure Amazon Bedrock Customized Mannequin on-demand inference:

request_params = {
    "clientRequestToken": "NovaRecipeSageMakerODI",
    "modelDeploymentName": f"{imported_model_name}-odi",
    "modelArn": model_arn,
}

response = bedrock.create_custom_model_deployment(**request_params)

4. Monitor the mannequin deployment standing. Wait till the mannequin reaches the standing ACTIVE or FAILED:

from IPython.show import clear_output
import time

whereas True:
    response = bedrock.list_custom_model_deployments(
        sortBy="CreationTime", sortOrder="Descending"
    )
    model_summaries = response["modelDeploymentSummaries"]
    standing = ""
    for mannequin in model_summaries:
        if mannequin["customModelDeploymentName"] == f"{imported_model_name}-odi":
            standing = mannequin["status"].higher()
            custom_model_arn = mannequin["customModelDeploymentArn"]
            print(f'{mannequin["status"].higher()} {mannequin["customModelDeploymentArn"]} ...')
            if standing in ["CREATING"]:
                break
    if standing in ["ACTIVE", "FAILED"]:
        break
    clear_output(wait=True)
    time.sleep(10)

5. Run mannequin inference by way of AWS SDK:

instruments = [
    {
        "toolSpec": {
            "name": "fetch_weather",
            "description": 'Fetch weather information',
            "inputSchema": {
                "json": {
                    "type": "object",
                    "properties": {
                        "type": "object",
                        "properties": {
                            "query": {
                                "type": "string",
                                "description": "Property query",
                            },
                            "num_results": {
                                "type": "integer",
                                "description": "Property num_results",
                            },
                        },
                        "required": ["query"],
                    },
                },
            },
        }
    }
    ...
]

system_prompt = f"""
You're a useful AI assistant that may reply questions and supply info.
You should use instruments that will help you along with your duties.

You've got entry to the next instruments:


{{instruments}}

For every perform name, return a json object with perform identify and parameters:

{{{{"identify": "perform identify", "parameters": "dictionary of argument identify and its worth"}}}}
"""

system_prompt = system_prompt.format(instruments=json.dumps({'instruments': instruments}))

messages = [
{"role": "user", "content": [{"text": "What is the weather in New York?"}]},
]

6. Submit the inference request by utilizing the converse API:

response = consumer.converse(
    modelId=model_arn,
    messages=messages, 
    system=["text": system_prompt],
    inferenceConfig={
        "temperature": temperature, 
        "maxTokens": max_tokens, 
        "topP": top_p
   },
)

response["output"]

We get the next output response:

{
   "message":{
      "position":"assistant",
      "content material":[
         {
            "text":"{"name": "fetch_weather", "parameters": {"query": "Rome, Italy"}}"
         }
      ]
   }
}

Clear up

To wash up your sources and keep away from incurring extra expenses, comply with these steps:

1. Delete unused SageMaker Studio resources
2. (Elective) Delete the SageMaker Studio domain
3. On the SageMaker console, select Coaching within the navigation pane and confirm that your coaching job isn’t operating anymore.
4. Delete custom model deployments in Amazon Bedrock. To take action, use the AWS CLI or AWS SDK to delete it.

Conclusion

This put up demonstrates how one can customise Amazon Nova understanding fashions utilizing the DPO recipe on SageMaker coaching jobs. The detailed walkthrough with a selected deal with optimizing software calling capabilities showcased important efficiency enhancements, with the fine-tuned mannequin reaching as much as 81% higher F1 scores in comparison with the bottom mannequin with coaching dataset of round 8k information.

The absolutely managed SageMaker coaching jobs and optimized recipes simplify the customization course of, so organizations can adapt Amazon Nova fashions for domain-specific use circumstances. This integration represents a step ahead in making superior AI customization accessible and sensible for organizations throughout industries.

To start utilizing the Nova-specific recipes, go to the SageMaker HyperPod recipes repository, the SageMaker Distributed Training workshop and the Amazon Nova Samples repository for instance implementations. Our workforce continues to develop the recipe panorama based mostly on buyer suggestions and rising machine studying tendencies, so you might have the instruments wanted for profitable AI mannequin coaching.

In regards to the authors

Mukund Birje is a Sr. Product Advertising Supervisor on the AIML workforce at AWS. In his present position he’s targeted on driving adoption of Amazon Nova Basis Fashions. He has over 10 years of expertise in advertising and marketing and branding throughout a wide range of industries. Exterior of labor yow will discover him mountaineering, studying, and attempting out new eating places. You may join with him on LinkedIn.

Karan Bhandarkar is a Principal Product Supervisor with Amazon Nova. He focuses on enabling clients to customise the muse fashions with their proprietary information to higher deal with particular enterprise domains and trade necessities. He’s captivated with advancing Generative AI applied sciences and driving real-world affect with Generative AI throughout industries.

 Kanwaljit Khurmi is a Principal Worldwide Generative AI Options Architect at AWS. He collaborates with AWS product groups, engineering departments, and clients to offer steering and technical help, serving to them improve the worth of their hybrid machine studying options on AWS. Kanwaljit focuses on aiding clients with containerized functions and high-performance computing options.

 Bruno Pistone is a Senior World Extensive Generative AI/ML Specialist Options Architect at AWS based mostly in Milan, Italy. He works with AWS product groups and enormous clients to assist them absolutely perceive their technical wants and design AI and Machine Studying options that take full benefit of the AWS cloud and Amazon Machine Studying stack. His experience consists of: mannequin customization, generative AI, and end-to-end Machine Studying. He enjoys spending time with buddies, exploring new locations, and touring to new locations.