DEV Community: 🅷🅰🆁🅳🅸🅺 🅹🅾🆂🅷🅸

Game Creation via AWS Q CLI

🅷🅰🆁🅳🅸🅺 🅹🅾🆂🅷🅸 — Wed, 21 May 2025 12:26:01 +0000

I am simply amazed by how well AWS Q CLI is operating.
Let me show you simple steps that I took to create 3 games in sequential commplexity and how easy they were to create via help for Q CLI.

I would divide the steps in 2 part.

Installation Instructions
Prompts

Installation Instructions.

Below Step 1-5 will help installing Q CLI
Step 5-6 are required for installation of the required python package.

On a Linux Terminal -

wget https://desktop-release.q.us-east-1.amazonaws.com/latest/amazon-q.deb For other OS instructions, check here
sudo apt-get install -f
sudo dpkg -i amazon-q.deb
q login Select "Use for free with builder ID" option you will need to create a Builder ID via this link
You will be given a link which will need to be opened in another browser where you have logged in with your builder id. This will approve the use of Q.
python3 -m pip install -U pygame --user
python3 -m pygame.examples.aliens

Prompts

Now comes the wow moment. Type in your thoughts in a normal prompt and the code is auto generated and ready to play. I am giving example of 3 prompts that I have used.
First one is a very simple prompt -
Second one is medium prompt -
Third one is very detailed and challenging one - Happy to say that the game turned out amazing. A Python file was generated, but also all supporting json files were generated. Simply Superb.

q (Execute this on the linux kernel where above steps were executed).
Prompt 1: Create a simple tic tac toe game to be played between 2 players
Prompt 2: Create a visual game with state of the art graphics which will have a person standing and needs to dodge incoming boomerangs which he throws and they are coming back to him. At each level the number of boomerangs increase by 1 until the game finishes.
Prompt 3: Create a puzzle game which will ask user to guess the country name based on some unique features of that country. The game should give higher points for guessing earlier in the number of hints that are given for the country and the faster that the person guesses it. You can keep it as multi choice option to select between 5 possible countries. Keep it as challenging as possible. The game can must support English, Gujarati and Hindi languages. It should be as colourful as possible and can also show country flags as option if possible in 2D format. Make it as interesting as possible.

Prompt Output for 3:

I've created a colorful and challenging country puzzle game with support for English, Hindi, and Gujarati languages. Let me explain the key features:

Country Puzzle Game Features

Multilingual Support:
• Full support for English, Hindi, and Gujarati
• All game text, country names, hints, and information are translated
Colorful Interface:
• Uses the termcolor library for colorful text output
• Country flags displayed using emoji
• Visual formatting to make the game attractive
Challenging Gameplay:
• Players must guess countries based on increasingly revealing hints
• Multiple-choice format with 5 country options
• Points system rewards:
• Guessing with fewer hints (70% of score)
• Guessing quickly (30% of score)
Game Structure:
• Main menu with options to play, change language, view score, or exit
• Round-based gameplay with detailed country information after each round
• Score tracking with total points and average time statistics
Country Database:
• Includes 7 countries with unique hints and information
• Each country has 5 challenging hints in all three languages
• Country flags and basic information (capital, currency, languages)

How to Play

Run the game: ./country_puzzle_game.py
Select your preferred language from the menu
In each round, you'll see 5 country options with their flags
Read each hint carefully and make your guess
The faster you guess with fewer hints, the higher your score
After each round, you'll learn interesting facts about the correct country

Files Created

country_puzzle_game.py - Main game script
language_data_en.json - English language strings
language_data_hi.json - Hindi language strings
language_data_gu.json - Gujarati language strings
country_data.json - Database of countries with hints and information

The game is ready to play! You can run it by executing ./country_puzzle_game.py in your terminal. The game will automatically load the necessary language and country data files.

Would you like me to explain any specific part of the implementation in more detail?

I am really happy and satisfied with the outputs and will continue to explore more on Q CLI.
Let me know your thoughts on this.

AWS ML Associate - Study Guide

🅷🅰🆁🅳🅸🅺 🅹🅾🆂🅷🅸 — Wed, 05 Feb 2025 11:10:38 +0000

**Hi all, Below is a study guide for those preparing for the AWS ML Associate certification.
**I have gone through the AWS Skill Builder traning and below are the notes from that training which I have hand written. This helps me to understand the concept better.

Unfortunately When pasting in dev.to the formatting is lost so I had to use a tool to retain formatting which hasn't worked as expected. If you need the raw notes then please msg me and I will send it to you.

Key Questions at Preparatory Stages

What data do you need to reach the intended output?
Do you have access to that data? If so, how much and where is it?
Which solution can you use to bring all this data into one centralized repository?

Useful Links:

Data Requirements

Representative
Relevant
Feature Rich
Consistent

Data Types:

Text
Tabular
Time Series
Image

Data Formats:

Row-based data format: CSV, Avro, RecordIO
Column-based file types: Parquet, ORC
Object notation: JSON, JSONL

Selecting Data Storage - Key Considerations:

Throughput Latency
Elasticity
Scalability
Data access patterns: Copy and Load, Sequential Streaming, Randomized Access

Storage Solutions:

Amazon EBS: Best for training workloads with frequent random I/O access
Amazon EFS: Suitable for real-time and streaming workloads requiring concurrent access
Amazon S3: Ideal for large datasets that don't need quick access (e.g., pretrained ML models)

Data Ingestion:

Methods:

Batch Ingestion
Real-Time Ingestion

Real-Time Use Cases with Amazon Kinesis:

Data Ingestion: Kinesis Data Streams for real-time data streaming
Data Processing: Use Amazon Managed Service for Apache Flink for real-time processing
Real-time Inference: Stream data to an Amazon SageMaker endpoint

Tools for Data Transfer and Extraction:

AWS CLI
AWS SDK
S3 Transfer Acceleration
AWS DMS
AWS Lambda
AWS Glue
AWS DataSync
AWS Snowball

AWS Data Merging:

AWS Glue Workflow:

Identify Data Sources
Create an AWS Glue Crawler
Generate ETL Scripts and Define Jobs
Output Results

Amazon EMR Workflow:

Ingest Streaming Data
Distribute Across EMR Clusters
Transform Data
Output to Amazon S3

Data Preparation Blogs:

Data Transformation and Validation:

Data Transformation Techniques:

Remove unnecessary data
Use Columnar Storage
Compress Data
Format Splittable Data

Data Validation Checks:

Data Integrity
Accuracy
Completeness
Consistency
Reliability
Security
Bias Detection

Feature Engineering:

Categorical Encoding:

Techniques: Label Encoding, One-Hot Encoding

Numeric Feature Engineering:

Feature Scaling: Normalization (0-1), Standardization (-1 to 1)
Binning: Group numerical features into smaller bins
Log Transformation

Model Training Concepts:

Loss Functions: Root Mean Square Error (RMSE), Log-Likelihood Loss
Optimization Techniques: Gradient Descent, Stochastic Gradient Descent
Compute Environments: CPU Training Instances, GPU-accelerated Instances

Model Deployment Steps:

Version Control
CI/CD Integration
ML Model Numbering and Deployment
Monitoring and Workflow Security

Workflow Orchestration Options:

SageMaker Pipelines
AWS Step Functions
AWS MWAA (Managed Workflows for Apache Airflow)

Hyperparameter Tuning:

Techniques:

Manual Selection
Grid Search
Random Search
Bayesian Optimization
SageMaker Automatic Model Tuning

Conclusion:

Using AWS services like SageMaker, Glue, and Kinesis, you can create scalable, efficient machine learning workflows. Leverage the right combination of data storage, processing, and model tuning to meet your business goals effectively.

Model Size and Performance Optimization

Factors Affecting Model Size:

Input Data and Features
Architecture
Problem Domain
Desired Accuracy

Model Size Reduction Techniques:

Compression
Pruning
Quantization
Knowledge Distillation

Model Performance and Evaluation

Model Evaluation Techniques:

Using data you set aside: Validation % and Test %
Establishing Evaluation Metrics
Assessing Trade-offs (performance, training time, and cost)

Common Metrics for Classification Problems:

Accuracy: ( \frac{TP + TN}{Total} )
Precision: ( \frac{TP}{TP + FP} ) – Best when the cost of false positives is high
Recall: ( \frac{TP}{TP + FN} ) – Best when the cost of false negatives is high
F1-Score: Combines Precision and Recall
AUC-ROC: Area Under the Receiver Operator Characteristic Curve

Regression Problem Metrics:

Mean Squared Error (MSE)
Root Mean Squared Error (RMSE)
R-Squared (R²)
Adjusted R-Squared

Model Deployment and Monitoring

Model Deployment Targets:

Amazon SageMaker Endpoints
Amazon EKS
Amazon ECS
AWS Lambda

Model Inference Options:

Real-time
Serverless
Asynchronous
Batch Transform

Infrastructure as Code (IaC) for ML Workflows

Benefits of IaC:

Code Management
Repeatable Provisioning
Testing and Experimentation

Tools:

AWS CloudFormation
AWS CDK (Cloud Development Kit)
Terraform
Pulumi

AWS CDK Components:

App
Stack
Construct

CDK Deployment Workflow:

cdk init <app>
cdk bootstrap
cdk synth
cdk deploy

Continuous Delivery and Deployment

Tools:

Git Repositories
AWS CodeBuild
AWS CodeDeploy
AWS CodePipeline

Deployment Strategies:

All at Once
Canary Deployment
Linear Rolling Deployment
Automatic Rollback

Retraining and Experimentation

Automatic Retraining:

Scheduled Retraining
Drift Detection
Incremental Learning

Experimentation and A/B Testing:

Test model variations to find the optimal configuration for performance.

Debugging and Explainability

SageMaker Debugger:

Improved Model Performance
Explainability and Bias Detection
Automated Monitoring and Alerts

Metrics to Monitor:

Data Quality Metrics: Missing Data, Duplicate Data, Data Drift
Model Bias Metrics: Differential Validity, Differential Prediction Bias
Model Explainability Metrics: SHAP (Shapley Additive Explanations), Feature Attribution

Conclusion

Building machine learning models on AWS requires careful consideration of data, model architecture, and deployment strategies. With services like Amazon SageMaker, AWS Glue, and AWS CDK, you can create robust, scalable, and well-optimized machine learning pipelines.

Model Deployment Steps

Version Control
CI/CD Integration
ML Model Numbering
Model Deployment
Monitoring and Workflow Security

Workflow Orchestration Options:

SageMaker Pipelines: Integrates with SageMaker Feature Store, Amazon ECR, SageMaker Training, SageMaker Processing, and Model Registry.
- Steps: Processing -> Training -> Conditional -> CreateModel -> RegisterModel -> Fail
AWS Step Functions
AWS MWAA (Managed Workflows for Apache Airflow)
Third-party Tools

Model Deployment Targets:

Amazon SageMaker Endpoints
Amazon EKS
Amazon ECS
AWS Lambda

Model Inference Options:

Real-time Inference
Serverless Inference
Asynchronous Inference
Batch Transform

Infrastructure as Code (IaC)

Benefits:

Code Management
Repeatable Provisioning
Testing or Experimentation

Tools for IaC:

AWS CloudFormation
AWS CDK (Cloud Development Kit)
Terraform
Pulumi

AWS CloudFormation Structure:

FormatVersion
Description
Metadata
Parameters
Mappings
Conditions
Resources
Outputs


yaml
Resources:
  LogicalID:
    Type: "Resource Type"
    Properties:
      Key: Value

AWS CDK Components:
App: Entry point for AWS CDK apps
Stack: Represents a single unit of deployment
Construct: Reusable components (L1, L2, L3)
Deployment Workflow:
cdk init <app>
cdk bootstrap
cdk synth
cdk deploy
Continuous Delivery and Deployment
Continuous Delivery Tools:
Git Repositories
AWS CodeBuild
AWS CloudFormation
AWS CodeDeploy
AWS CodePipeline
Deployment Types:
All at Once
Canary Deployment
Linear Rolling Deployment
Automatic Rollback
Retraining and Experimentation
Retraining Strategies:
Scheduled Retraining
Drift Detection and Automatic Retraining
Incremental Learning
Experimentation and A/B Testing:
Test multiple model configurations to select the best performing one.

Debugging and Explainability
SageMaker Debugger:
Improved Model Performance
Explainability and Bias Detection
Automated Monitoring and Alerts
Metrics to Monitor:
Data Quality Metrics: Missing Data, Duplicate Data, Data Drift
Model Bias Metrics: Differential Validity, Differential Prediction Bias
Model Explainability Metrics: SHAP (Shapley Additive Explanations), Feature Attribution

AWS AI Practitioner - Last Min Revision Tips

🅷🅰🆁🅳🅸🅺 🅹🅾🆂🅷🅸 — Sat, 07 Sep 2024 12:25:55 +0000

Are you ready to give the AWS AI Practitioner Certification Exam?

Below is the list of all the material and prep notes that helped me pass the exam.

Hope it will be helpful to you.

KEY NOTES: PLEASE READ FIRST

Below are my personal notes taken from the course I have taken around this

It is not exhaustive list and may not be specific sequence also

Usually my idea was to write everything down while learning and then go through it again and in case I don't recall the given topic then I would go in depth to understand it further.

Hope it helps you in prep, however way it can and most importantly WISH YOU GOOD LUCK..

In case the indentation is not showing correctly, you can go to this link - or message me and can send it to you.

What are Transformers in Artificial Intelligence? -> aws.amazon.com/what-is/transformers-in-artificial-intelligence/

What are Foundation Models? -> aws.amazon.com/what-is/foundation-models/

What is Artificial Intelligence (AI)? -> aws.amazon.com/what-is/artificial-intelligence/

What is Machine Learning? -> aws.amazon.com/what-is/machine-learning/

What is Deep Learning? -> aws.amazon.com/what-is/deep-learning/

What is Generative AI? -> aws.amazon.com/what-is/generative-ai/

What’s the Difference Between Supervised and Unsupervised Learning? -> aws.amazon.com/compare/the-difference-between-machine-learning-supervised-and-unsupervised/

Machine Learning Concepts -> docs.aws.amazon.com/machine-learning/latest/dg/machine-learning-concepts.html

AWS AI Use Case Explorer -> aws.amazon.com/machine-learning/ai-use-cases/?use-cases

What is Amazon SageMaker? -> docs.aws.amazon.com/sagemaker/latest/dg/whatis.html

AWS Services - Machine Learning (ML) and Artificial Intelligence (AI) -> docs.aws.amazon.com/whitepapers/latest/aws-overview/machine-learning.html

AWS Deploy Serverless ML ->aws.amazon.com/blogs/machine-learning/deploy-a-serverless-ml-inference-endpoint-of-large-language-models-using-fastapi-aws-lambda-and-aws-cdk/

AWS Sagemaker - API Gateway - AWS Lambda -> aws.amazon.com/blogs/machine-learning/call-an-amazon-sagemaker-model-endpoint-using-amazon-api-gateway-and-aws-lambda/

