Churn prediction using multimodality of text and tabular features with Amazon SageMaker Jumpstart

Amazon SageMaker JumpStart is the Machine Studying (ML) hub of SageMaker offering pre-trained, publicly obtainable fashions for a variety of drawback sorts that will help you get began with machine studying.

Understanding buyer conduct is high of thoughts for each enterprise as we speak. Gaining insights into why and the way prospects purchase might help develop income. Buyer churn is an issue confronted by a variety of firms, from telecommunications to banking, the place prospects are sometimes misplaced to opponents. It’s in an organization’s greatest curiosity to retain current prospects as a substitute of buying new prospects, as a result of it often prices considerably extra to draw new prospects. When attempting to retain prospects, firms typically focus their efforts on prospects who usually tend to depart. Consumer conduct and buyer help chat logs can comprise priceless indicators on the chance of a buyer ending the service. On this answer, we prepare and deploy a churn prediction mannequin that makes use of a state-of-the-art pure language processing (NLP) mannequin to search out helpful indicators in textual content. Along with textual inputs, this mannequin makes use of conventional structured knowledge inputs comparable to numerical and categorical fields.

Multimodality is a multi-disciplinary analysis area that addresses a number of the authentic objectives of synthetic intelligence by integrating and modeling a number of modalities. This submit goals to construct a mannequin that may course of and relate data from a number of modalities comparable to tabular and textual options.

We present you find out how to prepare, deploy and use a churn prediction mannequin that has processed numerical, categorical, and textual options to make its prediction. Though we dive deep right into a churn prediction use case on this submit, you should utilize this answer as a template to generalize fine-tuning pre-trained fashions with your individual dataset, and subsequently run hyperparameter optimization (HPO) to enhance accuracy. You possibly can even change the instance dataset with your individual and run it finish to finish to unravel your individual use circumstances. The answer outlined within the submit is accessible on GitHub.

JumpStart answer templates

Amazon SageMaker JumpStart offers one-click, end-to-end options for a lot of frequent ML use circumstances. Discover the next use circumstances for extra data on obtainable answer templates:

The JumpStart answer templates cowl quite a lot of use circumstances, beneath every of which a number of completely different answer templates are provided (this Doc Understanding answer is beneath the “Extract and analyze knowledge from paperwork” use case).

Select the answer template that most closely fits your use case from the JumpStart touchdown web page. For extra data on particular options beneath every use case and find out how to launch a JumpStart answer, see Resolution Templates.

Resolution overview

The next determine demonstrates how you should utilize this answer with Amazon SageMaker elements. The SageMaker coaching jobs are used to coach the assorted NLP fashions, and SageMaker endpoints are used to deploy the fashions in every stage. We use Amazon Easy Storage Service (Amazon S3) alongside SageMaker to retailer the coaching knowledge and mannequin artifacts, and Amazon CloudWatch to log coaching and endpoint outputs.

We strategy fixing the churn prediction drawback with the next steps:

1. Information exploration to organize the info to be ML prepared.
2. Prepare a multimodal mannequin with a Hugging Face sentence transformer and Scikit-learn random forest classifier.
3. Additional enhance the mannequin efficiency with HPO utilizing SageMaker automated mannequin tuning.
4. Prepare two AutoGluon multimodal models: an AutoGluon multimodal weighted/stacked ensemble mannequin, and an AutoGluon multimodal fusion mannequin.
5. Consider and examine the mannequin performances on the holdout check knowledge.

Stipulations

To check out the solution in your individual account, just be sure you have the next in place:

• An AWS account. For those who don’t have an account, you possibly can join one.
• The answer outlined within the submit is a part of SageMaker JumpStart. To run this JumpStart answer and have the infrastructure deploy to your AWS account, you could create an lively Amazon SageMaker Studio occasion (see Onboard to Amazon SageMaker Studio). When your Studio occasion is prepared, use the directions in JumpStart to launch the answer.
• When working this notebook on Studio, you need to ensure the Python 3 (PyTorch 1.10 Python 3.8 CPU Optimized) picture/kernel is used.

You possibly can set up the required packages as outlined within the answer to run this pocket book:

Open the churn prediction use case

On the Studio console, select Options, fashions, instance notebooks beneath Fast begin options within the navigation pane. Navigate to the Churn Prediction with Textual content answer in JumpStart.

