Tech Journal 📚

AI and ML: Understanding the Basics in Simple Words

Raghul M — Mon, 08 Sep 2025 10:03:17 GMT

For a long time, I’ve been fascinated by Artificial Intelligence (AI) and how it’s shaping the world around us. But I’ve noticed that many people struggle with the basics AI/ML terms often feel full of jargon and hard to grasp. So, in this blog, I’ll break down these concepts in simple words, making it easier for anyone to get started with AI and ML.

What is AI?

AI (Artificial Intelligence) is a broad field that focuses on making machines simulate human-like intelligence. It covers multiple areas such as:

Machine Learning (ML) – teaching machines to learn from data .
Deep Learning (DL) – neural networks that handle complex data like images and text .Mimic Humain brains .

Think of AI as the umbrella, and ML/DL as important branches under it.

What is Machine Learning (ML) ?

Machine Learning is a Discipline in computer science where we train machines on data so that they can make predictions without explicit programming . This shift makes ML powerful the machine learns patterns from data and improves over time.

ML Has Two Key Parts : Training and Inference

Training
- In this phase, the model learns patterns from data.
- You provide the input (features) along with the correct output (labels).
- The model adjusts its internal parameters (weights) to minimize errors.
- Example: Training a model with thousands of house price records so it learns how features like size, location, and age affect the price.
- Training = Learning phase
Inference
- Once the model is trained, you use it to make predictions on new, unseen data.
- No labels are given here the model uses what it has already learned.
- Example: Feeding in details of a new house picture to predict its price.
- Inference = Using that knowledge to make predictions

ML Learning Styles :

There are three main learning paradigms (styles) in ML Common to Both Statistical ML and DL :

Supervised Learning – Uses labeled data. Example: Predicting if an email is spam or not.
Unsupervised Learning – Works with unlabeled data. It learns to identify patterns and structures in data without any explicit guidance Example: Grouping customers into clusters.
Reinforcement Learning (RL) – The model learns by trial and error, receiving rewards or penalties. RL is also used in training modern Large Language Models (LLMs) with a method called RLHF (Reinforcement Learning with Human Feedback). Example : It is used in LLM trainings like GPT , Claude .

Machine Learning has two main tasks :

Classification : It is about predicting categories (e.g., spam or not spam, cat or dog).
Regression : Its about predicting a continous numeric value (not a category) . give some important features , predict a number ( eg: House price prediction ) .Its like predicting the next numbers based on the trained numeric data .

Structured vs. Unstructured Data

Structured Data → Tabular, numbers, relational databases. (Good for classical ML).
Unstructured Data → Images, text, audio, video. (Needs Deep Learning).
Semi-Structured Data → JSON, XML, log files.

Deep learning :

. Deep Learning is a subset of Machine Learning that uses artificial neural networks to learn from large amounts of data. It mimics the way the human brain processes information recognizing patterns, learning from experience, and making decisions.

The main strength of deep learning lies in its ability to handle unstructured data like images, audio, and text, which traditional ML struggles with.

Neural Network Architectures :

Feed Forward Neural Network ( FNN ) - Basic prediction tasks ( eg; Predicting house prices based on size, location, etc. )
Recurrent Neural Network ( RNN ) - Sequences/time-series (eg; Language modeling, time-series forecasting, speech recognition.)
Convolutional Neural Network ( CNN ) - Images/videos ( eg; Facial recognition, medical image analysis, self-driving cars. )
Transformers - Advanced text and language tasks ( eg; Machine translation, chatbots, text summarization, code generation. )

Statistical Machine Learning vs Deep Learning :

Both Statistical Machine Learning (classic ML) and Deep Learning fall under ML, but they shine in different scenarios .

Aspect	Statistical ML	Deep Learning
Data Type	Works well with simple, structured data (tabular, numeric)	Best for complex, unstructured data (images, text, audio, video)
Dataset Size	Small to medium datasets	Large-scale, big datasets
Features	Relies on handcrafted features (feature engineering is crucial)	Automatically learns complex features from raw data
Compute Resources	Runs on normal CPUs, less computationally heavy	Requires GPUs/TPUs and high compute power
Interpretability	Easy to interpret and explain results	Harder to interpret (acts like a black box)
Examples	Logistic Regression, Decision Trees, Random Forest	CNNs, RNNs, Transformers

Conclusion :

AI and ML may sound filled with heavy jargon, but once you break them down, the core ideas are simple and exciting. From statistical ML handling structured data to deep learning powering today’s breakthroughs in images, speech, and large language models, both approaches play a key role in shaping the intelligent systems we use daily.

Connect with me on Linkedin: Raghul M

vLLM ? The Simple Guide for Non-Devs and Curious Minds

Raghul M — Thu, 31 Jul 2025 17:48:36 GMT

Large language models (LLMs) like ChatGPT, LLaMA, and Mistral are incredibly powerful, but they're also resource-hungry. They need lots of memory and processing power to respond to a single prompt, let alone handle multiple users. So how do you run a big LLM efficiently especially if you want to host it yourself ?

Thats where vLLM plays an vital role an open-source engine designed to serve large language models efficiently, quickly, and at scale.

This blog is your plain-layman term guide to understanding what vLLM is, how it works, and why it's a game-changer for running LLMs.

What Is vLLM (And Why Should You Care)?

Imagine you want to build your own chatbot, just like ChatGPT, but hosted on your own machine or cloud. You need it to:

Handle long conversations
Support multiple users at once
Be fast and responsive

vLLM ("Virtualized LLM") is a backend engine that makes this possible. It works under the hood to serve models like LLaMA , Qwen and Mistral while keeping GPU memory usage efficient and response times low.