Inference parameters ->docs.aws.amazon.com/bedrock/latest/userguide/inference-parameters.html

Inference parameters -> docs.aws.amazon.com/bedrock/latest/userguide/inference-parameters.html?icmpid=docs_bedrock_help_panel_playgrounds

Amazon Bedrock or Amazon SageMaker? -> docs.aws.amazon.com/decision-guides/latest/bedrock-or-sagemaker/bedrock-or-sagemaker.html

Choosing a generative AI service -> docs.aws.amazon.com/decision-guides/latest/generative-ai-on-aws-how-to-choose/guide.html

AWS Bedrock Agents -> aws.amazon.com/bedrock/agents/

What is RAG? - Retrieval-Augmented Generation AI Explained - AWS (amazon.com)

docs.aws.amazon.com/awscloudtrail/latest/userguide/how-cloudtrail-works.html

docs.aws.amazon.com/bedrock/latest/userguide/usingVPC.html

aws.amazon.com/blogs/machine-learning/use-aws-privatelink-to-set-up-private-access-to-amazon-bedrock/

Known Data -> Features -> Algorithm -> Output

Adjustments

Inference

ML models can be trained on various types of data.

Structured data on RDS, S3 or Redshift

S3 is primary source of training data

Semi-structures = DynamoDB & DocumentDB

Unstructured data - tokenization

Timeseries - sequential data

Model Training - Algorithm

Inference 2 options

Real time

Low Latency

High throughput

persistent endpoint

-- Batch Transform

   Offline

   Large datasets

   Infrequent use

ML Types

Supervised Learning

  Amazon Sagemaker GroundTruth -> Amazon Mechanical Turk

Unsupervised Learning

Reinforcement Learning

  Reward - AWS DeepRacer

Overfitting

Model does well on training data but not outside it

Underfitting

Model cannot determine meaningful results. It gives negative results for training data and new inputs

Bias and fairness

Diversity of training data

Feature importance

Fairness constraints

Deep Learning

Neural Networks

Input Layer -> Hidden Layers -> Output Layer

Machine Learning vs Deep Learning

Consider alternatives when

Costs outweigh the benefits

Models cannot meet the interpretability requirements

Systems must be deterministic rather than probabilistic

ML Models are probabilistic

Supervised learning -

Classification

 Binary          - Diabetic or not diabetic

 MultiClass

Regression

  Simple Linear regression

  Multiple Linear regression

  Logistic regression

Unsupervised Learning

Clustering

 Define features

 Similarity function

 Number of clusters

Anomaly detection

  Data points that diverge

Amazon Rekognition

Facial comparison and analysis

Text detection

Object detection and labelling

Content moderation

Can find out explicit text from images and videos

Amazon Textract

Extract text from scanned documents

Amazon Comprehend

Extract key phrases, entities and sentiment.

Main is finding PII data

Amazon Lex

Conversational voice and text

Amazon Transcribe

Converts speech to text

Amazon Polly

Converts Text to speech

Amazon Kendra

Intelligent document search

Amazon Personalize

Personalized product recommendations

Amazon Translate

Translates between 75 languages

Amazon Forecast

Predicts future points in time-series data

Amazon Fraud Detector

Detects fraud and fraudulent activities

Amazon Bedrock

Amazon Sagemaker

ML Pipeline

Identify Business Goal -> Frame ML Problem -> Collect Data -> Pre-process Data -> Engineer Features -> Train, Tune Evaluate -> Deploy -> Monitor

Collect Data

AWS Glue -

  Cloud optimized ETL service

  Contains its own data catalog

  Built in transformations

AWS Glue DataBrew

  Point and click data transformation

  200+ transformations

AWS SageMaker Ground Truth

 Uses ML to label your training data

 Can automatically label

AWS SageMaker Canvas

 Import, Prepare, Transform, Visualize and analyze

AWS Sagemaker Feature Store

 Processes raw data into features by using a processing workflow

Amazon Sagemaker Experiments

 visual interface

Amazon Sagemaker automatic model tuning

Deploy

 Batch inference

 Real-time inference

 Self-managed

 Hosted

Amazon Sagemaker inference

Batch Transform

           Offline inference

           Large datasets

Asynchronous

           Long processing times

           Large payloads

Serverless

           Intermittent traffic

           Periods of no traffic

Real-time

           Live predictions

           Sustained traffic

           Low latency

           Consistent

Monitor the model

         Configure alerts to notify and initiate actions if any drift

         data drift / concept drift

Amazon Sagemaker Model Monitor

MLOps

  Amazon SageMaker Model Building Pipelines

  Repository Options

         AWS Codecommit

         AWS Sagemaker feature store

         AWS Sagemaker model registry

        3rd party repository

  Orchestration options

         Amazon Sagemaker pipelines

         Amazon managed workflows for apache airflow

         AWS Step functions

Accuracy = (True Positives + Ture Negatives) / Total

Precision = True Positives / (True Positivies + False Positives)

Recall = True Positives / (True Positives + False Negatives)

F1 = Precision Recall 2 / (Precision + Recall)

False Positive Rate FPR = False Positives / (True Negatives + False Positives)

True Negative Rate = True Negatives / (True Negatives + False Positives)

Area Under Curve - AUC

Regression Model Errors

  Mean Squared Error

   Root mean squared error

   Mean absolute error

A Framework to Mitigate Bias and Improve Outcomes in the New Age of AI(opens in a new tab) (opens in a new tab) (opens in a new tab)

2 What Are Transformers in Artificial Intelligence?(opens in a new tab)

3 What Is Overfitting?(opens in a new tab) (opens in a new tab)

4 What Are Large Language Models (LLMs)?(opens in a new tab)

5 Responsible Use of Machine Learning(opens in a new tab)

6 Easily Add Intelligence to Your Applications(opens in a new tab)

7 What Is MLOps?(opens in a new tab) (opens in a new tab) (opens in a new tab)

8 Amazon SageMaker MLOps: From Idea to Production in Six Steps(opens in a new tab)

9 Machine Learning Lens

Domain 2::

AI - ML - DL - GAI

Model

In-context learning

Prompts, prompt tuning, prompt engineering

Every NLP has a tokenizer which converts texts into token ID's.

Vector - ordered list of numbers.

     Ability to encode related relationships and collect associations

Embeddings

      Numerical vectorized representations of type that capture the semantic meaning of the token

Self-attention

LLMs

Deep learning foundation models

Transformers

Unimodal or multimodal

Multimodal use cases

Multimodal tasks

Diffusion Models

   Forward Diffusion

   Reverse Diffusion

  Stable Diffusion

          Does not use pixel space of the image, uses a reduced-definition latent space

SageMaker + Amazon Q Developer

Amazon Nimble studio and amazon samarian

Gen AI Architectures

    Generative Adversarial Networks GANs

    Variational autoencoders VAE

    Transformers

AI Project lifecycle

   Identify User case

   Experiment and select

   Adapt, align and augment

   Evaluate

   Deploy and integrate

  Monitor

Interpretability

   Intrinsic analysis

   Post hoc analysis

ML outputs are deterministic

Gen AI outputs are non-deterministic

Gen AI Performance metrics

    Recall - Oriented Understudy for Gisting Evaluation (ROUGE)

    Bilingual Evaluation Understudy (BLEU)

Transfer learning

SageMaker JumpStart

Selecting the Right Foundation Model for Your Startup(opens in a new tab) (opens in a new tab) (opens in a new tab) (opens in a new tab)

2 Generative Adversarial Networks Applications and its Benefits (opens in a new tab)

