Monday, June 2, 2025

Cloud Setup Cheat Sheet II

In the previous post, we checked out Cloud Cheat Sheet to explain cluster provisioning process for managed cloud providers such as Azure AKS. Now we will resume to provision clusters: Amazon EKS and Google GKE.
Let's check it out!

Pre-Requisites
This blog post assumes an Azure, AWS, GCP account is setup plus all the corresponding CLIs are configured!

AWS Login
Navigate to https://aws.amazon.com | Sign In | Sign in using root user email. Root user | Root user email address e.g. steven_boland@hotmail.com | Next | Enter password. Setup AWS Multi-Factor Authentication.

AWS Single Sign On
Accessing AWS clusters programmatically is recommened to setup and configure AWS SSO. Example config:
  sso_start_url = https://stevepro.awsapps.com/start
  sso_region = eu-west-1
  sso_account_id = 4xxxxxxxxxx8
  sso_role_name = AdministratorAccess
  region = eu-west-1
  output = json

eksctl
Command-line tool that abstracts complexity involved in setting up AWS EKS clusters. Here is how to install:

Linux
 curl --silent --location "https://github.com/eksctl-io/eksctl/releases/latest/download/eksctl_$(uname
 -s)_amd64.tar.gz" | tar xz -C /tmp
 sudo mv /tmp/eksctl /usr/local/bin

Mac OS/X
 brew tap eksctl-io/eksctl  brew install eksctl

Windows
 Launch Powershell  choco install eksctl


Master Key
Next, create master SSH key for secure, automated and controlled access to your Kubernetes infrastructure:
 cd ~/.ssh
 ssh-keygen -t rsa -b 4096 -N '' -f master_ssh_key
 eval $(ssh-agent -s)
 ssh-add master_ssh_key


Amazon EKS
Amazon provides Elastic Kubernetes Service as a fully managed Kubernetes container orchestration service. Follow all instructions below in order to provision a Kubernetes cluster and test its functionality end-to-end. Download code sample here.

Pre-Requisites
  aws sso login

Check Resources
  aws ec2 describe-instances --query 'Reservations[*].Instances[*].InstanceId' --output table
  aws ec2 describe-addresses --query 'Addresses[*].PublicIp' --output table
  aws ec2 describe-key-pairs --query 'KeyPairs[*].KeyName' --output table
  aws ec2 describe-volumes --query 'Volumes[*].VolumeId' --output table
  aws ec2 describe-vpcs --query 'Vpcs[*].VpcId' --output table
  aws cloudformation list-stacks --query 'StackSummaries[*].StackName' --output table
  aws cloudwatch describe-alarms --query 'MetricAlarms[*].AlarmName' --output table
  aws ecr describe-repositories --query 'repositories[*].repositoryName' --output table
  aws ecs list-clusters --query 'clusterArns' --output table
  aws eks list-clusters --query 'clusters' --output table
  aws elasticbeanstalk describe-environments --query 'Environments[*].EnvironmentName' --output table
  aws elb describe-load-balancers --query 'LoadBalancerDescriptions[*].LoadBalancerName' --output table
  aws elbv2 describe-load-balancers --query 'LoadBalancers[*].LoadBalancerName' --output table
  aws iam list-roles --query 'Roles[*].RoleName' --output table
  aws iam list-users --query 'Users[*].UserName' --output table
  aws lambda list-functions --query 'Functions[*].FunctionName' --output table
  aws rds describe-db-instances --query 'DBInstances[*].DBInstanceIdentifier' --output table
  aws route53 list-hosted-zones --query 'HostedZones[*].Name' --output table
  aws s3 ls
  aws sns list-topics --query 'Topics[*].TopicArn' --output table
  aws sqs list-queues --query 'QueueUrls' --output table
  aws ssm describe-parameters --query 'Parameters[*].Name' --output table

Cluster YAML
  kind: ClusterConfig
  apiVersion: eksctl.io/v1alpha5
  
  metadata:
    name: stevepro-aws-eks
    region: eu-west-1
    version: "1.27"
    tags:
      createdBy: stevepro
  
  kubernetesNetworkConfig:
    ipFamily: IPv4
  
  iam:
    withOIDC: true
    serviceAccounts:
    - metadata:
        name: ebs-csi-controller-sa
        namespace: kube-system
      attachPolicyARNs:
      - "arn:aws:iam::aws:policy/service-role/AmazonEBSCSIDriverPolicy"
      roleOnly: true
      roleName: stevepro-aws-eks-AmazonEKS_EBS_CSI_DriverRole
  
  addons:
  - name: aws-ebs-csi-driver
    version: v1.38.1-eksbuild.2
    serviceAccountRoleARN: \
  	arn:aws:iam::4xxxxxxxxxx8:role/stevepro-aws-eks-AmazonEKS_EBS_CSI_DriverRole
  - name: vpc-cni
    version: v1.19.2-eksbuild.1
  - name: coredns
    version: v1.10.1-eksbuild.18
  - name: kube-proxy
    version: v1.27.16-eksbuild.14
  
  nodeGroups:
    - name: stevepro-aws-eks
      instanceType: m5.large
      desiredCapacity: 0
      minSize: 0
      maxSize: 3
      ssh:
        allow: true
        publicKeyPath: ~/.ssh/master_ssh_key.pub
      preBootstrapCommands:
        - "true"