Let’s break down the main ideas behind vLLM in simple terms:

1. Tokens

LLMs don’t understand words directly. They split your input into smaller units called tokens. For example, "chatbot" might become "chat" + "bot".

2. Attention

When the model generates the next word, it looks back at previous tokens and decides which ones matter most. This is called attention.

3. KV (Key-Value) Cache

As the model processes input, it saves information about each token from past querys into a memory bank. This is the KV cache, which lets the model remember the conversation.

4. PagedAttention (The Magic)

Normally, the KV cache grows as the conversation gets longer. That eats up GPU memory fast. PagedAttention solves this by:

Storing memory in chunks (called pages)
Swapping pages in and out of GPU as needed

It’s like working at a small desk: you keep only the important notes on your desk and file away the rest, pulling them out only when you need them.

5. vLLM Engine

This is the smart part of the system. It:

Loads the model
Tokenizes the input
Manages the KV cache using PagedAttention
Streams the output

All while keeping GPU usage low and performance high.

6. OpenAI-Compatible API

vLLM exposes an API that looks exactly like OpenAI's API Endpoints .

Refer this : https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html

Why vLLM Matters

Here’s why developers and organizations are excited about vLLM:

Fast - Generates responses quickly, even for long chats.
Scalable - Can handle multiple users at once.
Memory-efficient - Thanks to PagedAttention.
Easy to integrate - Compatible with OpenAI-style APIs.

If you want to build apps like ChatGPT, or host your own LLMs securely, vLLM is the engine you want.

A Simple Chatbot Flow with vLLM

User asks: "Tell me a joke."
Input gets tokenized.
Model checks previous tokens (if any) using attention.
vLLM loads needed memory pages.
Response is generated and streamed back.

And it does this fast, even if you’re chatting with multiple users.

Conclusion

vLLM = fast, memory-efficient LLM serving engine with an OpenAI-like API.

You now understand:

What attention, KV cache, and PagedAttention mean
Why vLLM is better than regular model serving
How it fits into chatbot pipelines

If you're building with LLMs and want speed, scale, and control, vLLM is 100% worth checking out.

Connect with me on Linkedin: Raghul M

Understanding Reverse Proxy and Forward Proxy — The Simple Way

Raghul M — Sun, 11 May 2025 09:05:43 GMT

When we browse the internet, a lot happens behind the scenes. One such hidden hero is the proxy. Whether it’s keeping your identity safe, speeding things up, or managing requests, proxies silently work in the background to make your online experience smoother. Let's break it all down.

What Is a Proxy?

A proxy is like a middleman between you and the internet. Instead of directly connecting to a website, your request first goes to a proxy server. That server then talks to the website on your behalf.

Imagine you’re at a party and want to ask someone a question, but instead of going directly, you ask your friend to pass the message. Your friend is the proxy.

Why Use a Proxy?

There are many reasons to use a proxy:

To hide your identity (IP address)
To filter content (like blocking social media at work)
To speed up browsing using cached content
To add a layer of security and control over traffic

📌

Now, proxies come in two main flavors: Reverse Proxy and Forward Proxy. Let’s explore both.

What Is a Reverse Proxy?

A Reverse Proxy sits in front of one or more servers and handles requests from clients (like users) to those servers.

Think of it like a receptionist in an office. When visitors come in (users), the receptionist decides which employee (server) should handle the request.

✅ Why Use a Reverse Proxy?

Load Balancing – It distributes traffic to different servers to avoid overload.
Security – It hides the internal structure of your servers from outsiders.
Caching – It can store frequent responses and send them faster.
SSL Termination – It handles HTTPS encryption, reducing work on backend servers.

What Is a Forward Proxy?

A Forward Proxy sits in front of the client (user) and makes requests to websites on the user’s behalf.

Imagine you're in a country where a website is blocked. You tell your friend in another country to access it and send it to you. That friend is acting as your forward proxy.

✅ Why Use a Forward Proxy?

Bypass restrictions – Like accessing blocked websites.
Hide your IP address – Helps with anonymity.
Content filtering – Schools and offices use it to block certain sites.
Monitoring – Organizations track employee usage.

Differences Between Forward and Reverse Proxy

Feature	Forward Proxy	Reverse Proxy
Who uses it?	The client (user)	The server side
Purpose	Access control & privacy for users	Load balancing, caching & security
Hides identity of	The user	The server
Example Use Case	Accessing a blocked website	Managing multiple backend servers

Why Are Proxies Important? (In DevOps)

In DevOps, proxies are crucial for:

🔐 Security – Hide backend servers and control access.
⚖️ Load Balancing – Distribute traffic across services.
🚀 Performance – Cache content to speed up responses.
🧪 Build Control – Restrict internet access in CI/CD.
🧩 Microservices – Enable smooth, secure communication.

Conclusion

Proxies aren’t just networking tools — they’re a core part of modern DevOps. From security to scalability, proxies help teams build reliable and efficient systems.

✅ Forward Proxy: Acts on behalf of the client (user). It hides the client’s identity from the server.
✅ Reverse Proxy: Acts on behalf of the server. It hides the server’s identity from the client.

In the next post, we'll explore hands-on proxy setups and real-world use cases using NGINX. Stay tuned!

Connect with me on Linkedin: Raghul M

How I Turned an Old Laptop into a Local AI Server (for Free!) with Ollama + Cloudflare Tunnel

Raghul M — Fri, 11 Apr 2025 15:10:08 GMT

Introduction :

I had an old laptop and a wild idea…

