Linux Security, AI, Docker And Cloud With Hands-On Labs

Set up a Linux server on AWS using EC2, Ubuntu, and SSH access, then prepare the system by updating packages, installing tools, and configuring a Python environment for AI applications.

Explore why cloud computing offers scalable, high performance, accessible servers for AI. Learn AWS EC2 and provisioning a Linux server on the cloud, with local alternatives if needed.

Connect to your AWS VM from your local system using MobaXterm by entering the public IP, the Ubuntu user, and the private key in SSH settings to access the server.

Master the Linux filesystem hierarchy by understanding the root tree and key directories like /home, /etc, /bin, /usr, and /var, where everything is treated as a file.

Explore Linux commands to navigate and manage files: pwd shows your location, cd changes directories, ls lists contents, and mkdir, touch, rm, and rmdir create or remove files and folders.

Create and edit files with the vi editor by entering insert mode with i, saving and exiting with escape then colon wq, and viewing content with cat.

Learn to change file permissions with chmod using numeric codes: read 4, write 2, execute 1, and set owner, group, and others (7, 6, 0) as shown.

Learn how to use the chown command to change file ownership, elevating privileges with sudo to switch from Ubuntu to another user, and verify ownership on files such as backup.txt.

Master apt on Ubuntu by updating, upgrading, and installing packages from the terminal, with commands like sudo apt update, sudo apt upgrade, and sudo apt install.

Learn hands-on package management with apt by installing git and docker.io from the terminal, verifying versions, and understanding dependencies in real-world Linux setups.

Learn to list environment and system variables with print env, create and print shell variables with echo, and export them so child scripts can inherit them in bash.

Learn to set up python on ubuntu for ai development, verify python3, install pip, and add libraries like numpy, pandas, and OpenAI via pip; create a virtual environment.

Learn how to manage Python dependencies by using a virtual environment, capturing installed libraries in a requirements.txt with pip freeze, and reinstalling them with pip install -r requirements.txt.

Implement a real-time GitHub info fetcher using Python and the requests library, querying the GitHub API for user data in AI-backed cloud back-end contexts.

Learn to run ai models on Linux by installing NumPy, PyTorch, and Transformers, explore Hugging Face, and load a real text generation model in a hands-on lab.

Build your first AI script on Linux using a Python program with Transformers, PyTorch, and NumPy to generate text from user input with a GPT-2 model.

Run a Python script to load the GPT-2 pre-trained model on a Linux system, downloading the full model on first run and generating outputs from prompts.

Discover how transformers and Hugging Face enable access to pre-trained models like GPT-2 in code, by loading from Hugging Face and running locally with the transformers library.

Explore artificial intelligence text generation flow from user input to readable output using a GPT-2 model, including tokenization, tokens, attention masks, and decoding in a PyTorch and transformers script.

Discover Generative AI, which creates new content by learning from data instead of fixed rules. Generate text, images, audio, and code with tools like ChatGPT and GitHub Copilot.

It explains that a large language model powers generative AI by predicting the next word from vast training data. It uses patterns and probability to produce natural text.

Trace how an llm works: input a prompt, the model processes text to understand context, predicts the next word, and continues generating to form a final, human-like response in seconds.

Explore common large language model examples, including ChatGPT and GPT-2/3 with newer versions, and HuggingFace models like BERT and DistalBERT, all powering text generation and understanding in real-world applications.

Compare OpenAI and HuggingFace on api based usage and local setup, noting OpenAI's limited control and cost, HuggingFace's full control and open source models.

Install the OpenAI Python library with pip, verify with pip list, and create chatbot.py using vi to initialize the OpenAI client with an API key to enable AI communication.

Write Python code to build an AI chatbot using the OpenAI library, authenticate with an API key, and send user input to the GPT-4o mini model.

Explore docker fundamentals with dockerfile, image, and container concepts, including base images, dependencies, and running apps. Learn benefits like consistency, portability, isolation, fast deployment, and production readiness.

Replace the python virtual environment with docker by writing a docker file, building a docker image, and running the AI chatbot as a container for portable, production-ready deployment.

Create a dockerfile to define how your chatbot runs in a container using a python:3.10 base image, copy files to /app, and set the default command python chatbot.py.

Create a chatbot by wiring chatbot.py in a docker setup, loading the API key from .env, sending user input to an OpenAI model and displaying the response, and handling errors.

Install docker on Ubuntu, update the system and install docker.io, verify the service runs, fix permissions by adding the user to the docker group, and test with hello world.

Build a docker image from a Dockerfile by running docker build -t ai-chatbot . in the project directory, using the Dockerfile to install requirements and create the image.

Launch the ai-chatbot in a docker container with interactive mode and an env-file to securely load API keys from .env and interact with the AI model.