Create Cluster
  eksctl create cluster -f ~/stevepro-awseks/cluster.yaml          \
     --kubeconfig ~/stevepro-awseks/kubeconfig                     \
     --verbose 5

Scale Nodegroup
  eksctl scale nodegroup                                           \
     --cluster=stevepro-aws-eks                                    \
     --name=stevepro-aws-eks                                       \
     --nodes=3                                                     \
     --nodes-min=0                                                 \
     --nodes-max=3                                                 \
     --verbose 5

Deploy Test
  kubectl create ns test-ns
  kubectl config set-context --current --namespace=test-ns
  kubectl apply -f Kubernetes.yaml
  kubectl port-forward service/flask-api-service 8080:80
  curl http://localhost:8080

Output
  Hello World (Python)!

Shell into Node
  kubectl get po -o wide
  cd ~/.ssh
  ssh -i master_ssh_key ec2-user@node-ip-address

Cleanup
  kubectl delete -f Kubernetes.yaml
  kubectl delete ns test-ns

Delete Cluster
  eksctl delete cluster                                            \
     --name=stevepro-aws-eks                                       \
     --region eu-west-1                                            \
     --force

ERRORS
Error: getting availability zones for region operation error EC2: DescribeAvailabilityZones, StatusCode: 403
Reference: Dashboard | IAM | Users | SteveProXNA | Permissions | Add Permission | AdministratorAccess:
  {
     "Version": "2012-10-17",
     "Statement": [
         {
             "Effect": "Allow",
             "Action": "*",
             "Resource": "*"
         }
     ]
  }

Error: unable to determine AMI from SSM Parameter Store: operation SSM: GetParameter, StatusCode: 400
AWS Dashboard | IAM | Users | SteveProXNA | Create new group | Permission | AdministratorAccess-Amplify
  {
     "Version": "2012-10-17",
     "Statement": [
         {
             "Effect": "Allow",
             "Action": ],
                 "ssm:GetParameter",
                 "ssm:GetParameters"
             ],
             "Resource": "arn:aws:ssm:*:*:parameter/aws/service/eks/optimized-ami/*"
         },
         {
             "Effect": "Allow",
             "Action": "ec2:DescribeImages",
             "Resource": "*"
         }
     ]
  }


Google GKE
Google provides the Google Kubernetes Engine as fully managed Kubernetes container orchestration service. Follow all instructions below in order to provision a Kubernetes cluster and test its functionality end-to-end.
Download code sample here.

Pre-Requisites
  gcloud auth login
  gcloud auth application-default login
  gcloud auth configure-docker
  gcloud config set project SteveProProject

Check Resources
  gcloud compute instances list
  gcloud compute disks list
  gcloud compute forwarding-rules list
  gcloud compute firewall-rules list
  gcloud compute addresses list
  gcloud container clusters list

Create Cluster
   gcloud container clusters create stevepro-gcp-gke               \
     --project=steveproproject                                     \
     --zone europe-west1-b                                         \
     --machine-type=e2-standard-2                                  \
     --disk-type pd-standard                                       \
     --cluster-version=1.30.10-gke.1070000                         \
     --num-nodes 3                                                 \
     --network=default                                             \
     --create-subnetwork=name=stevepro-gcp-gke-subnet,range=/28    \
     --enable-ip-alias                                             \
     --enable-intra-node-visibility                                \
     --logging=NONE                                                \
     --monitoring=NONE                                             \
     --enable-network-policy                                       \
     --labels=prefix=stevepro-gcp-gke,created-by=${USER}           \
     --no-enable-managed-prometheus                                \
     --quiet --verbosity debug

Get Credentials
  gcloud container clusters get-credentials stevepro-gcp-gke       \
     --zone=europe-west1-b                                         \
     --quiet --verbosity debug

IMPORTANT - if you do not have the following gke gcloud auth plugin then execute the following commands:
  gcloud components install gke-gcloud-auth-plugin
  gke-gcloud-auth-plugin --version

Deploy Test
  kubectl create ns test-ns
  kubectl config set-context --current --namespace=test-ns
  kubectl apply -f Kubernetes.yaml
  kubectl port-forward service/flask-api-service 8080:80
  curl http://localhost:8080

Output
  Hello World (Python)!

Shell into Node
  mkdir -p ~/GitHub/luksa
  cd ~/GitHub/luksa
  git clone https://github.com/luksa/kubectl-plugins.git
  cd kubectl-plugins
  chmod +x kubectl-ssh
  kubectl get nodes
  ./kubectl-ssh node gke-stevepro-gcp-gke-default-pool-0b4ca8ca-sjpj

Cleanup
  kubectl delete -f Kubernetes.yaml
  kubectl delete ns test-ns

Delete Cluster
  gcloud container clusters delete stevepro-gcp-gke                \
     --zone europe-west1-border                                    \
     --quiet --verbosity debug

Summary
To summarize, we have now setup and provisioned Azure AKS, Amazon EKS and Google GKE clusters with end-to-end tests. In future we could explore provisioning AWS and GCP Kubeadm clusters using Terraform!

Monday, May 5, 2025

Cloud Setup Cheat Sheet

In 2024, we checked out GitLab Cheat Sheet to streamline collaborative team workflows that leverage CI/CD pipelines. Now, we will explain cluster provisioning process for managed cloud providers: Azure, AWS + GCP.
Let's check it out!