Most GenAI tools need expensive GPUs or cloud credits. I had neither. So, I asked myself can I run a language model locally, without the cloud, and still make it accessible from anywhere?

Turns out, yes and it was surprisingly fun. Here’s exactly how I built a self-hosted AI server using Ollama and Cloudflare Tunnel, step-by-step.

Project overview :

Hardware & OS Setup 💻

I used an old laptop with the following specs:

Storage: 465 GB
RAM: 4 GB
OS: Xubuntu (lightweight and efficient) / Linux Mint (Any Linux you can use )

Why Xubuntu/Linux Mint?

Low memory usage
Fast performance on older hardware
Easy to set up and supports modern tools

Installing Ollama :

Ollama is a powerful CLI tool that allows you to run and interact with language models locally. Here's how I installed it:

$ curl -fsSL https://ollama.com/install.sh | sh

Then I pulled a lightweight model for fast performance:

$ ollama pull tinyllama

I later tried deepseek-r1:1.5b and it worked great too!

🔄 Serving the LLM

To serve the model and make it accessible:

$ OLLAMA_HOST=0.0.0.0 ollama serve

Note: If you run into address already in use, try a different port using:

$ OLLAMA_HOST=0.0.0.0 OLLAMA_PORT=11435 ollama serve

Verify it's working: It will list all the models available

$ curl http://localhost:11435/api/tags

Exposing Ollma Localhost with Cloudflare Tunnel

To make the local server publicly accessible, I used Cloudflare Tunnel. Open new terminal and install Cloudflared tunnel

$ wget https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64 -o cloudflared
$ chmod +x cloudflared

To verify the installation Run this command :

$ cloudflared --version

Once verified lets expose the localhost using Cloudflared

$ cloudflared tunnel --url http://localhost:11435

This gives you a public URL like:

https://your-unique-subdomain.trycloudflare.com

Now your Ollama model is accessible from anywhere securely! You can use it via curl or api from any application .

curl https://your-unique-subdomain.trycloudflare.com/api/generate -d '{
  "model": "deepseek-r1r:1.5b",
  "prompt": "Write a Python function to reverse a string"
}'

🌐 Creating a Streamlit Frontend

I built a Streamlit app to interact with the model easily:

import streamlit as st
import requests

# --- Config ---
OLLAMA_BASE_URL = "https://your-unique-subdomain.trycloudflare.com"  # or your tunnel domain
TAGS_URL = f"{OLLAMA_BASE_URL}/api/tags"
GENERATE_URL = f"{OLLAMA_BASE_URL}/api/generate"

# --- Page Settings ---
st.set_page_config(page_title="Ollama Chat", layout="centered")
st.title("🧠 Ollama Chat Interface")

# --- Fetch Models ---
@st.cache_data
def fetch_models():
    try:
        response = requests.get(TAGS_URL)
        if response.status_code == 200:
            data = response.json()
            models = [model["name"] for model in data.get("models", [])]
            return models
        else:
            st.error(f"Failed to fetch models: {response.status_code}")
            return []
    except Exception as e:
        st.error(f"Error fetching models: {e}")
        return []

# --- UI: Select Model ---
models = fetch_models()
if not models:
    st.warning("No models available. Please load a model into Ollama.")
    st.stop()

selected_model = st.selectbox("📦 Choose a model:", models)

# --- UI: Prompt Input ---
prompt = st.text_area("💬 Enter your prompt:", height=200)

if st.button("🚀 Generate Response"):
    if not prompt.strip():
        st.warning("Prompt cannot be empty.")
    else:
        with st.spinner("Generating response..."):
            payload = {
                "model": selected_model,
                "prompt": prompt,
                "stream": False
            }
            try:
                response = requests.post(GENERATE_URL, json=payload)
                if response.status_code == 200:
                    result = response.json()
                    st.markdown("### ✅ Response")
                    st.write(result.get("response", "No response received."))
                else:
                    st.error(f"Error {response.status_code}: {response.text}")
            except Exception as e:
                st.error(f"Request failed: {e}")

📊 Bonus Tips

Use htop or glances to monitor memory and CPU.
Check disk usage with lsblk and df -h.
Use lightweight models for fast inference on low-end machines.

🚀 What You Can Build

Personal chatbot
Code generation tool
Lightweight AI backend for your apps
Home AI server on a budget

📖 Conclusion :

This project proved something awesome . that you don’t need top-tier hardware to experiment with AI. With a bit of creativity and the right tools, even an old laptop can become a powerful AI playground.

Feel free to check out the GitHub repository for the complete setup.

If you try this out or want help replicating it – feel free to reach out! Raghul M

Ollama & OpenWebUI Setup Guide: Run LLMs Locally with Ease

Raghul M — Fri, 21 Mar 2025 10:21:40 GMT

Introduction

Image source : https://www.packetswitch.co.uk/

Ollama is an open-source tool designed to help developers run and develop large language models (LLMs) locally on their machines. It enables efficient AI model execution without relying on cloud-based services, ensuring cost-effectiveness, privacy, and performance.

🔗 Download Ollama: Ollama Official Website

Ollama Commands

1. Running a Model:

$ ollama run

Checks if the model is available locally; if not, it pulls it from the Ollama model registry and run the model

2. Starting the API Server:

$ ollama serve

Runs the Ollama API on port 11434.

3. Verifying Model Integrity:

$ ollama check

Uses SHA-256 digest to confirm authenticity.

4. Listing Available Models:

$ ollama list

Displays the locally available models.

5. Pulling a Model from the Registry:

$ ollama pull

Downloads a model from the Ollama registry.

6. Pushing a Model to the Registry:

$ ollama push username:

Uploads a custom model to the Ollama registry.

