Customise Amazon Nova in Amazon SageMaker AI utilizing Direct Desire Optimization

On the AWS Summit in New York Metropolis, we launched a complete suite of mannequin customization capabilities for Amazon Nova basis fashions. Accessible as ready-to-use recipes on Amazon SageMaker AI, you need to use 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’ll 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 method to tune mannequin outputs along with your preferences. DPO makes use of prompts paired with two responses—one most well-liked over the opposite—to information the mannequin towards outputs that higher mirror your required tone, model, or tips. You possibly can implement this system utilizing both parameter-efficient or full mannequin DPO, primarily based in your knowledge quantity and value issues. The personalized fashions will 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 coaching jobs and SageMaker HyperPod, providing you with flexibility to pick out the surroundings that most closely fits your infrastructure and scale necessities.

On this put up, we current a streamlined method 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 particular Nova customization recipe which supplies complete configurations to regulate Amazon Nova coaching parameters, mannequin settings, and distributed coaching methods. You should utilize the default configurations optimized for the SageMaker AI surroundings 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, mechanically decommissions the cluster.

This streamlined structure delivers a totally managed consumer expertise, so you may shortly outline Amazon Nova coaching parameters and choose your most well-liked 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 corresponding to Amazon Bedrock Information Bases, Amazon Bedrock Guardrails, and Amazon Bedrock Brokers.

Enterprise Use Case – Implementation Stroll-through

On this put up, we deal with adapting the Amazon Nova Micro mannequin to optimize structured operate calling for application-specific agentic workflows. We reveal how this method can optimize Amazon Nova fashions for domain-specific use circumstances by a 81% enhance in F1 rating and as much as 42% good points in ROUGE metrics. These enhancements make the fashions extra environment friendly in addressing a big selection of enterprise purposes, corresponding to enabling buyer help AI assistants to intelligently escalate queries, powering digital assistants for scheduling and workflow automation, and automating decision-making in sectors like ecommerce and monetary providers.

As proven within the following diagram, our method makes use of DPO to align the Amazon Nova mannequin with human preferences by presenting the mannequin with pairs of responses—one most well-liked by human annotators and one much less most well-liked—primarily based on a given consumer question and out there instrument actions. The mannequin is educated with the nvidia/When2Call dataset to extend the chance of the tool_call response, which aligns with the enterprise aim of automating backend actions when acceptable. Over many such examples, the Amazon Nova mannequin learns not simply to generate right function-calling syntax, but in addition to make nuanced selections about when and how you can invoke instruments in complicated workflows—bettering its utility in enterprise purposes like buyer help 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 might 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 method. The next diagram illustrates how these phases will 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 sturdy 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.

Conditions

You should full the next conditions earlier than you may run the Amazon Nova Micro mannequin fine-tuning pocket book:

1. Make the next quota enhance requests for SageMaker AI. For this use case, you will want 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 on 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 possibly can create an Amazon SageMaker Studio area (discuss with Use fast setup for Amazon SageMaker AI) to entry Jupyter notebooks with the previous function. (You should utilize JupyterLab in your native setup, too.)
3. Create an AWS Id and Entry Administration (IAM) function with managed insurance policies AmazonSageMakerFullAccess, AmazonS3FullAccess, and AmazonBedrockFullAccess to provide required entry to SageMaker AI and Amazon Bedrock to run the examples.
4. Assign the next coverage because the belief relationship to your IAM function:

{
    "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 property for this deployment. This repository consists of a pocket book that references coaching property:

   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, it is advisable load the nvidia/When2Call dataset. This dataset supplies synthetically generated consumer queries, instrument choices, and annotated preferences primarily based on actual situations, to coach and consider AI assistants on making optimum tool-use selections in multi-step situations.

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

1. Load the nvidia/When2Call dataset:

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

The DPO method requires a dataset containing the next:

• Consumer prompts (e.g., “Write knowledgeable e mail asking for a increase”)
• Most well-liked outputs (perfect responses)
• Non-preferred outputs (undesirable responses)

The next code is an instance from the unique dataset:

2. As a part of knowledge 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 Making ready knowledge for fine-tuning Understanding fashions.

For the total knowledge conversion code, see here.

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

from datasets import Dataset, DatasetDict
from random import randint

...

dataset = DatasetDict(
    {"practice": 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 recordsdata, which is required by SageMaker HyperPod recipes for Amazon Nova, and developing the Amazon S3 paths the place these recordsdata might be uploaded:

...

train_dataset.to_json("./knowledge/practice/dataset.jsonl")
test_dataset.to_json("./knowledge/take a look at/dataset.jsonl")


s3_client.upload_file(
    "./knowledge/practice/dataset.jsonl", bucket_name, f"{input_path}/practice/dataset.jsonl"
)
s3_client.upload_file(
    "./knowledge/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 kind 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 Title
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,
    function=function,
    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 possibly can level to the particular 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 straight 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 operate name on the created Estimator:

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

You possibly can monitor the job straight out of your pocket book output. You may also refer the SageMaker AI console, which exhibits 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 might be out there in an escrow S3 bucket. This safe bucket is managed by Amazon and makes use of particular entry controls. You possibly can entry the paths shared in manifest recordsdata which are 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 in opposition to 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, corresponding 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 judge response accuracy, precision and mannequin inference high quality with the likelihood to make use of our personal dataset and examine outcomes with the bottom mannequin on Amazon Bedrock.

Possibility A: Consider gen_qa activity

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

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

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

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

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

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

model_path = "<ESCROW_S3_PATH_MODEL_CHECKPOINTS>"

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 knowledge 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 kind, the container picture for the analysis job, and outline the checkpoint path the place the mannequin might be saved. The beneficial occasion sorts 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 Title
job_name = "train-nova-micro-eval"

estimator = PyTorch(
    output_path=f"s3://{bucket_name}/{job_name}",
    base_job_name=job_name,
    function=function,
    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={"practice": eval_input}, wait=False)

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

The next determine and accompanying desk present the analysis outcomes in opposition to 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 fact and response_B represents our personalized mannequin output:

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

2. Following the identical method 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, discuss with the pocket book nova-micro-dpo-peft.ipynb.

The next determine exhibits the outcomes for the llm_judge activity:

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

Summarized analysis outcomes

Our fine-tuned mannequin delivers vital 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. When it comes to lexical overlap, the mannequin demonstrated enhanced accuracy in matching generated solutions to reference texts —instruments to invoke and construction of the invoked operate— attaining good points 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 well-liked in 66.2% in opposition to the bottom fact outputs. These complete outcomes throughout a number of analysis frameworks affirm the effectiveness of our fine-tuning method in elevating mannequin efficiency for real-world situations.

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 = "<ESCROW_S3_PATH_MODEL_CHECKPOINTS>"
# 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": function,
    "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 out there by 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 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 utilize instruments that will help you along with your duties.

You might have entry to the next instruments:

<instruments>
{{instruments}}
</instruments>
For every operate name, return a json object with operate identify and parameters:

{{{{"identify": "operate 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 through the use of the converse API:

response = shopper.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":{
      "function":"assistant",
      "content material":[
         {
            "text":"{"name": "fetch_weather", "parameters": {"query": "Rome, Italy"}}"
         }
      ]
   }
}

Clear up

To scrub up your assets and keep away from incurring extra fees, comply with these steps:

1. Delete unused SageMaker Studio assets
2. (Elective) Delete the SageMaker Studio area
3. On the SageMaker console, select Coaching within the navigation pane and confirm that your coaching job isn’t operating anymore.
4. Delete {custom} mannequin 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 particular deal with optimizing instrument calling capabilities showcased vital efficiency enhancements, with the fine-tuned mannequin attaining as much as 81% higher F1 scores in comparison with the bottom mannequin with coaching dataset of round 8k information.

The totally 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 staff continues to broaden the recipe panorama primarily based on buyer suggestions and rising machine studying tendencies, so you could have the instruments wanted for profitable AI mannequin coaching.

Concerning the authors

Mukund Birje is a Sr. Product Advertising and marketing Supervisor on the AIML staff at AWS. In his present function he’s centered 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. Outdoors of labor you will discover him mountain climbing, studying, and making an attempt out new eating places. You possibly can 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 knowledge to raised deal with particular enterprise domains and trade necessities. He’s enthusiastic about 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 supply steering and technical help, serving to them improve the worth of their hybrid machine studying options on AWS. Kanwaljit focuses on helping clients with containerized purposes and high-performance computing options.

 Bruno Pistone is a Senior World Vast Generative AI/ML Specialist Options Architect at AWS primarily based in Milan, Italy. He works with AWS product groups and huge clients to assist them totally 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.