Pre-Requisites
This blog post assumes an Azure, AWS, GCP account is setup. The following links document paid or free tier:
 Azure [Microsoft]  AZ  PAID Tier Account  FREE Tier Account
 Amazon Web Services  AWS  PAID Tier Account  FREE Tier Account
 Google Cloud Platform  GCP  PAID Tier Account  FREE Tier Account

Azure CLI
The Azure Command Line Interface is a set of commands used to create and manage Azure resources. The CLI is available across services designed to get working with Azure quickly with an emphasis on automation.

Linux
Install the Azure CLI on Linux | Choose an installation method e.g. apt (Ubunuty, Debian) | Launch Terminal
 curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

Mac OS/X
Install Azure CLI on Mac OS/X | Install with Homebrew | Install Homebrew manager if you haven't already!
 brew update && brew install azure-cli

Windows
Install Azure CLI on Windows | Microsoft Install (MSI) | Download the Latest MSI of the Azure CLI (64-bit)
 Download and install https://aka.ms/installazurecliwindowsx64

After installing the Azure CLI on Linux, Mac OS/X, Windows confirm the current working version of the CLI:
 az version


AWS CLI
The AWS Command Line Interface is a unified tool used to manage your AWS services. Use the AWS CLI tool to download configure and control AWS services from the command line and automate them through scripts.

Linux
Install the AWS CLI on Linux | Linux tab | Command line installer - Linux x86 (64-bit) | Launch the Terminal
 curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
 unzip awscliv2.zip
 sudo ./aws/install

Mac OS/X
Install the AWS CLI on MacOS/X | macOS tab | GUI installer | Download the macOS pkg file AWSCLIV2.pkg
 Download and install https://awscli.amazonaws.com/AWSCLIV2.pkg

Windows
Install the AWS CLI on Windows | Windows tab | Download MSI | Download Windows (64-bit) AWSCLIV2.msi
 Download and install https://awscli.amazonaws.com/AWSCLIV2.msi

After installing the AWS CLI on Linux, Mac OS/X, Windows confirm the current working version of the CLI:
 aws --version


GCP CLI
The GCP Command Line Interface is used to create and manage Google Cloud resources + services directly from the command line and to perform common platform tasks faster by controlling cloud resources at scale.

Linux
Install the gcloud CLI | Linux tab | Platform Linux 64-bit (x86_64) | Launch Terminal + execute commands:
 curl -O https://dl.google.com/dl/cloudsdk/channels/rapid/downloads/google-cloud-cli-linux-x86_64.tar.gz
 tar -xf google-cloud-cli-linux-x86_64.tar.gz
 cd google-cloud-sdk  ./install.sh

Mac OS/X
Install the gcloud CLI | macOS tab | Platform macOS macOS 64-bit (ARM64, Apple silicon) | Launch Terminal
 curl -O https://dl.google.com/dl/cloudsdk/channels/rapid/downloads/google-cloud-cli-darwin-arm.tar.gz
 tar -xf google-cloud-cli-darwin-arm.tar.gz
 cd google-cloud-sdk  ./install.sh

Windows
Install the gcloud CLI | Windows tab | Download the Google Cloud CLI installer GoogleCloudSDKInstaller.exe
 Download and install https://dl.google.com/dl/cloudsdk/channels/rapid/GoogleCloudSDKInstaller.exe

After installing the gcloud CLI on Linux, Mac OS/X, Windows confirm the current working version of the CLI:
 gcloud init  gcloud version


Master Key
Next, create master SSH key for secure, automated and controlled access to your Kubernetes infrastructure:
 cd ~/.ssh
 ssh-keygen -t rsa -b 4096 -N '' -f master_ssh_key
 eval $(ssh-agent -s)
 ssh-add master_ssh_key


Azure AKS
Microsoft provides Azure Kubernetes Services as fully managed Kubernetes container orchestration service. Follow all instructions below in order to provision a Kubernetes cluster and end-to-end test its functionality.
Download code sample here.

Pre-Requisites
  az login

Check Resources
  az account list --output table
  az group list --output table
  az resource list --output table
  az resource list --query "[?location=='northeurope']" --output table
  az vm list --output table
  az aks list --output table
  az container list --output table
  az storage account list --output table
  az network public-ip list --output table

Create Group
  az group create --name stevepro-azraks-rg --location northeurope --debug

Security Principal
  az ad sp create-for-rbac --name ${USER}-sp --skip-assignment

Output
  {
     "appId": "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX",
     "displayName": "stevepro-sp",
     "password": "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX",
     "tenant": "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX",
  }

Export
  export AZ_SP_ID=<value_from_appId>
  export AZ_SP_PASSWORD=<value_from_password>

Create Cluster
  az aks create --name stevepro-azraks                 \
     --resource-group stevepro-azraks-rg               \
     --dns-name-prefix stevepro-azraks                 \
     --node-count 3                                    \
     --node-vm-size Standard_D2s_v3                    \
     --kubernetes-version 1.31                         \
     --ssh-key-value ~/.ssh/master_ssh_key.pub         \
     --service-principal ${AZ_SP_ID}                   \
     --client-secret ${AZ_SP_PASSWORD}                 \
     --load-balancer-sku standard                      \
     --network-plugin azure --debug

Get Credentials
  export KUBECONFIG=~/.kube/config
  az aks get-credentials --name stevepro-azraks        \
     --resource-group stevepro-azraks-rg --file ~/.kube/config