7. Creating a Custom Model:

$ ollama create my_custom_model -f ./Modelfile

Builds a custom model based on the configuration in a Modelfile.

8. Check avilable commands:

$ /?

Available Commands:
  /set            Set session variables
  /show           Show model information
  /load    Load a session or model
  /save    Save your current session
  /clear          Clear session context
  /bye            Exit
  /?, /help       Help for a command
  /? shortcuts    Help for keyboard shortcuts

REST API Endpoints

Ollama provides REST API endpoints to interact with models programmatically.

Ollama REST API endpoints :

POST /api/generate   # Generates responses (supports streaming option).
POST /api/chat       # Chat Interaction - Handles chat-based interactions.
GET /api/models      # Returns a list of installed models.
POST /api/pull       # Pulls a model from the Ollama registry
POST /api/push.      # Uploads a locally built model to the Ollama registry.
GET /api/status.     # Returns the current status of the running Ollama API.

Creating and Managing Custom Models

Creating a Custom Image

To create a custom model, follow these steps:

Create a Modelfile with the necessary configurations:

FROM BASE_MODEL:TAG
PARAMETER temperature 0.2
SYSTEM "You are a helpful assistant."
MESSAGE "Welcome to Ollama!"

Build the model:

$ ollama create my_custom_model -f ./Modelfile

Pushing a Custom Model to the Registry

$ ollama push my_custom_model

This command uploads the locally built model to the Ollama registry.

Pulling a Model from the Ollama Registry

$ ollama pull username:my_custom_model

Downloads and installs a model from the Ollama registry for local use.

Using Ollama with Python

Ollama can be integrated with Python to generate AI-powered responses. Below is an example using the requests library:

import ollama

response = ollama.generate(
    model="deepseek-r1",
    prompt="What is Deepseek?"
)

print(response["response"])

This script sends a request to the Ollama API running locally, generates a response using the specified model, and prints the output.

Setting Up OpenWebUI with Ollama

OpenWebUI is a user-friendly interface that enhances the experience of interacting with LLMs like Ollama.

Running OpenWebUI with Docker

You can easily set up OpenWebUI using Docker with the following command:

$ docker run -d --name open-webui -p 3000:3000 -e OLLAMA_BASE_URL=http://localhost:11434 --restart always ghcr.io/open-webui/open-webui:main

This runs OpenWebUI as a Docker container and connects it to your local Ollama instance.
Access OpenWebUI at http://localhost:3000.

Conclusion :

Ollama provides a powerful way to run LLMs locally, ensuring privacy, performance, and cost-effectiveness. With its easy-to-use CLI commands, REST API support, Python integration, and OpenWebUI interface, it’s a great tool for developers looking to build AI applications without relying on cloud-based services.

🚀 Ready to explore Ollama? Download it today and start running your own AI models locally!

Connect with me on Linkedin: Raghul M

💬 Have questions or feedback? Drop them in the comments below!

Understanding Embeddings : How AI Learns Meaning from Text, Images, and Data

Raghul M — Wed, 05 Feb 2025 13:23:34 GMT

Hey Everyone 👋🏻 !

In my previous blog, we explored how Transformers work and how they revolutionized modern AI, paving the way for major advancements.

Today, let's dive into embeddings—the foundation of Large Language Models (LLMs). We'll cover how embeddings work, different types of embeddings, and their applications. Let's get started!

What is an Embedding?

An embedding is a numerical representation of data (words, sentences, images, videos, audio, documents) in a vector format within a multidimensional space. These representations capture meaning and relationships between data points.

It is also known as a vector embedding.

📌 Example:

Image sources : towardsdatascience.com

Words with similar meanings—like "king" and "queen"—will have embeddings that are closer together in vector space.

Types of Embeddings

Word Embeddings

Represent individual words in a multi-dimensional space.
Capture relationships between words.

📌 Models: Word2Vec, GloVe, FastText (by Facebook)
📌 Use Cases: Machine translation, chatbots, search engines

Text Embeddings

Represent longer texts (phrases, sentences, paragraphs, or documents) as vectors.

📌 Models: BERT, Paragraph2Vec
📌 Use Cases: Text classification, sentiment analysis

Note:

Word embeddings focus on individual words.

Text embeddings capture the meaning of entire texts.

Sentence Embeddings

Represent entire sentences in vector form.
Capture both meaning and context.
Similar sentences have embeddings that are closer together.

📌 Models: Sentence-BERT (SBERT), Universal Sentence Encoder (USE) [by Google], Infersent
📌 Use Cases: Semantic search, text retrieval

Note: Sentence embeddings are a type of text embedding but specifically focus on entire sentences

Image Embeddings

Convert images into feature vectors.
Helps in image similarity searches & object recognition.

📌 Models: CNN (ResNet, VGG, CLIP)
📌 Use Cases: Image search, object detection

Graph Embeddings

Represent nodes, edges, or entire graphs as vectors.
Used in social networks, fraud detection, recommendation systems.

📌 Models: Node2Vec, GraphSAGE
📌 Use Cases: Fraud detection, social network analysis

Video Embeddings

Convert both spatial (image) and temporal (motion) features into a meaningful vector sequence.

📌 Models: C3D, CLIP (for video)
📌 Use Cases: Video search, activity recognition

Audio Embeddings

Convert sound waves into vector representations.
Capture pitch, tone, and speech meaning.

📌 Models: Wav2Vec, OpenL3
📌 Use Cases: Speech recognition, music classification

Note: All these embeddings fall under vector embeddings.

Shared Embedding Space

A shared embedding space is a common vector space where different types of data (e.g., text & images) are mapped close together if they are related.

