Churn prediction utilizing multimodality of textual content and tabular options 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 downside varieties that will help you get began with machine studying.

Understanding buyer conduct is high of thoughts for each enterprise right now. Gaining insights into why and the way prospects purchase can assist develop income. Buyer churn is an issue confronted by a variety of corporations, from telecommunications to banking, the place prospects are usually misplaced to opponents. It’s in an organization’s greatest curiosity to retain present prospects as a substitute of buying new prospects, as a result of it normally prices considerably extra to draw new prospects. When attempting to retain prospects, corporations typically focus their efforts on prospects who usually tend to go away. Consumer conduct and buyer help chat logs can comprise precious indicators on the chance of a buyer ending the service. On this resolution, 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 alerts in textual content. Along with textual inputs, this mannequin makes use of conventional structured knowledge inputs reminiscent of numerical and categorical fields.

Multimodality is a multi-disciplinary analysis discipline that addresses a few of the authentic targets 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 reminiscent of tabular and textual options.

We present you how one can 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 use this resolution 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 exchange the instance dataset with your individual and run it finish to finish to resolve your individual use circumstances. The answer outlined within the submit is offered on GitHub.

JumpStart resolution templates

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

The JumpStart resolution templates cowl a wide range of use circumstances, below every of which a number of totally different resolution templates are supplied (this Doc Understanding resolution is below 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 below every use case and how one can launch a JumpStart resolution, see Answer Templates.

Answer overview

The next determine demonstrates how you should use this resolution with Amazon SageMaker elements. The SageMaker coaching jobs are used to coach the varied 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 method fixing the churn prediction downside with the next steps:

1. Information exploration to arrange the information 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 computerized mannequin tuning.
4. Prepare two AutoGluon multimodal fashions: an AutoGluon multimodal weighted/stacked ensemble mannequin, and an AutoGluon multimodal fusion mannequin.
5. Consider and evaluate the mannequin performances on the holdout check knowledge.

Stipulations

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

• An AWS account. When you don’t have an account, you’ll be able to join one.
• The answer outlined within the submit is a part of SageMaker JumpStart. To run this JumpStart resolution and have the infrastructure deploy to your AWS account, you should create an energetic 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 pocket book on Studio, you must ensure that 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 resolution to run this pocket book:

Open the churn prediction use case

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

Now we are able to take a more in-depth have a look at a few of the property which might be included on this resolution.

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 reveals us 10 observations of the coaching knowledge.

Let’s start exploring the prepare and validation dataset.

As you’ll be able to see, we’ve totally different options reminiscent of 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, often known as 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 reveals the abstract statistics of the coaching dataset.

We’ve 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 function 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 function 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 function 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 function.
3. Use a Hugging Face sentence transformer to encode the textual content function to generate a X-dimensional dense vector, the place the worth of X is determined by 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, discuss with the GitHub repo.

The next determine depicts the mannequin structure diagram.

There are numerous hyperparameters you’ll be able to tune, reminiscent of n-estimators, max-depth, and bootstrap. For extra particulars, discuss 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 function 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,
    function=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 a regular endpoint format and the endpoint response can comprise nested knowledge buildings.

With our mannequin efficiently deployed and our predictor configured, we are able to 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": "Effectively, I have been coping with TelCom for 3 months now, and I really feel like they're very useful and aware of 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 unsuitable on each contracts, and so they 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 want to have extra assist when it comes to technical help, I have never had the type of assist with my telephone line and I haven't got the kind of tech help I need. So I want to negotiate a telephone contract, possibly an improve from a Dash plan, or possibly from a Verizon plan.nTelCom Agent: Excellent."
}
response = predictor.predict(knowledge=[data])

The next code reveals the response (likelihood of churn) from querying the endpoint:

20.09% likelihood of churn

Be aware that the likelihood returned by this mannequin has not been calibrated. When the mannequin provides a likelihood of churn of 20%, for instance, this doesn’t essentially imply that 20% of shoppers with a likelihood 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 ample. 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 relies on hyperparameter configurations. Coaching a mannequin with one set of hyperparameter configurations is not going to assure an optimum mannequin. In consequence, 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 computerized mannequin tuning. SageMaker computerized mannequin tuning, often known as hyperparameter tuning, finds the very 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 end in a mannequin that performs the very best, as measured by a metric that you just select. The very best mannequin and its corresponding hyperparameters are chosen on the validation knowledge. Subsequent, the very 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 educated with HPO is considerably higher than the one educated with out HPO.

The next are static hyperparameters we don’t tune and dynamic hyperparameters we wish to tune and their looking out 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,
    function=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 kind 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 a daily 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 out the very best hyperparameter values from. We set the overall variety of tuning jobs as 10 and distribute these jobs on 5 totally different Amazon Elastic Compute Cloud (Amazon EC2) cases for working parallel tuning jobs.

Lastly, we move these values to instantiate a SageMaker Estimator object, much like what we did within the earlier coaching step. As an alternative of calling the match perform of the Estimator object, we move the Estimator object in as a parameter to the HyperparameterTuner constructor and name the match perform 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 the very 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 are able to generate the abstract desk of all of the tuning jobs.

After the tuning jobs are full, we deploy the mannequin that provides the very 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 are able to see working HPO with SageMaker computerized 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, evaluate 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 sorts of AutoGluon multimodality:

• Prepare a number of tabular fashions in addition to the TextPredictor mannequin (using the TextPredictor mannequin within TabularPredictor), after which mix them through both a weighted ensemble or stacked ensemble, as defined in AutoGluon-Tabular: Strong and Correct AutoML for Structured Information
• 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 move in hyperparameters. Not like present 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 normally 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 establish 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(
    function=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 are able to 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 Textual content + Tabular – Fast Begin.

Internally, we use totally 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 function 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 comply with 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 establish 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(
    function=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 are able to see the AutoGluon multimodal ensemble and multimodal fusion fashions obtain the very best efficiency.

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

Demo pocket book

You need to use the demo pocket book to ship instance knowledge to already-deployed mannequin endpoints. The demo pocket book rapidly permits you to get hands-on expertise by querying the instance knowledge. After you launch the Churn Prediction with Textual content resolution, open the demo pocket book by selecting Use Endpoint in Pocket book.

Clear up

Whenever you’ve completed with this resolution, just be sure you delete all undesirable AWS assets by selecting Delete all assets.

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

Conclusion

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

When you’re fascinated by studying extra about buyer churn fashions, take a look at the next posts:

In regards to the Authors

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

Rajakumar Sampathkumar is a Principal Technical Account Supervisor at AWS, offering prospects steering 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.