Now we will take a more in-depth have a look at a number of the belongings which are included on this answer.

Information exploration

First let’s obtain the check, validate, and prepare dataset from the supply S3 bucket and add it to our S3 bucket. The next screenshot exhibits us 10 observations of the coaching knowledge.

Let’s start exploring the prepare and validation dataset.

As you possibly can see, now we have completely different options comparable to CustServ Calls, Day Cost, and Day Calls that we use to foretell the goal column y (whether or not the shopper left the service).

y is called the goal attribute: the attribute that we would like the ML mannequin to foretell. As a result of the goal attribute is binary, our mannequin performs binary prediction, also called binary classification.

There are 21 options, together with the goal variable. The variety of examples for coaching and validation knowledge are 43,000 and 5,000, respectively.

The next screenshot exhibits the abstract statistics of the coaching dataset.

We now have explored the dataset and break up it into coaching, validation, and check units. The coaching and validation set is used for coaching and HPO. The check set is used because the holdout set for mannequin efficiency analysis. We now perform characteristic engineering steps after which match the mannequin.

Match a multimodal mannequin with a Hugging Face sentence transformer and Scikit-learn random forest classifier

The mannequin coaching consists of two elements: a characteristic engineering step that processes numerical, categorical, and textual content options, and a mannequin becoming step that matches the reworked options right into a Scikit-learn random forest classifier.

For the characteristic engineering, we full the next steps:

1. Fill within the lacking values for numerical options.
2. Encode categorical options into one-hot values, the place the lacking values are counted as one of many classes for every characteristic.
3. Use a Hugging Face sentence transformer to encode the textual content characteristic to generate a X-dimensional dense vector, the place the worth of X relies on a selected sentence transformer.

We select the highest three most downloaded sentence transformer fashions and use them within the following mannequin becoming and HPO. Particularly, we use all-MiniLM-L6-v2, multi-qa-mpnet-base-dot-v1, and paraphrase-MiniLM-L6-v2. For hyperparameters of the random forest classifier, confer with the GitHub repo.

The next determine depicts the mannequin structure diagram.

There are various hyperparameters you possibly can tune, comparable to n-estimators, max-depth, and bootstrap. For extra particulars, confer with the GitHub repo.

For demonstration functions, we solely use numerical options CustServ Calls and Account Size, categorical options plan, and restrict, and textual content characteristic textual content to suit the mannequin. A number of options ought to be separated by ,.

hyperparameters = {
    "n-estimators": 50,
    "min-impurity-decrease": 0.0,
    "ccp-alpha": 0.0,   
    "sentence-transformer": "sentence-transformers/all-MiniLM-L6-v2",
    "criterion": "gini",
    "max-depth": 6,
    "boostrap": "True",
    "min-samples-split": 4,
    "min-samples-leaf": 1,
    "balanced-data": True,
    "numerical-feature-names": "CustServ Calls,Account Size",
    "categorical-feature-names": "plan,restrict",
    "textual-feature-names": "textual content",
    "label-name": "y"
}

current_folder = utils.get_current_folder(globals())
estimator = PyTorch(
    framework_version='1.5.0',
    py_version='py3',
    entry_point="entry_point.py",
    source_dir=str(Path(current_folder, '../containers/huggingface_transformer_randomforest').resolve()),
    hyperparameters=hyperparameters,
    position=config.IAM_ROLE,
    instance_count=1,
    instance_type=config.TRAINING_INSTANCE_TYPE,
    output_path="s3://" + str(Path(config.S3_BUCKET, config.OUTPUTS_S3_PREFIX_RF)),
    code_location='s3://' + str(Path(config.S3_BUCKET, config.OUTPUTS_S3_PREFIX_RF)),
    base_job_name=config.SOLUTION_PREFIX,
    tags=[{'Key': config.TAG_KEY, 'Value': config.SOLUTION_PREFIX}],
    sagemaker_session=sagemaker_session,
    volume_size=30
)

estimator.match({
    'prepare': 's3://' + str(Path(config.S3_BUCKET, config.DATASETS_S3_PREFIX, 'prepare.jsonl')),
    'validation': 's3://' + str(Path(config.S3_BUCKET, config.DATASETS_S3_PREFIX, 'validation.jsonl'))
})

We deploy the mannequin after coaching is full:

from sagemaker.serializers import JSONSerializer
from sagemaker.deserializers import JSONDeserializer

predictor = estimator.deploy(
    endpoint_name=endpoint_name,
    instance_type=config.HOSTING_INSTANCE_TYPE,
    initial_instance_count=1,
    serializer=JSONSerializer(),
    deserializer=JSONDeserializer()
)

When calling our new endpoint from the pocket book, we use a SageMaker SDK Predictor. A Predictor is used to ship knowledge to an endpoint (as a part of a request) and interpret the response. JSON is used because the format for each enter knowledge and output response as a result of it’s an ordinary endpoint format and the endpoint response can comprise nested knowledge buildings.

With our mannequin efficiently deployed and our predictor configured, we will check out the churn prediction mannequin on an instance enter:

knowledge = {
    "CustServ Calls": -20.0,
    "Account Size": 133.12,
    "plan": "D",
    "restrict": "limitless",
    "textual content": "Properly, I have been coping with TelCom for 3 months now, and I really feel like they're very useful and attentive to my points, however for a month now, I've solely had one technical help name and that was very lengthy and concerned. My telephone quantity was improper on each contracts, they usually gave me an opportunity to work with TelCom customer support and it was extraordinarily useful, so I've determined to keep it up. However I wish to have extra assist when it comes to technical help, I have not had the type of assist with my telephone line and I haven't got the kind of tech help I would like. So I wish to negotiate a telephone contract, perhaps an improve from a Dash plan, or perhaps from a Verizon plan.nTelCom Agent: Superb."
}
response = predictor.predict(knowledge=[data])

The next code exhibits the response (chance of churn) from querying the endpoint:

20.09% chance of churn

Be aware that the chance returned by this mannequin has not been calibrated. When the mannequin offers a chance of churn of 20%, for instance, this doesn’t essentially imply that 20% of consumers with a chance of 20% resulted in churn. Calibration is a helpful property in sure circumstances, however isn’t required in circumstances the place discrimination between circumstances of churn and non-churn is enough. CalibratedClassifierCV from Scikit-learn can be utilized to calibrate a mannequin.

Now we question the endpoint utilizing the hold-out check knowledge, which consists of 1,939 examples. The next desk summarizes the analysis outcomes for our multimodal mannequin with a Hugging Face sentence transformer and Scikit-learn random forest classifier.

Mannequin efficiency depends on hyperparameter configurations. Coaching a mannequin with one set of hyperparameter configurations is not going to assure an optimum mannequin. Because of this, we run the HPO course of within the following part to additional enhance mannequin efficiency.

Match a multimodal mannequin with HPO

On this part, we additional enhance the mannequin efficiency by including HPO tuning with SageMaker automated mannequin tuning. SageMaker automated mannequin tuning, also called hyperparameter tuning, finds one of the best model of a mannequin by working many coaching jobs in your dataset utilizing the algorithm and ranges of hyperparameters that you just specify. It then chooses the hyperparameter values that lead to a mannequin that performs one of the best, as measured by a metric that you just select. The perfect mannequin and its corresponding hyperparameters are chosen on the validation knowledge. Subsequent, one of the best mannequin is evaluated on the hold-out check knowledge, which is identical check knowledge we created within the earlier part. Lastly, we present that the efficiency of the mannequin skilled with HPO is considerably higher than the one skilled with out HPO.

The next are static hyperparameters we don’t tune and dynamic hyperparameters we need to tune and their looking ranges:

from sagemaker.tuner import ContinuousParameter, IntegerParameter, CategoricalParameter, HyperparameterTuner
hyperparameters = {
    "min_impurity_decrease": 0.0,
    "ccp_alpha": 0.0,
    "numerical-feature-names": "CustServ Calls,Account Size",
    "categorical-feature-names": "plan,restrict",
    "textual-feature-names": "textual content",
    "label-name": "y"
}
hyperparameter_ranges = {
    "sentence-transformer": CategoricalParameter([
    "sentence-transformers/all-MiniLM-L6-v2", "sentence-transformers/multi-qa-mpnet-base-dot-v1", "sentence-transformers/paraphrase-MiniLM-L6-v2"]
    ),
    "criterion": CategoricalParameter(["gini", "entropy"]),
    "max-depth": CategoricalParameter([10, 20, 30, 40, 50, 60, 70, 80, 90, 100, -1]),
    "boostrap": CategoricalParameter(["True", "False"]),
    "min-samples-split": IntegerParameter(2, 10),
    "min-samples-leaf": IntegerParameter(1, 5),
    "n-estimators": CategoricalParameter([100, 200, 400, 800, 1000]),
}