Image sources : dailydoseofds.com

📌 Example: CLIP (Contrastive Language-Image Pretraining)
- Developed by OpenAI to create a shared embedding space for images & text.
- Allows images and textual descriptions to be compared directly.

Use Case: You can search for images using text descriptions!

Applications of Embeddings :

Image sources : lyzr.ai

Large Language Models (LLMs): Convert input tokens into token embeddings.
Semantic Search: Retrieves similar sentences to improve search relevance.
RAG (Retrieval-Augmented Generation): Uses sentence embeddings to retrieve relevant text.
Recommendations: Finds similar products using vector search.
Anomaly Detection: Identifies unusual patterns in data.

Famous Word Embedding Models :

Image sources : medium.com

Word2Vec → Predicts a word based on surrounding words (developed by Google).
GloVe → Similar to Word2Vec but with a different mathematical approach (by Stanford).

Lets Understank Tokens :

Image sources : edenai.co

What is a Token?

A token is a small unit of text used in NLP models. It can be:

A word (e.g., "cat")
A subword (e.g., "play" and "ing" in "playing")
A character (e.g., "C", "a", "t")
A symbol or punctuation (e.g., "!")

Example:
- Sentence: "I love AI!"
- Tokens: ["I", "love", "AI", "!"]

Token vs. Embedding

Feature	Token	Embedding
Definition	A unit of text (word, subword, character)	A numeric vector representing meaning
Format	Text	Numbers (vector)
Example	`"cat"` → Token	`"cat"` → `[0.23, 0.87, -0.45, ...]`

Tokens help models read text.

Embeddings help models understand meaning.

Example Code: How Embeddings Works : https://github.com/Raghul-M/GenAI/blob/main/Embedings/Token-Embeddings.ipynb

Conclusion :

Embeddings have become a fundamental building block in modern AI, enabling machines to understand and represent complex data in a way that drives advancements in natural language processing, search, and more. Their ability to convert words, sentences, or documents into numerical vectors allows for more efficient and accurate tasks like similarity search and classification. As technology evolves, embeddings will continue to play a crucial role in shaping the future of AI.

Connect with me on Linkedin: Raghul M

Understanding Transformers: The Backbone of Modern AI

Raghul M — Fri, 31 Jan 2025 12:09:17 GMT

Introduction :

Hey everyone 👋🏻 !

Let me Introduce Transformers wait a minute, not the movie! Though, I have to admit, the Transformers movies are pretty cool, especially the Autobots and Megatrons . But today, I’m here to introduce something even cooler the Transformer model, which has completely changed the AI industry.

The Transformer model and its architecture were proposed by a group of Google researchers in the 2017 paper Attention Is All You Need. This innovation revolutionized the entire AI landscape. These models power state-of-the-art Natural Language Processing (NLP) applications, including GPT, BERT, and T5. Unlike traditional models like RNNs and LSTMs, Transformers leverage the self-attention mechanism to process data more efficiently, leading to groundbreaking advancements in machine learning and artificial intelligence.

In this blog, I will break down Transformers, Transformer architecture, its components (encoders, decoders, attention mechanisms), and its impact on AI. I will also provide a hands-on example using the Gensim library. No need to worry—it won’t be too mathematical!

Understanding Some Fundamentals

Before diving into Transformers, let’s first understand some key concepts.

What is a Language Model?

A language model is essentially a system that predicts the next word in a sentence. For example:

Google's popular language model is BERT.
OpenAI's ChatGPT is based on the GPT model.

GPT is called a large language model (LLM) because it is trained on billions of parameters, making it incredibly powerful. The primary goal of a language model is to predict the next word in a sentence accurately.

Word Embeddings and Tokens

Machine learning models don't understand text directly; instead, they work with numerical representations known as word embeddings. Before feeding text into a Transformer model, words are broken down into tokens and transformed into embeddings.

For example:

The phrase "river bank" and "financial bank" will have different embeddings, even though they share the word bank.

Tokens

Tokens are the smallest units of text used in Natural Language Processing (NLP). The process of breaking text into these smaller units is called tokenization.

Example:

"unbelievable" → ["un", "believable"]

Why Have Transformers Revolutionized AI?

Transformers have redefined AI due to several key factors:

Parallel Processing – Unlike RNNs, which process words sequentially, Transformers analyze the entire input at once, making them significantly faster.
Better Context Understanding – Transformers capture long-range dependencies, allowing them to understand language better than traditional models.
Scalability – Models like GPT-4 and BERT demonstrate how well Transformers scale with massive datasets.
Versatility – Used in chatbots, translation, summarization, text generation, image processing, and more.

Transformer Architecture: A High-Level Overview

Transformers follow an encoder-decoder architecture. Here’s a simplified breakdown:

Encoder: Takes the input sentence, generates embeddings for each word/token, and produces contextual embeddings.
Decoder: Uses the contextual embeddings to predict the next word, generating an output with the highest probability.

Variants of Transformers

Transformer: Generic encoder-decoder architecture.
BERT: Only has an encoder.
GPT: Only has a decoder.

Understanding Encoders and Decoders

Encoder:

Converts input tokens into meaningful representations.
Uses self-attention to understand relationships between words.
Stacks multiple layers for deep feature extraction.

Decoder:

Takes encoder outputs and generates predictions.
Uses self-attention + cross-attention to ensure coherence in output.

Static vs. Contextual Embeddings

Static Embeddings: Pre-trained word representations like Word2Vec, GloVe.
Contextual Embeddings: Transformer-generated dynamic embeddings that change based on context.

Example:

"bank" in "river bank" vs. "financial bank" will have different embeddings in Transformer models.

Attention Mechanism: The Heart of Transformers

Self-Attention:
- Each word attends to every other word in a sentence.
- Helps the model understand context efficiently.
Multi-Head Attention:
- Instead of using a single attention mechanism, Transformers use multiple parallel attention heads.
- Each head captures different aspects of meaning.
Cross-Attention:
- Used in the decoder to attend to encoder outputs, ensuring context-rich responses.

How Text is Converted into Output (Step-by-Step)

Tokenization: Text is broken into smaller units.
Embedding: Tokens are converted into numerical vectors.
Positional Encoding: Adds information about word order.
Self-Attention & Multi-Head Attention: Captures contextual relationships.
Feed-Forward Network: Processes extracted features.
Output Generation: Decoder produces meaningful text.

Hands-on Example: Using Gensim for Word Embeddings

Before diving into Transformer-based models, let’s see how word embeddings work with Gensim.

Step 1: Install Gensim

pip install gensim

Step 2: Train a Word2Vec Model

from gensim.models import Word2Vec

# Sample dataset
sentences = [['machine', 'learning', 'is', 'fun'], ['deep', 'learning', 'is', 'powerful']]

# Train Word2Vec model
model = Word2Vec(sentences, vector_size=50, window=3, min_count=1, workers=4)

# Get similar words
print(model.wv.most_similar('learning'))

Conclusion :

Transformers have revolutionized AI, enabling state-of-the-art NLP applications. Their ability to process large datasets, understand context deeply, and handle long-range dependencies makes them the go-to choice for modern AI systems. With further advancements, Transformers will continue to shape the future of AI. 🚀

Connect with me on Linkedin: Raghul M

Python Webapp Deployment on Heroku Using GitHub Actions

Raghul M — Tue, 16 Jul 2024 15:56:07 GMT

This project demonstrates how to deploy a simple Python web application using Flask to Heroku deployment, with automated testing using pytest and deployment using GitHub Actions.

Github Repo link : 🔗Heroku Deployment using Github Actions

Project Description

This project includes:

A basic Flask web application.
Tests written in pytest.
Automated deployment to Heroku using GitHub Actions.

Prerequisites

Python 3.10+
Git
GitHub account
Heroku account
Heroku CLI

Local Setup

Clone the repository:

 git clone https://github.com/Raghul-M/Python-Github_Actions-Heroku.git
 cd Python-Github_Actions-Heroku

Create a virtual environment:

 python -m venv venv
 source venv/bin/activate  # On Windows use `venv\Scripts\activate`

Install dependencies:
```
 pip install -r requirements.txt
```
Run the application locally:
```
 python3 app.py
```

Running Tests

Run tests with pytest:

pytest

Deployment

Heroku Setup

Login to Heroku:
```
 heroku login
```
Create a new Heroku app:
```
 heroku create your-app-name
```
Set up GitHub Actions for Heroku deployment:
- Go to your GitHub repository.
- Navigate to Settings > Secrets > New repository secret.
- Add the following secrets:
  - HEROKU_API_KEY: Your Heroku API key.
  - HEROKU_APP_NAME: Your Heroku app name.

Add the GitHub Actions workflow file (.github/workflows/deploy.yml):

 name: Python application
 on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]
  permissions:
    contents: read
  jobs:
    build:

  runs-on: ubuntu-latest

  steps:
  - uses: actions/checkout@v4
    with:
      fetch-depth: 0
  - name: Set up Python 3.10
    uses: actions/setup-python@v3
    with:
      python-version: "3.10"
  - name: Install dependencies
    run: |
      python -m pip install --upgrade pip
      pip install flake8 pytest
      if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
  - name: Lint with flake8
    run: |
      # stop the build if there are Python syntax errors or undefined names
      flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
      # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
      flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
  - name: Test with pytest
    run: |
      pytest

  deploy:
  needs: build
  runs-on: ubuntu-latest
  steps:
  - uses: actions/checkout@v2
  - uses: akhileshns/heroku-deploy@v3.12.12
    with:
        heroku_api_key: ${{secrets.HEROKU_API_TOKEN}}
        heroku_app_name: ${{secrets.HEROKU_APP_NAME}} #Must be unique in Heroku
        heroku_email: ${{secrets.HEROKU_EMAIL}}

Create a Procfile
Create a Runtime file

Output :

Localhost

Deployed App on Heroku

Contributing

Contributions are welcome! If you have suggestions, bug reports, or want to add new features, feel free to submit a pull request.

Feel free to explore, contribute, and adapt this project to suit your needs. If you encounter any issues or have suggestions for improvement, please raise them in the GitHub repository's issues section. Happy coding! 🚀

Connect with me on Linkedin: Raghul M

Docker Streamlit Application Deployment Using GitHub Actions on AWS Self-Hosted Runner

Raghul M — Tue, 16 Jul 2024 09:21:58 GMT

This project demonstrates a CI/CD pipeline using GitHub Actions to build a Dockerized Streamlit Python application and deploy it to an AWS EC2 Self Hosted Runner.

Github Repo link🔗Docker Deployment using Github Actions

Project Workflow :

Code Commit: Developers push code changes to the main branch.
CI Build Job: GitHub Actions triggers a build job (build.yml) upon code commit.
Docker Image Build: The CI job builds a Docker image from the Dockerfile and pushes it to Docker Hub upon successful build.
CD Deploy Job: After the image is pushed, another GitHub Actions job (deploy.yml) is triggered.
Deployment to AWS EC2:
- The deploy job uses a self-hosted runner on an AWS EC2 instance.
- It pulls the latest Docker image from Docker Hub.
- The image is then run as a container on the EC2 instance.