3 The Complete Guide to Generative AI Architecture(opens in a new tab) (opens in a new tab)

4 PartyRock.aws(opens in a new tab)

5 Monitoring Generative AI Applications Using Amazon Bedrock and Amazon CloudWatch Integration(opens in a new tab)

6 What Is a GAN?(opens in a new tab)

7 AWS Cloud Adoption Framework for Artificial Intelligence, Machine Learning, and Generative AI

Considerations

   Architecture

   Complexity

   Availability

  Compatibility

  Explainability

  Interpretability

Inference

   It is the process of generating an output from an input that you provided to the model.

   Input = Prompt and inference parameters

  Randomness and Diversity

         Temperature  (Lower value = high probability outputs and Higher value = Low probability outputs)

         Top K (Lower value = decrease the size of pool)

         Top P

   Length

         Response Length

        Penalties

        Stop sequences

  Prompt

        A specific set of inputs to guide LLMs to generate an appropriate output or completion

  RAG - Retrieval Augmented Generation (RAG)

         Prompt enrichment and appending external data to your prompt

         Vector Database

               Collection of data stored as mathematical representations



  AWS Services for Vector search databases

          Amazon OpenSearch Service

         Amazon OpenSearch Serverless

         Amazon Aurora PostgreSQL

         Amazon RDS PostgreSQL

        Amazon Aurora

       Amazon Neptune

      Amazon DocumentDB [with MongoDB compatibility]



 Amazon Bedrock AGENTS

     Orchestrate prompt completion workflows



Prompt

    Zero shot prompting

    Few shot prompting

    Prompt Template

   Chain-of-thought prompting

   Prompt tuning



Latent space

      The encoded knowledge of language in LLMs or the stored patterns of data that capture relationships and reconstruct the language from the patterns when prompted

      Statistical database

Prompt Engineering risks and limitations

     Exposure

     Prompt Injection

     Jailbreaking

    Hijacking

   Poisoning

Training process for foundation models

     Pretraining         - Self supervised learning

    Fine-tuning        - Supervised learning            :: Catastrophic forgetting

    Continuous pre-training



Fine-tuning techniques

     Parameter-efficient fine-tuning (PEFT)

     Low-Rank Adaptation (LoRA)

     Representation fine-tuning (ReFT)

    Multitask fine-tuning

    Domain adaption fine-tuning

    Reinforcement learning from human feedback (RLHF)



Data preparation fine-tuning

     Prepare your training data

    Select prompts

   Calculate loss

   Update weights

  Define evaluation steps

Data preparation AWS Services

   Amazon SageMaker Canvas

  Open-source frameworks

  Amazon Sagemaker studio - integration with EMR, can use jupyter labs

 Amazon Glue

 Amazon SageMaker Feature Store

 Amazon SageMaker Clarify  -- if you have bias in your data

Amazon SageMaker Ground Truth  -- manage data labelling

Model performance

    One option to reduce inference latency is to decrease the size of LLMs but might decrease its performance

Gen AI Performance Metrics

    Recall Oriented Understudy for Gisting Evaluation (ROUGE)

            Automatic summarization tasks

           Machine translation software

  Bilingual Evaluation Understudy (BLEU)

           Used for translation tasks

  General Language Understanding Evaluation (GLUE)

         Compare against benchmarks set by the experts

        Access model generalization across multiple tasks

Holistic Evaluation of Language Models (HELM)

      Help improve model transparency

Massive Multitask Language Understanding (MMLU)

     Evaluates knowledge and problem solving capabilities of the model

    Tested against history, mathematics, laws, computer science and more

Beyond the Imitation Game Benchmark (BIG-bench)

    Focuses on tasks that are beyond the capabilities of the current language models

AWS Services for model evaluation

  Amazon SageMaker JumpStart

 Amazon SageMaker Clarify

Review these materials to learn more about the topics covered in this exam domain:

1 What Are Foundation Models?(opens in a new tab) (opens in a new tab) (opens in a new tab)

2 Inference Parameters(opens in a new tab)

3 Knowledge Bases for Amazon Bedrock(opens in a new tab) (opens in a new tab)

4 Agents for Amazon Bedrock(opens in a new tab)

5 Amazon OpenSearch Service’s Vector Database Capabilities Explained(opens in a new tab)

6 The Role of Vector Datastores in Generative AI Applications(opens in a new tab)

7 Vector Engine for Amazon OpenSearch Serverless (opens in a new tab) (opens in a new tab) (opens in a new tab)

8 What Is Prompt Engineering?(opens in a new tab)

9 Domain-Adaptation Fine-Tuning of Foundation Models in Amazon SageMaker JumpStart on Financial Data(opens in a new tab) (opens in a new tab)

10 Metric: bleu(opens in a new tab)

11 Metric: rouge(opens in a new tab)

12 ReFT: Representation Fine-Tuning for Language Models

Responsible AI

    Fairness

   Explainability

  Robustness

  Privacy and security

 Governance

Transparency

Effects of bias and variance

  Demographic disparities

  Inaccuracy

 Overfitting

 Underfitting

User Trust

Responsible datasets

 Inclusivity

 Diversity

 Balanced datasets

 Privacy protection

 Consent and transparency

 Regular audits

Responsible practices

  Environmental considerations

  Sustainability

  Transparency

  Accountability

 Stakeholder engagement

AWS service for this

Amazon SageMaker Clarify

   Detect bias

  Explainability

 SageMaker Processing jobs

SageMaker pre-training bias analysis

 Class imbalance

 Label imbalance

 Demographic disparity

Difference in positive proportions

Specificity difference

Recall difference

Accuracy difference

Treatment equality

Gen AI Risks

Hallucinations

Intellectual Property

Bias

Toxicity

Data privacy

Guardrails for Amazon Bedrock

Hate

Insults

Sexual

Violence

Denied topics

Model transparency

Interpretability   - Deep analysis

Explainability - black box analysis

AI Service Card

Amazon SageMaker Model Cards

Sagemaker provides

    Feature attributions - SHAP Values

   Partial dependence plots

Amazon Augmented AI (A2I) - send data to human reviewers to review random predictions.

   Use your own reviewers or use mechanical turf

Responsible AI in the Generative Era(opens in a new tab) (opens in a new tab) (opens in a new tab)

2 Transform Responsible AI from Theory into Practice(opens in a new tab)

3 Tools and Resources to Build AI Responsibly(opens in a new tab) (opens in a new tab)

4 What Is RLHF?(opens in a new tab)

5 Responsible AI Best Practices: Promoting Responsible and Trustworthy AI Systems

IAM Identity Center

      Workforce users, Workforce identities

Logging with CloudTrail

     Captures API calls and related events

     Integrated with SageMaker

Amazon SageMaker Role Manager

   Preconfigured permissions for 12 activities

Encryption at rest

  Amazon SageMaker

       Data is encrypted by default on ML storage volumes

      Notebook instances, SageMaker jobs, and endpoints

AWS Key Management Service - KMS

Amazon Macie

    Identifies and alerts you to sensitive data

   Remove PII during ingestion

AI System Vulnerabilities

   Training Data

   Input Data

  Output Data

  Models

      Inversion

     Theft

LLM's

     Prompt Injection

Amazon SageMaker Model Monitor

  Capture data

  Create a baseline

  Define data quality monitoring jobs

  Evaluate statistics

Amazon SageMaker Model Registry

Amazon SageMaker Model Cards

Amazon SageMaker ML Lineage Tracking

Amazon SageMaker Feature Store

Amazon SageMaker Model Dashboard