tuning_job_name = f"{config.SOLUTION_PREFIX}-hpo"

current_folder = utils.get_current_folder(globals())
estimator = PyTorch(
    framework_version='1.5.0',
    py_version='py3',
    entry_point="entry_point.py",
    source_dir=str(Path(current_folder, '../containers/huggingface_transformer_randomforest').resolve()),
    hyperparameters=hyperparameters,
    position=config.IAM_ROLE,
    instance_count=1,
    instance_type=config.TRAINING_INSTANCE_TYPE,
    output_path="s3://" + str(Path(config.S3_BUCKET, config.OUTPUTS_S3_PREFIX_RF)),
    code_location='s3://' + str(Path(config.S3_BUCKET, config.OUTPUTS_S3_PREFIX_RF)),
    tags=[{'Key': config.TAG_KEY, 'Value': config.SOLUTION_PREFIX}],
    sagemaker_session=sagemaker_session,
    volume_size=30
)

We outline the target metric identify, metric definition (with regex sample), and goal sort for the tuning job.

First, we set the target because the accuracy rating on the validation knowledge (roc auc rating on validation knowledge) and outlined metrics for the tuning job by specifying the target metric identify and an everyday expression (regex). The common expression is used to match the algorithm’s log output and seize the numeric values of metrics.

objective_metric_name = "roc auc"
metric_definitions = [{"Name": "roc auc", "Regex": "roc auc score on validation data: ([0-9.]+)"}]
objective_type = "Maximize"

Subsequent, we specify hyperparameter ranges to pick one of the best hyperparameter values from. We set the overall variety of tuning jobs as 10 and distribute these jobs on 5 completely different Amazon Elastic Compute Cloud (Amazon EC2) cases for working parallel tuning jobs.

Lastly, we go these values to instantiate a SageMaker Estimator object, just like what we did within the earlier coaching step. As a substitute of calling the match operate of the Estimator object, we go the Estimator object in as a parameter to the HyperparameterTuner constructor and name the match operate of it to launch tuning jobs:

tuner = HyperparameterTuner(
    estimator,
    objective_metric_name,
    hyperparameter_ranges,
    metric_definitions,
    max_jobs=18, # improve the utmost variety of jobs will doubtless get higher efficiency
    max_parallel_jobs=3,
    objective_type=objective_type,
    base_tuning_job_name=tuning_job_name,
)

# Launch a SageMaker Tuning job to seek for one of the best hyperparameters
tuner.match(
    {'prepare': 's3://' + str(Path(config.S3_BUCKET, config.DATASETS_S3_PREFIX, 'prepare.jsonl')), 'validation': 's3://' + str(Path(config.S3_BUCKET, config.DATASETS_S3_PREFIX, 'validation.jsonl'))},
    logs=True
)

When the tuning job is full, we will generate the abstract desk of all of the tuning jobs.

After the tuning jobs are full, we deploy the mannequin that offers one of the best analysis metric rating on the validation dataset, carry out inference on the identical hold-out check dataset we did within the earlier part, and compute analysis metrics.

We will see working HPO with SageMaker automated mannequin tuning considerably improves the mannequin efficiency.

Along with HPO, mannequin efficiency can also be depending on the algorithm. It’s vital to coach a number of state-of-the-art algorithms, examine their efficiency on the identical hold-out check knowledge, and decide up the optimum one. Subsequently, we prepare two extra AutoGluon multimodal fashions within the following sections.

Match an AutoGluon multimodal weighted/stacked ensemble mannequin

There are two varieties of AutoGluon multimodality:

• Prepare a number of tabular fashions in addition to the TextPredictor mannequin (using the TextPredictor mannequin inside TabularPredictor), after which mix them by way of both a weighted ensemble or stacked ensemble, as defined in AutoGluon-Tabular: Robust and Accurate AutoML for Structured Data
• Fuse a number of neural community fashions immediately and deal with uncooked textual content (that are additionally able to dealing with extra numerical and categorical columns)

We prepare a multimodal weighted or stacked ensemble mannequin first on this part, and prepare a fusion neural community mannequin within the subsequent part.