Deploy Test
  kubectl create ns test-ns
  kubectl config set-context --current --namespace=test-ns
  kubectl apply -f Kubernetes.yaml
  kubectl port-forward service/flask-api-service 8080:80
  curl http://localhost:8080

Output
  Hello World (Python)!

Shell into Node
  mkdir -p ~/GitHub/luksa
  cd ~/GitHub/luksa
  git clone https://github.com/luksa/kubectl-plugins.git
  cd kubectl-plugins
  chmod +x kubectl-ssh
  kubectl get nodes
  ./kubectl-ssh node aks-nodepool1-20972701-vmss000000

Cleanup
  kubectl delete -f Kubernetes.yaml
  kubectl delete ns test-ns

Delete Cluster
  az aks delete --name stevepro-azraks                 \
     --resource-group stevepro-azraks-rg

Delete Group
  az group delete --name stevepro-azraks-rg --yes --no-wait
  az group delete --name NetworkWatcherRG --yes --no-wait

Summary
To summarize, we have setup CLIs for Azure, Amazon and Google and provisioned an Azure AKS Kubernetes cluster with end-to-end testing. Next, we will resume to provision clusters for Amazon EKS and Google GKE. This will be the topic of the next post.

Wednesday, January 1, 2025

Retrospective XVI

Last year, I conducted a simple retrospective for 2023. Therefore, here is a retrospective for year 2024.

2024 Achievements
  • Transfer all Windows and Linux keyboard shortcuts and muscle memory to new Mac Book Pro
  • Transfer all important Windows and Linux applications navigations for M1-powered MacBooks
  • Build GitLab CI/CD pipelines extending DevOps skillset and streamline collaborative workflow
  • Provision Kubernetes clusters for GitLab CI/CD pipelines e.g. Azure AKS, AWS-EKS, GCP-GKE
  • Configure Doom open source port for Windows and Linux to debug step thru the source code
  • Launch fulltime Python coding experience to learn AI focusing on RL Reinforcement Learning
  • Experiment with OpenAI Gym project for RL research and build Atari available environments
  • Investigate OpenAI Retro project for RL research on classic Sega 8-bit + 16-bit video games

Note: building OpenAI projects for classic Sega 8/16-bit video games integration is a big achievement!

2025 Objectives
  • Document DevOps managed clusters provisioning experience with AWS / Azure / GCP providers
  • Channel cloud computing knowledge toward software architecture or infrastructure certification
  • Harness Python potential power invoking C/C++ [PyBind11] with code magnitudes times faster
  • Extend OpenAI Gym and Retro projects for more Indie video games + Reinforcement Learning!

Artificial Intelligence
Artificial Intelligence refers to capability of machines to imitate human intelligence. AI empowers machines to acquire knowledge, adapt and independently make decisions like teaching a computer to act human like.

Machine Learning
AI involves a crucial element known as Machine Learning. ML is akin to training computers to improve tasks without providing detailed instructions. Machines utilize data to learn and enhance the performance without explicit programming and concentrates on creating algorithms for computers to learn from data to improve.

Deep Learning
Deep Learning involves artificial neural networks inspired by the human brain: mimicking how human brains work. DL excels at handling complex tasks and large datasets efficiently and achieves remarkable success in areas like natural language processing and computer vision despite complexity and interpretation challenges.

Generative AI
Generative AI is the latest innovation in the AI field. Instead of just identifying patterns GenAI goes one step further by actually attempting to produce new content that closely resembles what humans might create.

Outline
 Artificial Intelligence  Artificial Intelligence is the "big brain"
 Machine Learning  Machine Learning is its learning process
 Deep Learning  Deep Learning is its intricate wiring
 Generative AI  Generative AI is the creative spark


Gen AI and LLMs are revolutionizing our personal and professional lives From supercharged digital assistants to seemingly omniscient chatbots these technologies are driving a new era of convenience, productivity, and connectivity.

Traditional AI uses predictive models to classify data, recognize patterns, + predict outcomes within specific context whereas Gen AI models generate entirely new outputs rather than simply making predictions based on prior experience.

This shift from prediction to creation opens up new realms of innovation: in healthcare traditional predictive model can spot suspicious lesion in lung tissue MRI whereas GenAI could also determine the likelihood that patient will develop pneumonia or other lung diseases and offer treatment recommendations based on best practices gleaned from thousands of similar cases.

Example
GenAI powered healthcare chatbots can assist patients and healthcare providers and medical administrators:
 01. Symptom Checker  07. Mental Health Support
 02. Appointment Scheduling  08. Insurance and Billing Assistance
 03. Medication Reminders  09. Virtual Consultations and Telemedicine
 04. Health Tips and Preventive Care  10. Health Records Access
 05. Lab Results Interpretation  11. Emergency Triage
 06. Chronic Disease Management  

By leveraging conversational AI healthcare chatbot can improve patient engagement and provide real-time support and optimize the workflow for healthcare providers. Finally, Reinforcement Learning From Human Feedback RLHF can be integrated to further improve model performance over original pre-trained version!

Future
Artificial Intelligence is changing industries across the globe from healthcare and finance to marketing and logistics. As we enter 2025, the demand for skilled AI professionals continues to soar. Start out by building strong foundations in Python and understand key concepts such as machine learning and neural networks.