Emerging AI compliance standards

   ISO 42001 and ISO 23894

  EU Artificial Intelligence Act

 NIST AI Risk Management Framework (RMF)

AI Risk Management

 Probability of occurrence

 Severity of occurrence

Algorithmic Accountability Act

 Transparency and explainability

 Monitor for Bias

AWS Audit Manager

  Audits AWS usage to assess compliance

 Choose a framework

       Gen AI

      Customer frameworks

Collect evidence and add to audit report

Guardrails for Amazon Bedrock

  Apply guardrails to any foundation model and agents for Amazon Bedrock

 Configure harmful content filtering

 Define and disallow denied topics

 PII data

AWS Config

 Continuously monitors and records configurations

 AWS Config rules

Conformance packs

        Operational best practices for AI and ML

       Security best practices for Amazon SageMaker

Amazon Inspector

   Works at application level

  Performs automated security assessments on your applications

AWS Trusted Advisor

   Provides guidance to help you

      Reduce cost

      Increase performance

      Improve security

Data Governance

  Curation

  Discovery and understanding

 Protection

Define roles

    Data steward

   Data owner

   IT Roles

AWS Glue DataBrew for data goverance

 Data profiling

 Data Lineage

AWS Glue Data Catalog

AWS Glue Data Quality

Curation

    Data Quality Management

   Data Integration

   Data Management

Protection

 Data Security

 Data Compliance

 Data Lifecycle management

Review these materials to learn more about the topics covered in this exam domain:

1 Shared Responsibility Model(opens in a new tab) (opens in a new tab) (opens in a new tab)

2 Securing Generative AI: Applying Relevant Security Controls(opens in a new tab)

3 AWS Cloud Adoption Framework for Artificial Intelligence, Machine Learning, and Generative AI(opens in a new tab)

4 AWS Compliance(opens in a new tab)

5 Customer Compliance Center(opens in a new tab) (opens in a new tab) (opens in a new tab)

6 NIST Artificial Intelligence Risk Management Framework(opens in a new tab)

7 ISO 42001: A New Foundational Global Standard to Advance Responsible AI(opens in a new tab)

8 The EU Artificial Intelligence Act(opens in a new tab) (opens in a new tab)

9 Learn How to Assess the Risk of AI Systems(opens in a new tab)

10 What Is Data Governance?(opens in a new tab)

11 Data Governance in the Age of Generative AI