First, we retrieve the AutoGluon coaching picture:

from sagemaker import image_uris
from sagemaker.estimator import Estimator

train_image_uri = image_uris.retrieve(
    "autogluon",
    area=boto3.Session().region_name,
    model='0.5.2',
    py_version='py38',
    image_scope="coaching",
    instance_type=config.TRAINING_INSTANCE_TYPE,
)

Subsequent, we go in hyperparameters. In contrast to current AutoML frameworks that primarily concentrate on the mannequin or hyperparameter choice, AutoGluonTabular succeeds by ensembling a number of fashions and stacking them in a number of layers. Subsequently, HPO is often not required for AutoGluon ensemble fashions.

hyperparameters = {
    "numerical-feature-names": "CustServ Calls,Account Size",
    "categorical-feature-names": "plan,restrict",
    "textual-feature-names": "textual content",
    "label-name": "y",
    "problem_type": "classification", # both classification or regression. For classification, we are going to determine binary or multiclass classification within the coaching script
    "eval_metric": "roc_auc",
    "presets": "medium_quality",
    "auto_stack": "False",
    "num_bag_folds": 0,
    "num_bag_sets": 1,
    "num_stack_levels": 0,
    "refit_full": "False",
    "set_best_to_refit_full": "False",
    "save_space": "True",
    "verbosity": 2,
    "pretrained-transformer": "google/electra-small-discriminator"
}

Lastly, we create a SageMaker Estimator and name estimator.match() to begin a coaching job:

# Create SageMaker Estimator occasion

training_job_name_ag = f"{config.SOLUTION_PREFIX}-ag"

tabular_estimator_ag = Estimator(
    position=config.IAM_ROLE,
    image_uri=train_image_uri,
    entry_point="prepare.py",
    source_dir=str(Path(current_folder, '../containers/autogluon_multimodal_ensemble').resolve()),
    instance_count=1,
    instance_type=config.TRAINING_INSTANCE_TYPE,
    max_run=360000,
    hyperparameters=hyperparameters,
    base_job_name=training_job_name_ag,
    output_path="s3://" + str(Path(config.S3_BUCKET, config.OUTPUTS_S3_PREFIX_AG_ENSEMBLE)),
    code_location='s3://' + str(Path(config.S3_BUCKET, config.OUTPUTS_S3_PREFIX_AG_ENSEMBLE)),
    tags=[{'Key': config.TAG_KEY, 'Value': config.SOLUTION_PREFIX}],
)

tabular_estimator_ag.match(
    {
        'prepare': 's3://' + str(Path(config.S3_BUCKET, config.DATASETS_S3_PREFIX, 'prepare.jsonl')),
        'validation': 's3://' + str(Path(config.S3_BUCKET, config.DATASETS_S3_PREFIX, 'validation.jsonl'))
    }, logs=False
)

After coaching is full, we retrieve the AutoGluon inference picture and deploy the mannequin:

# Retrieve the inference docker container uri
inference_image_uri = image_uris.retrieve(
    "autogluon",
    area=boto3.Session().region_name,
    model='0.5.2',
    py_version='py38',
    image_scope="inference",
    instance_type=config.HOSTING_INSTANCE_TYPE,
)

endpoint_name_ag = f"{config.SOLUTION_PREFIX}-ag-endpoint"

predictor_ag = tabular_estimator_ag.deploy(
    initial_instance_count=1,
    instance_type=config.HOSTING_INSTANCE_TYPE,
    entry_point="inference.py",
    image_uri=inference_image_uri,
    source_dir=str(Path(current_folder, '../containers/autogluon_multimodal_ensemble').resolve()),
    endpoint_name=endpoint_name_ag,
)

After we deploy the endpoints, we question the endpoint utilizing the identical check set and compute analysis metrics. Within the following desk, we will see AutoGluon multimodal ensemble improves about 3% in ROC AUC in contrast with the BERT sentence transformer and random forest with HPO.

Match an AutoGluon multimodal fusion mannequin

The next diagram illustrates the structure of the mannequin. For particulars, see AutoMM for Text + Tabular – Quick Start.

Internally, we use completely different networks to encode the textual content columns, categorical columns, and numerical columns. The options generated by particular person networks are aggregated by a late-fusion aggregator. The aggregator can output each the logits or rating predictions.