Therefore, whether an AI beginner or seasoned tech professional, here are the top 10 AI skills for success:
 No.  AI Skill Key Tools
 01  Machine Learning (ML) Scikit-learn, TensorFlow, PyTorch
 02  Deep Learning Keras, PyTorch, Google Colab
 03  Natural Language Processing (NLP) NLTK, SpaCy, GPT-based models (e.g., GPT-4)
 04  Data Science and Analytics NumPy, Pandas, Jupyter Notebooks
 05  Computer Vision OpenCV, YOLO (You Only Look Once), TensorFlow
 06  AI Ethics and Bias Mitigation AI Ethics Courses, Fairness Indicators (Google)
 07  AI Infrastructure and Cloud Computing Amazon Web Services, Microsoft Azure, Google Cloud AI
 08  Reinforcement Learning OpenAI Gym, TensorFlow Agents, Stable Baselines3
 09  AI Operations (MLOps) Docker, Kubernetes, Kubeflow, MLflow
 10  Generative AI Generative Adversarial Networks, DALL-E, GPT models

Finally, the GenAI market is poised to explode, growing to $1.3 trillion over the next 10 years from market size of just $40 billion in 2022. Therefore, it would be extraordinary to integrate GenAI to build content for OpenAI-based retro video games only to be trained by Reinforcement Learning algorithms to beat them J

Friday, November 15, 2024

OpenAI Retro Cheat Sheet

In the previous post, we checked out OpenAI Gym: an open source library in Python used for reinforcement learning algorithms development to communicate between environments such as classic Atari video games.

In the this post, we check out OpenAI Retro: source code repository which lets you turn classic video games into Gym environments for reinforcement learning with classic Atari video games and many other Emulated Systems including: Nintendo GameBoy / GameBoy Color, the Sega MegaDrive and the Sega Master System.

Let's check it out!

Gym Retro
In May 2018, Open AI announce Gym Retro: a platform for reinforcement learning research on classic 8-bit and 16-bit video games. The release includes games from the Sega Genesis and Sega Master System, and Nintendo’s NES, SNES, and Game Boy consoles. The release also includes an Integration Tool that lets you create save states, find memory locations + design scenarios that reinforcement learning agents can solve.

Hello Gym Retro
Create new Hello Gym Retro type environment. Launch PyCharm | New Project | Name: HelloGymRetro [~/]

 python -m venv .venv
 pip install gym-retro
 source .venv/bin/activate
 pip install --upgrade pip

CODE
 import retro
 env = retro.make(game="Airstriker-Genesis")
 observation = env.reset()
 
 while True:
    action = env.action_space.sample()
    observation, reward, done, info = env.step(action)
    env.render()
    if done:
        observation = env.reset()
 env.close()

IPMORTANT
At the time of this writing you may experience the following errors. Here are errors encountered + solutions:
 ERROR #1  AttributeError: module 'gym.utils.seeding' has no attribute 'hash_seed'
 Solution  pip uninstall -y gym  pip install gym==0.25.2

 ERROR #2  ModuleNotFoundError: No module named 'gym.envs.classic_control.rendering'
 Solution  pip uninstall -y gym  pip install gym==0.21.0

 ERROR #3   ERROR: Could not find a version that satisfies the requirement gym==0.21.0
 Solution  pip install
 git+https://github.com/openai/gym.git@9180d12e1b66e7e2a1a622614f787a6ec147ac40

Stable Retro
As per previous post, we learned that the lack of maintenance for OpenAI Gym prompted Gymnasium: which is an open source fork of the OpenAI Gym library maintained by The Farama Foundation. As Gym Retro built upon an unmaintained version of the OpenAI Gym library then this may explain errors encountered above J

Similarly, like Gym Retro built upon OpenAI Gym, Stable Retro is built upon Farama Foundation Gymnasium. Stable Retro lets you convert classic video games into Gymnasium environments for Reinforcement Learning!

Hello Stable Retro
Create Hello Stable Retro type environment. Launch PyCharm | New Project | Name: HelloStableRetro [~/]

 python -m venv .venv
 pip install stable-retro
 source .venv/bin/activate
 pip install --upgrade pip

CODE
 import retro
 env = retro.make(game="Airstriker-Genesis")
 observation, info = env.reset()
 
 while True:
    action = env.action_space.sample()
    observation, reward, terminated, truncated, info = env.step(action)
    if terminated or truncated:
        observation, info = env.reset()
 env.close()

Retro Examples
Complete all Retro examples! Extend OpenAI Test repo. Launch PyCharm | New Project | RetroCheatSheet


IMPORTANT
If Python Interpreter not set and/or Virtual Environment not available then choose File | Settings... | Project: Python Interpreter | Add Interpreter | Add Local Interpreter. Launch terminal: source .venv/bin/activate.

Setup ROMs: copy Sega ROM files from the data directory to Virtual Environment via the copy_files.py script
 mkdir data
 mkdir examples
 cd examples
 python copy_files.py


Sega Master System
Launch retro games for the Sega Master System 8-bit video game console with .sms supported ROM types:
 pip install stable-retro
 pip install --upgrade pip
 AlienSyndrome-Sms  RType-Sms
 BladeEagle-Sms  Shinobi-Sms
 DickTracy-Sms  SonicTheHedgehog-Sms
 JamesPond2CodenameRoboCod-Sms  TransBot-Sms