Repository Structure:

.github/workflows/: Contains GitHub Actions workflows.
- build.yml: Defines CI build steps.
- deploy.yml: Defines CD deployment steps.
Dockerfile: Configuration for building the Docker image.
README.md: Project documentation (you are currently reading this file).

Prerequisites:

Before running the CI/CD pipeline, ensure you have set up the following:

GitHub Repository: Configure secrets for Docker Hub credentials (DOCKER_USERNAME, DOCKER_PASSWORD) as Repo Secrets.
Docker Hub Account: Repository for storing Docker images.
AWS EC2 Instance: Ensure the instance is running and accessible via SSH and Configured Self-Hosted Runner

Final Deployment :

Notes

Ensure that your Dockerfile is configured correctly to build and run your Python application.
Regularly monitor and maintain your AWS EC2 instance to ensure proper functioning of the deployed application.

Contributing

Contributions are welcome! If you have suggestions, bug reports, or want to add new features, feel free to submit a pull request.

Connect with me on Linkedin: Raghul M

Open Source 101: A Developer's Blueprint for Getting Started

Raghul M — Tue, 16 Jul 2024 06:37:55 GMT

Welcome to the exciting world of open-source development! Whether you're a seasoned coder or a programming enthusiast looking to dive into collaborative coding, this guide is your comprehensive blueprint to kickstart your journey.

What is Opensource ?

Imagine software as a recipe for a dish. When a chef creates a recipe, they write it in a way other chefs can follow to make the same dish. Now, think of open source as sharing that recipe with everyone. In the world of computers, the software is like a recipe that tells the computer how to do specific tasks. With open source, the software's creators share the instructions (called source code) with everyone. This means anyone can see how the software works, change it to fit their needs, and even share their version with others. So, instead of keeping the recipe a secret, open source lets everyone be part of the cooking process. It's like a big kitchen where chefs (developers) work together, share ideas, and make the recipe better for everyone. This way, the software becomes a collaborative effort, benefiting from the skills and creativity of many people. Examples of open-source software are popular recipes that chefs worldwide contribute to and improve over time.

OSS - Open Source Software

Open Source Software refers to software whose source code is available to the public. Users can view, modify, and distribute the code, fostering collaboration and transparency.

Examples of OSS: Linux, Firefox, Python, GIMP, LibreOffice etc...

CSS - Closed Source Software

Closed Source Software refers to proprietary software whose source code is not distributed to the public. It is considered proprietary, entrusted, and exclusive, with restrictions on access

Examples of CSS: Microsoft Windows, Adobe Photoshop, etc...

What is Github?

GitHub is a leading platform for open-source development, facilitating global collaboration on diverse projects. Using Git for version control, enables easy forking, modification, and merging of code.
With a user-friendly interface and features like issue tracking and pull requests, GitHub streamlines collaborative development, promoting transparency and community engagement.
Developers leverage GitHub to share, collaborate, and benefit from the collective expertise of the open-source community, fostering innovation in software projects.

Repository :

A Repository is a folder for storing Documents and application source code. a repository can track and maintain version control

A repository, or "repo" is a central storage for code and files, facilitating collaboration and version control in software development.
Platforms like GitHub offer tools to host and manage repositories, enhancing teamwork and tracking changes in projects.

Basic Terminologies in Opensource:

Source Code: Source code is the human-readable set of instructions and statements written by a programmer using a programming language to create software. It is the original code that is written and edited by developers and is later compiled or interpreted to produce executable programs.
Repository: Storage space for project files, hosted on platforms like GitHub.
Version Control: System for tracking changes in source code over time, often using Git.
Fork: Creating a personal copy of a project for independent modification.
Pull Request (PR): Proposal to integrate changes from a fork into the original project.
Issue: Discussion space for tasks, bug reports, and feature requests in a project.
Merge: Combining changes from one branch or fork into another.
Commit: Set of changes made to the source code, acting like a snapshot.
Branch: Separate line of development within a repository.
License: Legal terms specifying how software can be used, modified, and distributed.
Community: Group of developers, contributors, and users engaged in an open-source project.
Contributor: Individual contributing to an open-source project through code, reports, or assistance.
Maintainer: Person or group overseeing and managing an open source project.
README: File providing essential information about a project, including usage instructions.
Code of Conduct: Guidelines on acceptable behavior.
Contributing Guidelines: describe how to contribute and collaborate.
Upstream: Forms the Foundation of the source.
Downstream: Programmers working stream.

Ways to Contribute

Code
Documentation
Advocacy(write blogs, share on social media, talks or workshops)
Community

How to start Contributing:

Search and Work on First good First issues label in issues.

Some websites for finding issues:

https://up-for-grabs.net/
https://goodfirstissues.com/
https://goodfirstissue.dev/
https://www.codetriage.com/

Attend regular meetings in the Community
Join sprints
Participate in a code Program.

Getting Started as a Newbie:

Watch this tutorial from eddiehub to get started on open source: here Join eddiehub community on open source here

EddieHub is an open-source organization focusing on reciprocal collaboration between members of the tech community; to encourage and promote communication, best practices, and technical expertise in an inclusive and welcoming environment.

Why Developers Should Contribute to Open Source, regardless of Experience?

Skill Enhancement: Contributing to open-source projects provides developers, regardless of experience, with an opportunity to enhance their skills. It allows them to work on real-world projects, learn from experienced developers, and gain hands-on experience with different technologies and coding practices.