Right here, we use the pretrained NLP spine to extract the textual content options after which use two different towers to extract the characteristic from the explicit column and numerical column.

As well as, to take care of a number of textual content fields, we separate these fields with the [SEP] token and alternate 0s and 1s because the section IDs, as proven within the following diagram.

Equally, we observe directions within the earlier part to coach and deploy the AutoGluon multimodal fusion mannequin:

# Create SageMaker Estimator occasion
training_job_name_ag_fusion = f"{config.SOLUTION_PREFIX}-ag-fusion"

hyperparameters = {
    "numerical-feature-names": "CustServ Calls,Account Size",
    "categorical-feature-names": "plan,restrict",
    "textual-feature-names": "textual content",
    "label-name": "y",
    "problem_type": "classification", # both classification or regression. For classification, we are going to determine binary or multiclass classification within the coaching script
    "eval_metric": "roc_auc",
    "verbosity": 2,
    "pretrained-transformer": "google/electra-small-discriminator",
}

tabular_estimator_ag_fusion = Estimator(
    position=config.IAM_ROLE,
    image_uri=train_image_uri,
    entry_point="prepare.py",
    source_dir=str(Path(current_folder, '../containers/autogluon_multimodal_fusion').resolve()),
    instance_count=1,
    instance_type=config.TRAINING_INSTANCE_TYPE,
    max_run=360000,
    hyperparameters=hyperparameters,
    base_job_name=training_job_name_ag_fusion,
    output_path="s3://" + str(Path(config.S3_BUCKET, config.OUTPUTS_S3_PREFIX_AG_FUSION)),
    code_location='s3://' + str(Path(config.S3_BUCKET, config.OUTPUTS_S3_PREFIX_AG_FUSION)),
    tags=[{'Key': config.TAG_KEY, 'Value': config.SOLUTION_PREFIX}],
)

tabular_estimator_ag_fusion.match(
    {
        'prepare': 's3://' + str(Path(config.S3_BUCKET, config.DATASETS_S3_PREFIX, 'prepare.jsonl')),
        'validation': 's3://' + str(Path(config.S3_BUCKET, config.DATASETS_S3_PREFIX, 'validation.jsonl'))
    }, logs=False
)

The next desk summarizes the analysis outcomes for the AutoGluon multimodal fusion mannequin, together with these of three fashions that we evaluated within the earlier sections. We will see the AutoGluon multimodal ensemble and multimodal fusion fashions obtain one of the best efficiency.

Be aware that the outcomes and relative efficiency between these fashions rely on the dataset you utilize for coaching. These outcomes are consultant, and despite the fact that the tendency for sure algorithms to carry out higher relies on related components, the steadiness in efficiency may change given a distinct knowledge distribution. You possibly can change the instance dataset with your individual knowledge to find out what mannequin works greatest for you.

Demo pocket book

You should use the demo pocket book to ship instance knowledge to already-deployed mannequin endpoints. The demo pocket book shortly means that you can get hands-on expertise by querying the instance knowledge. After you launch the Churn Prediction with Textual content answer, open the demo pocket book by selecting Use Endpoint in Pocket book.

Clear up

While you’ve completed with this answer, just be sure you delete all undesirable AWS sources by selecting Delete all sources.

Be aware that you should manually delete any extra sources that you might have created on this pocket book.

Conclusion

On this submit, we confirmed how you should utilize Sagemaker JumpStart to foretell churn utilizing multimodality of textual content and tabular options.

For those who’re enthusiastic about studying extra about buyer churn fashions, try the next posts:

Concerning the Authors

Dr. Xin Huang is an Utilized Scientist for Amazon SageMaker JumpStart and Amazon SageMaker built-in algorithms. He focuses on creating scalable machine studying algorithms. His analysis pursuits are within the space of pure language processing, explainable deep studying on tabular knowledge, and strong evaluation of non-parametric space-time clustering. He has printed many papers in ACL, ICDM, KDD conferences, and Royal Statistical Society: Sequence A journal.

Rajakumar Sampathkumar is a Principal Technical Account Supervisor at AWS, offering prospects steerage on business-technology alignment and supporting the reinvention of their cloud operation fashions and processes. He’s obsessed with cloud and machine studying. Raj can also be a machine studying specialist and works with AWS prospects to design, deploy, and handle their AWS workloads and architectures.