Sega Genesis
Launch retro games for the Sega Genesis [MD] 16-bit video game console with .md supported ROM types:
 pip install stable-retro
 pip install --upgrade pip
 AlteredBeast-Genesis  SonicTheHedgehog2-Genesis
 Flicky-Genesis  SonicTheHedgehog3-Genesis
 GhoulsnGhosts-Genesis  StreetsOfRage2-Genesis
 RevengeOfShinobi-Genesis  Strider-Genesis

YouTube



Pull Request
Finally, setup Pull Request for future contributions. Navigate to stable-retro source repo and Create new fork

Git clone the stable-retro forked source code repository and setup the following Git username and user email
 git config --global --get user.name
 git config --global --get user.email
 git config --global user.name "SteveProXNA"
 git config --global user.email "steven_boland@hotmail.com"

Next, configure the stable-retro upstream destination code repository in order to complete any Pull Request:
 git remote -v
 git remote add upstream git@github.com:Farama-Foundation/stable-retro.git
 origin
 origin
 git@github.com:SteveProXNA/stable-retro.git (fetch)
 git@github.com:SteveProXNA/stable-retro.git (push)
 upstream
 upstream
 git@github.com:Farama-Foundation/stable-retro.git (fetch)
 git@github.com:Farama-Foundation/stable-retro.git (push)


Launch PyCharm | Open Stable-Retro | Create virtual environment | Pip install all dependencies as required:
 pip install -e .
 pip install --upgrade pip

IMPORTANT
If Python Interpreter not set and/or Virtual Environment not available then choose File | Settings... | Project: Python Interpreter | Add Interpreter | Add Local Interpreter. Launch terminal: source .venv/bin/activate.


Examples
Navigate to the examples sub-directory. Checkout trivial_random_agent.py which should resemble the Hello Stable-Retro program above. Airstriker-Genesis ROM is included by default. Copy your Sega games into the corresponding data directory stable | game directory. Update name to the game ROM name. Execute script!


Tests
Navigate to the test_python sub-diretory. Open any test file | right click | Run test or Debug test to step thru source code. Important: you may need to install the pytest package if you get usual ModuleNotFound error:
 pip install pytest
 pip install --upgrade pip



Game Integration
As per the official Gym Retro docs Integrating a game means taking a video game ROM file and setting it up as a reinforcement learning environment by defining 3 things: #1 A starting state, #2 A reward function, #3 A done condition. However, in order to integrate a new game we must have the Game Integration tool setup.

Integration UI
Follow instructions as per video to install all dependencies then build Game Integration UI tool and launch:
 sudo apt-get update
 sudo apt-get install capnproto
 sudo apt-get install libcapnp-dev
 sudo apt-get install libqt5opengl5-dev
 sudo apt-get install qtbase5-dev
 sudo apt-get install zlib1g-dev
 sudo apt autoremove
 cmake . -DBUILD_UI=ON -UPYLIB_DIRECTORY
 make -j$(grep -c ^processor /proc/cpuinfo)
 ./gym-retro-integration



Supported ROMs
ROM files contain the game itself. Each system has a unique file extension to denote the compatible system:
 EXTN SYSTEM EXAMPLE
 a26 Atari 2600 automaton.a26
 gb Nintendo Game Boy dox-fire.gb
 gba Nintendo Game Boy Advance Vantage-LostMarbles.gba
 gg Sega Game Gear benryves-SegaTween.gg
 md Sega Genesis [Mega Drive] Dekadence-Dekadrive.md
 nes Nintendo Entertainment System [Famicom] Dr88-FamiconIntro.nes
 pce NEC TurboGrafx-16 [PC Engine] chrisc-512_Colours.pce
 sfc Super Nintendo Entertainment System [Super Famicom] Anthrox-SineDotDemo.sfc
 sms Sega Master System blind-happy10.sms

Launch CLion | Open Stable-Retro. Navigate to src/ui folder. Open main.cpp. Click "Select CMakeLists.txt":


Navigate to CMakeLists.txt file | OK | Trust Project. Afterwards CLion will index the project and update all symbols. Click Edit configurations drop down list. Choose gym-retro-integration | Debug. Click Debug icon:


Finally, debug tests. Navigate to tests folder. Open data.cpp. Choose tests-data | Debug. Click Debug icon:


Process
Now that we have built the Game Integration tool setup either directly from the CLI and/or built from source it is now possible to integrate new games into Gym-Retro. This process involves: #1 Creating states for Gym Retro environment to load, #2 Inspect ROM memory for points of interest, #3 Find those address and types.

The following videos on OpenAI Game Integration tool Part 1, Part 2, Part 3 give some excellent examples on how to implement this process + create the following necessary files in order to Integrate brand new games:

Files
 State file   Savestate from game beginning. Restart the environment puts agent at this point in the game
 data.json  Defines the list of game-related variables that Python sees based on game memory addresses
 scenario  JSON file defines the reward function and done condition using variables defined at data.json
 metadata  JSON file defines starting state if no state specified by user and miscellaneous debugging info


Summary
To summarize, we have now setup Stable Retro environments for classic 8-bit video game systems like the Sega Master System and 16-bit video game systems like the Sega Genesis [MD] the next step would be to use reinforcement learning to train a bot to play classic emulated video games using this Gym Retro setup.