Community Engagement: Open-source contributions enable developers to engage with a global community of like-minded individuals. This collaborative environment fosters networking, mentorship opportunities, and exposure to diverse perspectives, ultimately enriching a developer's professional growth and expanding their network in the tech industry.

Conclusion:

Embarking on the journey of open source is an invitation to a world of collaboration, innovation, and community-driven development. By understanding the fundamental terminology and concepts, you've taken the first step toward contributing and learning in this dynamic environment.

Connect with me on: https://linktr.ee/raghul_m1

Hosting a Portfolio Website in Azure Cloud with Custom Domain(Free)👨‍💻.

Raghul M — Sat, 18 Jun 2022 13:23:36 GMT

We are going to Host a Static Website in Azure Cloud with CI/CD using Github Actions and Free Custom Domain.

So, Basically What is Cloud Computing?

Definition of Cloud Computing According to NIST (National Institute of Standards and Technology-US)

A Model that enable ubiquitious (everywhere) and convenient on-demand network access to a shared pool of configurable computing resources for eg :(networks,storage,applications and services) that can be rapidly provisioned and released with minimal management effort or cloud service provider interaction.

In Layman Term

The cloud is the delivery of on-demand computing resources , everything from application to data centers over the internet on a pay for what you use basis On Demand Services are:

Networks
Servers
Storage
Applications and Servers

What is Azure Cloud??

Microsoft Azure, formerly known as Windows Azure, is Microsoft's public cloud computing platform. It provides a range of cloud services, including compute, analytics, storage and networking.The Azure cloud platform is with more than 200 products and cloud services designed to help you bring new solutions to life—to solve today’s challenges and create the future. Build, run and manage applications across multiple clouds, on-premises and at the edge, with the tools and frameworks of your choice.

So,Lets get Started with Our Project:

Prerequisites :
1.Github Account
2.Azure Account
3.Source Code for your Portfolio website 💻
4.Custom Domain (Tip: Free Domain)

Step 1 : Github Account & Source Code

GitHub is a web-based version-control and collaboration platform for software developers.Owned by Microsoft.

Create a Free Github Account Click here

Afterwards :
1.Create a New Repository 
2.Upload your Portfolio website sourcecode in the repo

Example :

Step 2 : Azure Account

Azure is a public cloud owned by Microsoft,Azure Account comes with 200$ credits for first month and 40+ free for life time.

Students : Click here (Credit card Not Required) Others : Click here (Credit card Required)

Step 3 : Free Custom Domain

Once you Create a free azure account you're eligible for 25+ free domain

For free Custom domain Click Here

Step 4 : Lets Start the Project

Follow this Link to step by step walkthrough of the project and it's documentation :

Project Documentation :Github Repo

live demo : raghulm.me (disabled)

Conclusion

the best way to gain knowledge is to make your hands dirty. try new stuff and play with services in the cloud. Side Projects are the best way to gain Experience.

Thanks for reading this post, Give your Valuable Feedback

Connect with me on :

Twitter : @RaghulM01

portfolio : raghul-m.github.io

In Collaboration with Think Digital , SRM

Tech Journal 📚

AI and ML: Understanding the Basics in Simple Words

What is AI?

What is Machine Learning (ML) ?

ML Has Two Key Parts : Training and Inference

ML Learning Styles :

Machine Learning has two main tasks :

Structured vs. Unstructured Data

Deep learning :

Statistical Machine Learning vs Deep Learning :

Conclusion :

vLLM ? The Simple Guide for Non-Devs and Curious Minds

What Is vLLM (And Why Should You Care)?

1. Tokens

2. Attention

3. KV (Key-Value) Cache

4. PagedAttention (The Magic)

5. vLLM Engine

6. OpenAI-Compatible API

Why vLLM Matters

A Simple Chatbot Flow with vLLM

Conclusion

Understanding Reverse Proxy and Forward Proxy — The Simple Way

What Is a Proxy?

Why Use a Proxy?

What Is a Reverse Proxy?

✅ Why Use a Reverse Proxy?

What Is a Forward Proxy?

✅ Why Use a Forward Proxy?

Differences Between Forward and Reverse Proxy

Why Are Proxies Important? (In DevOps)

Conclusion

How I Turned an Old Laptop into a Local AI Server (for Free!) with Ollama + Cloudflare Tunnel

Introduction :

Project overview :

Hardware & OS Setup 💻

Installing Ollama :

🔄 Serving the LLM

Exposing Ollma Localhost with Cloudflare Tunnel

🌐 Creating a Streamlit Frontend

📊 Bonus Tips

🚀 What You Can Build

📖 Conclusion :

Ollama & OpenWebUI Setup Guide: Run LLMs Locally with Ease

Introduction

Ollama Commands

1. Running a Model:

2. Starting the API Server:

3. Verifying Model Integrity:

4. Listing Available Models:

5. Pulling a Model from the Registry:

6. Pushing a Model to the Registry:

7. Creating a Custom Model:

8. Check avilable commands:

REST API Endpoints

Ollama REST API endpoints :

Creating and Managing Custom Models

Creating a Custom Image

Pulling a Model from the Ollama Registry

Using Ollama with Python

Setting Up OpenWebUI with Ollama

Running OpenWebUI with Docker

Conclusion :

Understanding Embeddings : How AI Learns Meaning from Text, Images, and Data

What is an Embedding?

Types of Embeddings

Word Embeddings

Text Embeddings

Sentence Embeddings

Image Embeddings

Graph Embeddings

Video Embeddings

Audio Embeddings

Shared Embedding Space

Applications of Embeddings :

Famous Word Embedding Models :

Lets Understank Tokens :

What is a Token?

Token vs. Embedding

Conclusion :