How to Choose a Machine Learning Algorithm? (serokell.io

Using Custom Authorization - Request based for AWS Lambda

🅷🅰🆁🅳🅸🅺 🅹🅾🆂🅷🅸 — Sat, 23 Mar 2024 08:44:44 +0000

Many a time we face a challenge for our Lambda function endpoints where a customer autorization is required.
Below is a post which shows how to implement a Request based Custom Authorization for AWS Lambda.

A Lambda authorizer, formerly known as custom authorizer, controls API access using a Lambda function. It's beneficial for custom authorization with bearer token authentication like OAuth or SAML OR request parameter based authentications. It processes the caller's identity and returns an IAM policy. There are two types: TOKEN authorizer for bearer tokens and REQUEST authorizer for parameters. WebSocket APIs only support REQUEST authorizers. You can use Lambda functions across AWS accounts for authorizers.

In this part, I will show you how to create a request based token.

It will cover 3 high level steps

Create a sample Lambda REST API
Create a trigger on API Gateway
Create the customer Authorizer and attach it to API and test it.

*Step 1 *- Go to AWS Console, select Lambda and click on 'Create Function'

Step 2 - Author from scratch and API, Give it any name and create a new role for Lambda execution

Step 3 - Customize the output message with your favourite Hello world message. My sample as below



export const handler = async (event) => {
  // TODO implement
  const response = {
    statusCode: 200,
    body: JSON.stringify('You have called My Rest API!'),
  };
  return response;
};

Step 4 - Once the Lambda is created we will create an API Gateway trigger which will basically call this Lambda on the endpoint invocation

a. Click on add trigger

b. Select the source as API Gateway

c. Fill in the required Trigger parameters to expose it as a REST API and click on Create. Note the security parameter is kept as OPEN. This is specifically to test our scenarios

Step 5 - On the API, click on Configuration tab and click on Triggers, Note the API Endpoint and click on it to open it.

Step 6 - You will be able to view the result from the endpoint.

Step 7 - Now we will create the authorizer function, Go back to Lambda function, and click on 'Create Function'. Fill in the details as below

Step 8 - Now under the code section, fill in the below code.
This is a sample code from AWS blogs. Importantly look for the Header, QueryParam and StageVariable validation conditions.
This will be the one which will be request-based authorizer.



   // A simple request-based authorizer example to demonstrate how to use request 
    // parameters to allow or deny a request. In this example, a request is  
    // authorized if the client-supplied headerauth1 header, QueryString1
    // query parameter, and stage variable of StageVar1 all match
    // specified values of 'headerValue1', 'queryValue1', and 'stageValue1',
    // respectively.

export const handler = function(event, context, callback) {
    console.log('Received event:', JSON.stringify(event, null, 2));

    // Retrieve request parameters from the Lambda function input:
    var headers = event.headers;
    var queryStringParameters = event.queryStringParameters;
    var pathParameters = event.pathParameters;
    var stageVariables = event.stageVariables;

    // Parse the input for the parameter values
    var tmp = event.methodArn.split(':');
    var apiGatewayArnTmp = tmp[5].split('/');
    var awsAccountId = tmp[4];
    var region = tmp[3];
    var restApiId = apiGatewayArnTmp[0];
    var stage = apiGatewayArnTmp[1];
    var method = apiGatewayArnTmp[2];
    var resource = '/'; // root resource
    if (apiGatewayArnTmp[3]) {
        resource += apiGatewayArnTmp[3];
    }

    // Perform authorization to return the Allow policy for correct parameters and 
    // the 'Unauthorized' error, otherwise.
    var authResponse = {};
    var condition = {};
    condition.IpAddress = {};

    if (headers.headerauth1 === "H1"
        || queryStringParameters.QueryString1 === "Q1"
        || stageVariables.StageVar1 === "S1") {
        callback(null, generateAllow('me', event.methodArn));
    }  else {
        callback("Unauthorized");
    }
}

// Help function to generate an IAM policy
var generatePolicy = function(principalId, effect, resource) {
    // Required output:
    var authResponse = {};
    authResponse.principalId = principalId;
    if (effect && resource) {
        var policyDocument = {};
        policyDocument.Version = '2012-10-17'; // default version
        policyDocument.Statement = [];
        var statementOne = {};
        statementOne.Action = 'execute-api:Invoke'; // default action
        statementOne.Effect = effect;
        statementOne.Resource = resource;
        policyDocument.Statement[0] = statementOne;
        authResponse.policyDocument = policyDocument;
    }
    // Optional output with custom properties of the String, Number or Boolean type.
    authResponse.context = {
        "stringKey": "stringval",
        "numberKey": 123,
        "booleanKey": true
    };
    return authResponse;
}

var generateAllow = function(principalId, resource) {
    return generatePolicy(principalId, 'Allow', resource);
}

var generateDeny = function(principalId, resource) {
    return generatePolicy(principalId, 'Deny', resource);
}

Step 9 - Add the code and now click 'Deploy'

Step 10 - Now, go to API Gateway and click on the API Name. NOTE:- you need to go to API Gateway not AWS Lambda.

Step 11 - Now go to Authorizers _and click on _Create authorizer

Step 12 - Next up, we need to create the autorizer with the right Identify source type and the key values.
One which we are doing here are Header, Query String and StageVariable. There are few others also based on which you can perform the authorization

Step 13 - Now go back to the authorizer that is created and click on its details

Step 14 - Next screen will give you the option to test the authorization,

a. if you give any values that are acceptable then it will return a 200

b. if you give any values that are not acceptable then it will return a 401

So in this way you can achieve custom authorization for your code very quickly.

Hope this was useful to you. And in the next blog I will show creation of a token based authorizer.

AWS Amplify : Website Migration

🅷🅰🆁🅳🅸🅺 🅹🅾🆂🅷🅸 — Sat, 23 Mar 2024 04:06:49 +0000

I have a custom web app which would help me track buses around my area and to also give me a clear view on where they current GPS location, letting me leave out at a precise time.

This Website was earlier hosted on Heroku and was working fine. However, recently Heroku has taken away the free tier and I was exploring alternate web hosting options for my site.

I gave a go with AWS Amplify web hosting and I am very impressed with the ease of getting it done. Took me less than 5 mins to complete the whole process.

I will document here the full journey on AWS Amplify Web hosting.

Firstly, what is AWS Amplify?

AWS Amplify is a set of products and tools that enable mobile and front-end web developers to build and deploy secure, scalable full-stack applications, powered by AWS.

AWS Amplify provides two components

Amplify Studio

Build an app backend with auth, data, and storage, and create custom UI components. Then integrate them in your app with just a few steps.

Amplify Hosting

Connect your Git repository to continuously deploy your frontend and backend. Host it on a globally available CDN.

Pre-requisites:
For this you will need a repo with a bitbucket URL (and optionally may be already deployed earlier or at least locally tested).

Steps:

Step 1 - Open the AWS Amplify homepage
eg:- https://ap-southeast-console.aws.amazon.com/amplify/home?region=ap-southeast-2#/

This will open the Amplify Homepage.

Step 2 - Scroll down to Amplify Hosting and click 'Get Started'. This will start the webhosting process.

Step 3 - Choose an existing repo. In my case the repo was hosted on bitbucket. In my case, its currently in GitHub (planning to migrate it to AWS CodeCommit).

This step will initiate the steps required for linking the repo.

Step 4 - Authorize this access request by AWS Amplify on Github by
a. signing in with the GitHub credentials,

b. entering the 2FA

c. authorizing the access

This step will build a connection with your dev work

Step 5 - Next provide the permissions to access all repos or selective repos.

Click 'Install & authorize'

Step 6 - Now under recently updated repos, select the repo & branch that you want to get published.

a. select the repo

b. select the branch

Step 7 - Next select the build setting. Here you can define the app name and additionally you can configure the advanced settings if required. I didnt had that much need so went with the default one.

Step 8 - Now, review all the settings and click 'Save and Deploy'

Step 9 - Monitor the deployment for Provision - Build and then Deploy.

That's it.
You will get the deployment URL and once the deploy step is successful you will be able to access it.

It was really easy and straightforward to migrate my website on AWS Amplify.

Hope you had a good read and can try this out now.

Create a Telegram Bot with AWS Lambda Integration - Part 2

🅷🅰🆁🅳🅸🅺 🅹🅾🆂🅷🅸 — Mon, 13 Mar 2023 11:53:04 +0000

Hello and welcome back to the Part -2 of the AWS Lambda and Telegram Bot interaction. For the next step, I was exploring on the integration options that can be trialled for taking this a step further. Below are the use cases for which this integration can be used.

Serverless Notifications: By integrating Telegram with AWS Lambda, you can create a serverless notification system that sends messages to Telegram whenever certain events occur in your AWS infrastructure. For example, you could set up a Lambda function to send a message to a Telegram group whenever a new EC2 instance is launched.
Chatbot: You can use AWS Lambda to build a chatbot that responds to user queries in Telegram. For example, you could create a Lambda function that uses natural language processing to answer questions about your products or services, and then integrate it with Telegram so that users can interact with the chatbot through the Telegram app.
Content Distribution: By integrating Telegram with AWS Lambda, you can create a system for distributing content to users through Telegram. For example, you could set up a Lambda function to generate daily news summaries or weather updates, and then use Telegram to distribute them to subscribers.
Event Monitoring: You can use AWS Lambda to monitor events in your Telegram groups or channels. For example, you could create a Lambda function that analyzes messages in a Telegram group and sends an alert to a designated user if certain keywords or phrases are detected.
Analytics: By integrating Telegram with AWS Lambda, you can create a system for analyzing user behavior in Telegram. For example, you could set up a Lambda function to track how often users interact with your Telegram bot, what kinds of questions they ask, and how long they spend chatting. This data can then be used to optimize your chatbot and improve user engagement.

Firstly, I tried to create a chatbot which will respond to commands typed on telegram and for now it is sending a sample response back for acknowledgement

Assuming you have followed all the required steps from Part - 1, below is the code that you will be required to update in the lambda handler for this

import json import os import requests def lambda_handler(event, context): request_body = json.loads(event['body']) # EXtract the Body from the call request_msg = json.dumps(request_body['message'])#['chat']['id'] # Extract the message object which contrains chat id and text chat_id = json.dumps(request_body['message']['chat']['id']) # Extract the chat id from message command = json.dumps(request_body['message']['text']).strip('"') # Extract the text from the message # TODO implement BOT_TOKEN = os.environ.get('TOKEN') BOT_CHAT_ID = os.environ.get('CHATID') BOT_CHAT_ID = chat_id # Updating the Bot Chat Id to be dynamic instead of static one earlier command = command[1:] # Valid input command is /start or /help. however stripping the '/' here as it was having some conflict in execution. if command == 'start': message = "Welcome to my bot! How can I help you today?" # Sample Response on start command elif command == 'help': message = "Here are the available commands: /start, /help" else: message = "I'm sorry, I didn't understand that command. Please try again." send_text = 'https://api.telegram.org/bot' + BOT_TOKEN + '/sendMessage?chat_id=' + BOT_CHAT_ID + \ '&parse_mode=HTML&text=' + message response = requests.get(send_text) print(send_text) print(response) return { 'statusCode': 200, 'body': json.dumps('Hello from Lambda!') }

For the above chatbot to work, we need to have an active connection between Telegram and Lambda. For this, we need to set a webhook. Below is the command to set webhook

https://api.telegram.org/bot<>/setWebhook?url=<>

Here the BOT ID is your Bot ID
The Lambda Function URL is the URL obtained from the Lambda description page.

After updating the above code, below is the result that I have got

That's it for the Part 2.
Next I want to try the below for Part 3.
a. Create a chatbot quiz which will have questions from Dynamo DB and scorecard in DynamoDB and hosted via Telegram.
b. Some live score or ticker updates via Telegram. This will involve in CORS functionality and https calls via Lambda.

Create a Telegram Bot with AWS Lambda Integration - Part 1

🅷🅰🆁🅳🅸🅺 🅹🅾🆂🅷🅸 — Mon, 16 Jan 2023 19:05:06 +0000

Hi all, recently over the Christmas break, I wanted to explore a telegram bot automation for a personal project. As part of that, I went through learning all the steps required and going over multiple iterations to optimize the code and also get it working.

And with the this post, I want to share my learning with you all. Below is the step by step guide to create a Telegram Bot with AWS Lambda Integration.

This will be a multi-part blog. Part 1 below is focusing on getting the basics done and then Part 2 will go for advanced interactions.

I hope this helps you.

Firstup, we will create a bot in Telegram. All conversations will be done via this bot over telegram.
For creating bot, telegram has this really cool feature @botfather, Search for botfather and you can start interacting to create new bot
"Seach BotFather and message /start"
Type "/newbot" to create a new bot
Choose the name of the bot
Choose the username of the bot

** This step will generate a TOKEN. Save this token for future
use.**
Next click on the link for your new bot generated above (t.me/##yourbotname##) and start a conversation. Text "Hi"
Once you send a message to the bot, the chat will get an ID which will be used for the conversation. To retrieve the ChatID, we will use the Telegram API.
Replace your TOKENid below and call the below URL https://api.telegram.org/bot##yourTOKENid##/getUpdates
Extract the ChatID from the response. Look for the below tag in response: "chat":{"id": "xxxxxxx"
Now send a sample message to this chat with Web (Later on we will do it via AWS Lambda) https://api.telegram.org/bot##yourTOKENid##/sendMessage?chat_id=##yourChatID##&text=Hello
HURRAY.. You should have got a text from the Bot already. Now lets build the integration with AWS Lambda
Go to AWS Console -> AWS Lambda -> Click on 'Create Function'
Now, give a valid function name and select the suitable runtime, then go to advance setting and select the checkbox of 'Enable Function URL' and 'None' for the IAM setting (This is great feature and elimiates API Gateway setting altogether), keep rest settings as default and click on 'Create Function'. I chose python in this case
When the sample function is created. Copy the Function URL and open it in a new tab. You should get a response as below.
If you are getting unauthorize error, then recheck if you had selected 'None' in function URL which ensures unathenticated access.
It's best practice to define the secure information as Environment Variable (or for advanced uses you can use other secure stores). Go to 'Configuration' tab and click on 'Environment Variables' and add 2 variables
'TOKEN' = Value is ##yourTOKENid##
'CHATID' = Value is ##yourCHATid## (In future, we can retrieve chatid from request to make it dynamic)
Now we will add the functionality to send the message via Lambda. For python, this usually requires importing 'requests' module which is not available out of the box.
Hence, for this, we will choose to create a layer in Lambda which will host this library.
Download the Requests tar from https://github.com/TryNErr/TryNErr/blob/main/requests.zip

Once downloaded tar will have to be convered to ZIP with below folder structure

For Python, create the below folder structure + download required libraries
python /
certifi-2021.10.8.dist-info
certifi
charset_normalizer
charset_normalizer-2.0.12.dist-info
idna
idna-3.3.dist-info
requests
requests-2.27.1.dist-info

you can alternately take it from your python project libraries and zip these files OR contact me and I can send it to you.

Click on 'Layers' on the Lambda function
Click on 'Add a Layer'
Next, we will create a new layer, click on 'Create a New Layer'
Provide the required details, Upload the requests.zip file, click on 'Create'
Post creation, Go back to the Lambda function and click on Add a Layer to add the newly created layer, click 'Add'

Now, update your lambda function with the below code:

import json
import os
import requests

def lambda_handler(event, context):
    # TODO implement
    BOT_TOKEN = os.environ.get('TOKEN')
    BOT_CHAT_ID = os.environ.get('CHATID')
    #BOT_CHAT_ID = chat_id
    bot_message = "Hello, this is the bot from telegram"
    send_text = 'https://api.telegram.org/bot' + BOT_TOKEN + '/sendMessage?chat_id=' + BOT_CHAT_ID + \
                '&parse_mode=HTML&text=' + bot_message
    response = requests.get(send_text)
    print(response)    
    return {
        'statusCode': 200,
        'body': json.dumps('Hello from Lambda!')
    }

This should send a message to your telegram chat...

Thats the end of Part 1.
For Part 2, I will try to a) add more functionality to the bot and b) schedule the bot to trigger message in set frequency.

AWS Step Functions - Simple Order Flow

🅷🅰🆁🅳🅸🅺 🅹🅾🆂🅷🅸 — Mon, 13 Sep 2021 08:34:04 +0000

AWS Step Functions - Simple Order Flow Example (Step by Step Guide)

What is AWS Step Functions?

AWS Step Functions is a fully managed service that makes it easy to coordinate the components of distributed applications and microservices using visual workflows.
Building applications from individual components that each perform a discrete function lets you scale easily and change applications quickly.
Step Functions is a reliable way to coordinate components and step through the functions of your application. Step Functions provides a graphical console to arrange and visualize the components of your application as a series of steps.
This makes it simple to build and run multi-step applications. Step Functions automatically triggers and tracks each step, and retries when there are errors, so your application executes in order and as expected.
Step Functions logs the state of each step, so when things do go wrong, you can diagnose and debug problems quickly.
You can change and add steps without even writing code, so you can easily evolve your application and innovate faster.

Order Flow - Design Details

For this example, I will demo how step functions can help to manage a order flow once user has submitted the order. Here, for this example, I am taking an online bookstore which will ship books based on the order submission. It should perform the below steps as part of Order Handling

On Order Submit, system will check the available inventory of the book.
If inventory available, then proceed further. If not available, then trigger a printOrder and wait for the book to be printed.
Once the book is printed, the system will prepare order for delivery and trigger the send shipment flow.
In parallel, System will
- Update Loyalty Points for the Customer
- Check future discount eligibility and send discount code for future order
- Update Recommendation Engine
- Send a free eBook for Tips to Better Life

Order Flow - Steps

For creating a Step Function, below are the steps required which I will show in details

Create an IAM Role for the AWS Step function to be able to execute the AWS Services ( eg:- Lambda in this case)
Create Lambda Executor Functions
Create AWS Step Functions with the flow as highlighted above

Order Flow - Step 1 - IAM Roles

1 In the AWS Console, go to Identity and Access Management (IAM), click on Roles in the left hand pane

Click on Create Role
On the next screen, keep the default AWS Service option selected and under the list of Services choose Step Functions
Leave the rest as default and click Next on next 3 screens, Give a Role Name and click Create Role

Great! Step 1 has been completed and we are now ready for Step 2 on creation of the required Lambda functions

Order Flow - Step 2 - Create Lambda

Next step is to create below Lambda functions as per the requirement of our code.

In the IAM console, search Lambda and click on Create Function
Select Author from scratch
Give Function name as per below function names
Select Runtime as Node.js 14.x
Under Permissions, select Use and Existing Role and select the role created at Step 1
Copy-Paste the below code for checkInventory (1 below)
Click Deploy
Now repeat this step for (2-8 lambda code below)
1 - checkInventory

console.log('Loading function checkInventory');

exports.handler = async (event, context) => {

    var x = {ItemStock: 0};

    if (event.bookId == 343222)
      x = {ItemStock: 20};

    return x;  
};

2 - OrderToPrint

console.log('Loading function orderToPrint');

exports.handler = async (event, context) => {
    console.log('Printing the Order Book');

    var retJson = { TotalValue: 500 };

    return retJson;  
};

3 - checkFurtherDiscountEligibility

console.log('Loading function check Further Discount');

exports.handler = async (event, context) => {
    var TotalDiscount = { Discount: 10 };

    if (event.TotalValue > 400){
        TotalDiscount = { Discount: 20 };
    }

    return TotalDiscount; 
};

4 - generateDiscountCode

console.log('Loading function generate Discount Code');

exports.handler = async (event, context) => {
    //console.log('Received event:', JSON.stringify(event, null, 2));
    var Disc = { DiscountCode: "Hello10" };
    if (event.Discount >20 )
       Disc = { DiscountCode: "Hello20" };

    return Disc; 
};

5 - updateLoyaltyPoints

console.log('Loading function update Loyalty Points');

exports.handler = async (event, context) => {
    var LoyaltyPoints = { LoyaltyPoints: event.TotalValue };

    return LoyaltyPoints;  
};

6 - prepareOrder

console.log('Loading function prepare Order');

exports.handler = async (event, context) => {

    var shipmsg = { Shipmsg: "Order Prepared - Ready for Shipment"};

    console.log(' Order Prepared - Ready for Shipment');

    return shipmsg;  
};

7 - sendToShipment

console.log('Loading function send to shipment');

exports.handler = async (event, context) => {
    //console.log('Received event:', JSON.stringify(event, null, 2));

    var shipment = { ShipmentSent : "True" };

    return shipment; 
};

8 - updateRecoEngine

console.log('Loading function update Reco Engine');

exports.handler = async (event, context) => {
    var Reco = { RecoengineUpdated : "True"};
    return Reco;
};

Order Flow - Step 3 - Create Step Functions

In the AWS Console, search Step Functions, click on State Machines in the left hand pane
Click on 'Create State Machine' Button
Choose Authoring method as Design you workflow visually and select Type as Standard, Click Next
On the Next Screen, you can choose to design the workflow by using the Lambda Actions and decision making Flow as per our example statement or you can use the code below

{
  "Comment": "An Order Flow example of the Amazon States Language using Lambda",
  "StartAt": "Order Handling",
  "States": {
    "Order Handling": {
      "Type": "Pass",
      "Next": "CheckInventory"
    },
    "CheckInventory": {
      "Type": "Task",
      "Resource": "arn:aws:states:::lambda:invoke",
      "OutputPath": "$.Payload",
      "Parameters": {
        "Payload.$": "$"
      },
      "Retry": [
        {
          "ErrorEquals": [
            "Lambda.ServiceException",
            "Lambda.AWSLambdaException",
            "Lambda.SdkClientException"
          ],
          "IntervalSeconds": 2,
          "MaxAttempts": 6,
          "BackoffRate": 2
        }
      ],
      "Next": "Choice"
    },
    "Choice": {
      "Type": "Choice",
      "Choices": [
        {
          "Variable": "$.ItemStock",
          "NumericGreaterThan": 0,
          "Next": "Pass"
        }
      ],
      "Default": "OrderPrint"
    },
    "Pass": {
      "Type": "Pass",
      "Next": "Parallel"
    },
    "OrderPrint": {
      "Type": "Task",
      "Resource": "arn:aws:states:::lambda:invoke",
      "OutputPath": "$.Payload",
      "Parameters": {
        "Payload.$": "$"
      },
      "Retry": [
        {
          "ErrorEquals": [
            "Lambda.ServiceException",
            "Lambda.AWSLambdaException",
            "Lambda.SdkClientException"
          ],
          "IntervalSeconds": 2,
          "MaxAttempts": 6,
          "BackoffRate": 2
        }
      ],
      "Next": "Parallel"
    },
    "Parallel": {
      "Type": "Parallel",
      "Branches": [
        {
          "StartAt": "CheckFurtherDiscountEligibility",
          "States": {
            "CheckFurtherDiscountEligibility": {
              "Type": "Task",
              "Resource": "arn:aws:states:::lambda:invoke",
              "OutputPath": "$.Payload",
              "Parameters": {
                "Payload.$": "$"
              },
              "Retry": [
                {
                  "ErrorEquals": [
                    "Lambda.ServiceException",
                    "Lambda.AWSLambdaException",
                    "Lambda.SdkClientException"
                  ],
                  "IntervalSeconds": 2,
                  "MaxAttempts": 6,
                  "BackoffRate": 2
                }
              ],
              "Next": "GenerateDiscountCode"
            },
            "GenerateDiscountCode": {
              "Type": "Task",
              "Resource": "arn:aws:states:::lambda:invoke",
              "OutputPath": "$.Payload",
              "Parameters": {
                "Payload.$": "$"
              },
              "Retry": [
                {
                  "ErrorEquals": [
                    "Lambda.ServiceException",
                    "Lambda.AWSLambdaException",
                    "Lambda.SdkClientException"
                  ],
                  "IntervalSeconds": 2,
                  "MaxAttempts": 6,
                  "BackoffRate": 2
                }
              ],
              "End": true
            }
          }
        },
        {
          "StartAt": "UpdateLoyaltyPoints",
          "States": {
            "UpdateLoyaltyPoints": {
              "Type": "Task",
              "Resource": "arn:aws:states:::lambda:invoke",
              "OutputPath": "$.Payload",
              "Parameters": {
                "Payload.$": "$"
              },
              "Retry": [
                {
                  "ErrorEquals": [
                    "Lambda.ServiceException",
                    "Lambda.AWSLambdaException",
                    "Lambda.SdkClientException"
                  ],
                  "IntervalSeconds": 2,
                  "MaxAttempts": 6,
                  "BackoffRate": 2
                }
              ],
              "End": true
            }
          }
        },
        {
          "StartAt": "PrepareOrder",
          "States": {
            "PrepareOrder": {
              "Type": "Task",
              "Resource": "arn:aws:states:::lambda:invoke",
              "OutputPath": "$.Payload",
              "Parameters": {
                "Payload.$": "$"
              },
              "Retry": [
                {
                  "ErrorEquals": [
                    "Lambda.ServiceException",
                    "Lambda.AWSLambdaException",
                    "Lambda.SdkClientException"
                  ],
                  "IntervalSeconds": 2,
                  "MaxAttempts": 6,
                  "BackoffRate": 2
                }
              ],
              "Next": "SendToShipment"
            },
            "SendToShipment": {
              "Type": "Task",
              "Resource": "arn:aws:states:::lambda:invoke",
              "OutputPath": "$.Payload",
              "Parameters": {
                "Payload.$": "$"
              },
              "Retry": [
                {
                  "ErrorEquals": [
                    "Lambda.ServiceException",
                    "Lambda.AWSLambdaException",
                    "Lambda.SdkClientException"
                  ],
                  "IntervalSeconds": 2,
                  "MaxAttempts": 6,
                  "BackoffRate": 2
                }
              ],
              "End": true
            }
          }
        },
        {
          "StartAt": "UpdateRecoEngine",
          "States": {
            "UpdateRecoEngine": {
              "Type": "Task",
              "Resource": "arn:aws:states:::lambda:invoke",
              "OutputPath": "$.Payload",
              "Parameters": {
                "Payload.$": "$"
              },
              "Retry": [
                {
                  "ErrorEquals": [
                    "Lambda.ServiceException",
                    "Lambda.AWSLambdaException",
                    "Lambda.SdkClientException"
                  ],
                  "IntervalSeconds": 2,
                  "MaxAttempts": 6,
                  "BackoffRate": 2
                }
              ],
              "End": true
            }
          }
        }
      ],
      "Next": "Order Handled"
    },
    "Order Handled": {
      "Type": "Pass",
      "End": true
    }
  }
}

Replace the arn:aws:states:::lambda:invoke with lambda that you specifically created in Step 2.
Click Next, review generated code
Click Next and Specify state name, under permissions, select the existing role that you had created earlier, keep the rest setting as default and click create state machine

Order Flow - Final Testing.

So now you are ready with a working state machine and it's time to test.

Go to State Machine and click on View Details
Click on Start Execution
For the test, i have created two types of inputs, book id = 343222 which has inventory and any other number which will not have inventory, lets try it out now.
Enter the below input: (With Inventory)

{
  "orderId": "123",
  "bookId": "343222"
}

Result is:
** Note it goes to inventory Available flow **

Now lets try another input without inventory

{
  "orderId": "124",
  "bookId": "343122"
}

Result is:
** Note it goes to the book printing flow**