Consequently, Python NEAT is a popular library for training neural networks using genetic algorithms. There is an excellent Open AI and NEAT Tutorial series that integrates Sonic the Hedgehog as a testbed for applied reinforcement learning to provide a rich, rewarding, and visually complex environment that is well-suited for evolving neural networks. Ultimate goal: would be to use this as inspiration to integrate more Indie games!

Sunday, September 15, 2024

OpenAI Farma Cheat Sheet

OpenAI is an American Artificial Intelligence [AI] research organization founded Dec-2015 head-quartered in San Francisco. In April 2016, OpenAI released a public beta of "OpenAI Gym": its platform for reinforcement learning research. Reinforcement Learning [RL] is an interdisciplinary area of machine learning and optimal control concerned with how an agent takes action in environment in order to maximize cumulative rewards.

In 2021, the non-profit organization Farama Foundation took over Gym. They introduced new features into Gym and renamed the library to Gymnasium where the future maintenance of OpenAI Gym will take place.

Let's check it out!

Gym
OpenAI Gym is an open source Python library for developing reinforcement learning algorithms by providing standard API to communicate between algorithms and environments. Gym soon became widely adopted by the community for creating and training algorithms in various environments for AI Reinforcement Learning.

Gym provides a wide range of environments, including classic control problems, Atari games, and robotics. Gym also includes set of tools for monitoring and evaluating performance of reinforcement learning agents.

Hello Gym
Creating a Gym environment e.g. Cart Pole. Launch PyCharm | New Project | Name: HelloCartPoleGym [~/]

 source .venv/bin/activate
 pip install --upgrade pip
 pip install gym
 pip install gym[classic_control]

CODE
 import gym
 env = gym.make("CartPole-v1", render_mode="human")
 observation, info = env.reset(seed=42)
 
 for _ in range(1000):
    action = env.action_space.sample()
    observation, reward, terminated, truncated, info = env.step(action)
    if terminated or truncated:
        observation, info = env.reset()
 env.close()
YouTube videos online also introduce OpenAI Gym but include Frozen Lake environment and Atari Breakout.


Gymnasium
The main problem with Gym was the lack of maintenance: OpenAI did not allocate substantial resources for the development of Gym since its inception seven years earlier and, by 2020, it simply was not maintained.

Gymnasium is a maintained fork of the OpenAI Gym library. The Gymnasium interface is simple, pythonic, and capable of representing general RL problems with a compatibility wrapper for old Gym environments:

Hello Gymnasium
Creating /Gymnasium environment e.g. Cart Pole. Launch PyCharm | New Project | HelloCartPoleGymnasium

 source .venv/bin/activate
 pip install --upgrade pip
 pip install gymnasium
 pip install gymnasium[classic-control]

CODE
 import gymnasium as gym
 env = gym.make("CartPole-v1", render_mode="human")
 observation, info = env.reset(seed=42)
 
 for _ in range(1000):
    action = env.action_space.sample()
    observation, reward, terminated, truncated, info = env.step(action)
    if terminated or truncated:
        observation, info = env.reset()
 env.close()

Differences
While both Gym and Gymnasium are powerful tools for creating environments for reinforcement learning, it makes more sense to prefer Gymnasium going forward as technically future support for Gym there is none. Note: old import gym documentation is replaced with import gymnasium as gym convention going forward.


Farama Examples
Complete all Farama examples! Create OpenAI Test repo. Launch PyCharm | New Project | FarmaCheatSheet

IMPORTANT
If Python Interpreter not set and/or Virtual Environment not available then choose File | Settings... | Project: Python Interpreter | Add Interpreter | Add Local Interpreter. Launch terminal: source .venv/bin/activate.

Copy the official Gymnasium requirements.txt from the Farama Foundation GitHub repository docs directory:
 pip install -r requirements.txt
 pip install --upgrade pip

Classic Control
There are five Classic Control environments which are stochastic in terms of initial state within given range.
 pip install gymnasium
 Acrobot-v1 CartPole-v1 MountainCar-v0 Pendulum-v1

Toy Text
Toy Text environments are designed to be extremely simple, with small discrete state and action spaces, and hence easy to learn. They are suitable for debugging implementations of reinforcement learning algorithms.
 pip install gymnasium
 Blackjack-v1 CliffWalking-v0 FrozenLake-v1 Taxi-v3

Box2D
Box2D environments involve toy games based around box2d physics control and PyGame-based rendering.
 pip install gymnasium  pip install Box2D
 BipedalWalker-v3 CarRacing-v2 LunarLander-v2

MuJoCo
MuJoCo [Multi-Joint dynamics with Contact] is physics engine for facilitating research and development in robotics, biomechanics, graphics and animation, also areas where fast and accurate simulation is needed.
 pip install gymnasium  pip install mujoco==2.3.0
 Ant-v4 Humanoid-v4 InvertedPendulum-v4 Swimmer-v4
 HalfCheetah-v4 HumanoidStandup-v4 Pusher-v4 Walker2d-v4
 Hopper-v4 InvertedDoublePendulum-v4 Reacher-v4 

Atari
Atari environments are simulated via the Arcade Learning Environment (ALE) through the Stella emulator.
 pip install gymnasium[atari]  pip install gymnasium[accept-rom-license]
 Adventure-v5 Defender-v5 KeystoneKapers-v5 Seaquest-v5
 AirRaid-v5 DemonAttack-v5 KingKong-v5 SirLancelot-v5
 Alien-v5 DonkeyKong-v5 Klax-v5 Skiing-v5
 Amidar-v5 DoubleDunk-v5 Koolaid-v5 Solaris-v5
 Assault-v5 Earthworld-v5 Krull-v5 SpaceInvaders-v5
 Asterix-v5 ElevatorAction-v5 KungFuMaster-v5 SpaceWar-v5
 Asteroids-v5 Enduro-v5 LaserGates-v5 StarGunner-v5
 Atlantis-v5 Entombed-v5 LostLuggage-v5 Superman-v5
 Atlantis2-v5 Et-v5 MarioBros-v5 Surround-v5
 Backgammon-v5 FishingDerby-v5 MiniatureGolf-v5 Tennis-v5
 BankHeist-v5 FlagCapture-v5 MontezumaRevenge-v5 Tetris-v5
 BasicMath-v5 Freeway-v5 MrDo-v5 TicTacToe3D-v5
 BattleZone-v5 Frogger-v5 MsPacman-v5 TimePilot-v5
 BeamRider-v5 Frostbite-v5 NameThisGame-v5 Trondead-v5
 Berzerk-v5 Galaxian-v5 Othello-v5 Turmoil-v5
 Blackjack-v5 Gopher-v5 Pacman-v5 Tutankham-v5
 Bowling-v5 Gravitar-v5 Phoenix-v5 UpNDown-v5
 Boxing-v5 Hangman-v5 Pitfall-v5 Venture-v5
 Breakout-v5 HauntedHouse-v5 Pitfall2-v5 VideoCheckers-v5
 Carnival-v5 Hero-v5 Pong-v5 VideoChess-v5
 Casino-v5 HumanCannonball-v5 Pooyan-v5 VideoCube-v5
 Centipede-v5 IceHockey-v5 PrivateEye-v5 VideoPinball-v5
 ChopperCommand-v5 Jamesbond-v5 Qbert-v5 WizardOfWor-v5
 CrazyClimber-v5 JourneyEscape-v5 Riverraid-v5 WordZapper-v5
 Crossbow-v5 Kaboom-v5 RoadRunner-v5 YarsRevenge-v5
 Darkchambers-v5 Kangaroo-v5 Robotank-v5 Zaxxon-v5


Pull Request
Finally, submit Pull Request: upload Farma examples. Navigate to source Gymnasium repo | Create new fork

Git clone the forked Gymnasium source code repository and setup the following Git username and useremail
 git config --global --get user.name
 git config --global --get user.email
 git config --global user.name "SteveProXNA"
 git config --global user.email "steven_boland@hotmail.com"

Next, configure the Gymnasium upstream destination code repository in order to complete the Pull Request:
 git remote -v
 git remote add upstream git@github.com:Farama-Foundation/Gymnasium.git
 origin
 origin
 git@github.com:SteveProXNA/Gymnasium.git (fetch)
 git@github.com:SteveProXNA/Gymnasium.git (push)
 upstream
 upstream
 git@github.com:Farama-Foundation/Gymnasium.git (fetch)
 git@github.com:Farama-Foundation/Gymnasium.git (push)



Launch PyCharm | Open Gymnasium | Create virtual environment | Install requirements as pre-requisites:
 pip install -r docs/requirements.txt
 pip install --upgrade pip

Uncomment game from ClassicControl sub-directory files.txt or ToyText files.txt. Open main.py. Run script:

Install Box2D and MuJoCo dependencies. Uncomment game from Box2D files.txt or MuJoCo. Run main.py:
 Box2D
 pip install Box2D
 MuJoCo
 pip install mujoco==2.3.0


Finally, in order to integrate Atari game examples I found this only worked cut from tag v0.29.1 [81b87ef]:
 git fetch --tags --prune --prune-tags
 git fetch --all
 git tag | grep v0.29.1
 git checkout tags/v0.29.1

It seems after tag v0.29.1 any Atari game may throw the following: gymnasium.error.NamespaceNotFound: Namespace ALE not found. Have you installed the proper package for ALE?. Resume Atari tag v0.29.1 setup:
 pip install gymnasium[atari]  pip install gymnasium[accept-rom-license]



Retrospectives
In Jan-2020 Retrospective XI, we learned about an interesting development connecting Artificial Intelligence and retro video games leveraging Reinforcement Learning. In Jan-2021 Retrospective XII, we then discussed video games as an interesting field of study and retro game development of Pacman and Doom clones as an excellent avenue to pursue with regards to future applications in software with Artificial Intelligence and RL.

Consequently, in the previous post, we disovered how to debug step thru cloned versions of Doom to better understand the original source code: an important pre-requisite to extend knowledge for further research in reinforcement learning, in particular. For example, ViZDoom allows developing AI bots that play Doom using visual data. In 2022, ViZDoom joined Farama Foundation featuring new Gymnasium environment wrappers.


Summary
To summarize, we have now setup Gymnasium environments for Classic Control, Toy Text, Box 2D, MuJo Co and Atari. NB: all Atari environments leverage the Atari Arcade Learning Environment [ALE] emulator Stella.

In fact, reverting back to OpenAI which hosts the Retro Git source code repository, also including Emulated Systems like Atari. However, Retro also includes many other Emulated Systems we have developed for in the past including Nintendo GameBoy / GameBoy Color, Sega MegaDrive and or course the Sega Master System! This will be the topic of the next post.