Tushar Mahore

Building a RAG Pipeline from Scratch with Python

2026-04-10T09:00:00+00:00

Large Language Models are impressive — until they hallucinate a citation that doesn’t exist, or confidently answer a question about events after their training cutoff. Retrieval-Augmented Generation (RAG) is the architectural fix: instead of relying purely on parametric memory baked into model weights, we retrieve relevant documents at inference time and ground the response in them.

This post walks through building a minimal but complete RAG pipeline from scratch. No LangChain magic — just the moving parts, visible.

What We Are Building

A system that:

Ingests a set of documents and indexes them by semantic meaning
Takes a user query, finds the most relevant passages
Sends the query + retrieved passages to an LLM to generate a grounded answer

flowchart TD
    A[Documents] --> B[Chunking]
    B --> C[Embedding Model\nsentence-transformers]
    C --> D[(FAISS Index)]

    Q[User Query] --> E[Query Embedding]
    E --> F[Similarity Search]
    D --> F
    F --> G[Top-k Passages]
    G --> H[Prompt Assembly]
    Q --> H
    H --> I[LLM Generator]
    I --> J[Grounded Answer]

    style A fill:#e8f4fd
    style Q fill:#fff3e0
    style J fill:#e8f5e9

Setup

pip install sentence-transformers faiss-cpu transformers torch

For this walkthrough we use:

sentence-transformers — embedding documents and queries
FAISS — approximate nearest-neighbour index
transformers — local LLM for generation (or swap in an API)

Step 1 — Document Loading and Chunking

RAG works on chunks, not full documents. A 10-page PDF fed as one string drowns the model in irrelevant context. We split into overlapping chunks so no information is cut off at a boundary.

from typing import List

def load_documents(paths: List[str]) -> List[str]:
    """Load plain-text documents from file paths."""
    docs = []
    for path in paths:
        with open(path, "r", encoding="utf-8") as f:
            docs.append(f.read())
    return docs


def chunk_text(text: str, chunk_size: int = 300, overlap: int = 50) -> List[str]:
    """Split text into overlapping word-level chunks."""
    words = text.split()
    chunks = []
    start = 0
    while start < len(words):
        end = start + chunk_size
        chunk = " ".join(words[start:end])
        chunks.append(chunk)
        start += chunk_size - overlap  # slide with overlap
    return chunks


def build_corpus(paths: List[str]) -> List[str]:
    docs = load_documents(paths)
    corpus = []
    for doc in docs:
        corpus.extend(chunk_text(doc))
    return corpus

Why overlap? A key sentence might sit at the boundary between two chunks. An overlap of ~50 words ensures it appears fully in at least one chunk.

Step 2 — Embedding the Corpus

We use a bi-encoder — a model that maps any text to a fixed-size dense vector such that semantically similar texts land close together in vector space.

from sentence_transformers import SentenceTransformer
import numpy as np

EMBED_MODEL = "sentence-transformers/all-MiniLM-L6-v2"

def embed_corpus(corpus: List[str], model_name: str = EMBED_MODEL) -> np.ndarray:
    """
    Encode all corpus chunks into dense vectors.
    Returns array of shape (n_chunks, embedding_dim).
    """
    model = SentenceTransformer(model_name)
    print(f"Embedding {len(corpus)} chunks...")
    embeddings = model.encode(
        corpus,
        batch_size=64,
        show_progress_bar=True,
        normalize_embeddings=True  # L2-normalise for cosine similarity via dot product
    )
    return embeddings

all-MiniLM-L6-v2 is 22M parameters — fast and accurate enough for most use cases. For higher accuracy, swap in BAAI/bge-large-en-v1.5.

Step 3 — Building the FAISS Index

FAISS (Facebook AI Similarity Search) lets us search millions of vectors in milliseconds using approximate nearest-neighbour algorithms.

import faiss

def build_index(embeddings: np.ndarray) -> faiss.IndexFlatIP:
    """
    Build a flat inner-product FAISS index.
    With L2-normalised vectors, inner product == cosine similarity.
    """
    dim = embeddings.shape[1]
    index = faiss.IndexFlatIP(dim)
    index.add(embeddings.astype(np.float32))
    print(f"Index built: {index.ntotal} vectors, dim={dim}")
    return index


def save_index(index: faiss.Index, path: str):
    faiss.write_index(index, path)

def load_index(path: str) -> faiss.Index:
    return faiss.read_index(path)

For large corpora (>100k chunks), replace IndexFlatIP with IndexIVFFlat or IndexHNSWFlat for faster (approximate) search.

Step 4 — Retrieval

Given a user query, embed it and find the top-k most similar chunks.

def retrieve(
    query: str,
    index: faiss.Index,
    corpus: List[str],
    model_name: str = EMBED_MODEL,
    top_k: int = 5
) -> List[str]:
    """
    Embed query, search FAISS index, return top-k text chunks.
    """
    model = SentenceTransformer(model_name)
    query_vec = model.encode(
        [query],
        normalize_embeddings=True
    ).astype(np.float32)

    scores, indices = index.search(query_vec, top_k)

    results = []
    for score, idx in zip(scores[0], indices[0]):
        results.append({
            "text": corpus[idx],
            "score": float(score)
        })
    return results

Step 5 — Prompt Assembly and Generation

Retrieved chunks are injected into the prompt as context. The LLM is instructed to answer only from the provided context — the key constraint that reduces hallucination.

from transformers import pipeline

def build_prompt(query: str, context_chunks: List[dict]) -> str:
    context = "\n\n---\n\n".join(
        [f"[Passage {i+1}]\n{c['text']}" for i, c in enumerate(context_chunks)]
    )
    prompt = f"""You are a helpful assistant. Answer the question using ONLY the provided context.
If the answer is not in the context, say "I don't have enough information to answer this."

Context:
{context}

Question: {query}

Answer:"""
    return prompt


def generate_answer(prompt: str, model_name: str = "google/flan-t5-base") -> str:
    """
    Generate an answer using a local seq2seq model.
    Swap model_name for any HuggingFace-compatible model.
    """
    generator = pipeline("text2text-generation", model=model_name)
    output = generator(
        prompt,
        max_new_tokens=256,
        do_sample=False
    )
    return output[0]["generated_text"]

Step 6 — Putting It All Together

import os

# ── Config ──────────────────────────────────────────────────────────────────
DOCS_DIR    = "./documents"
INDEX_PATH  = "./rag_index.faiss"
CORPUS_PATH = "./corpus.txt"

# ── Build (run once) ─────────────────────────────────────────────────────────
doc_paths = [
    os.path.join(DOCS_DIR, f)
    for f in os.listdir(DOCS_DIR) if f.endswith(".txt")
]
corpus    = build_corpus(doc_paths)
embeddings = embed_corpus(corpus)
index     = build_index(embeddings)
save_index(index, INDEX_PATH)

# Save corpus for retrieval lookups
with open(CORPUS_PATH, "w") as f:
    for chunk in corpus:
        f.write(chunk + "\n<<>>\n")

# ── Query (run anytime) ───────────────────────────────────────────────────────
index  = load_index(INDEX_PATH)
with open(CORPUS_PATH) as f:
    corpus = f.read().split("\n<<>>\n")

query  = "What are the main challenges in retrieval-augmented generation?"
chunks = retrieve(query, index, corpus, top_k=4)
prompt = build_prompt(query, chunks)
answer = generate_answer(prompt)

print(f"\nQuery : {query}")
print(f"Answer: {answer}")
print("\nSources:")
for i, c in enumerate(chunks):
    print(f"  [{i+1}] score={c['score']:.3f} | {c['text'][:80]}...")

Sample Output

Embedding 142 chunks: 100%|████████████████| 3/3 [00:02<00:00]
Index built: 142 vectors, dim=384

Query : What are the main challenges in retrieval-augmented generation?
Answer: The main challenges include retrieval-generation mismatch, multi-hop
        reasoning over multiple documents, managing long contexts, and
        hallucination even when relevant passages are retrieved.

Sources:
  [1] score=0.872 | The core difficulty in RAG is ensuring the generator
                    actually uses the retrieved passages...
  [2] score=0.841 | Multi-hop questions require reasoning over chains of
                    documents, which flat retrieval struggles with...

Where to Go From Here

Enhancement	What it gives you
HyDE — generate a hypothetical answer, embed it	Better retrieval for complex queries
Re-ranking with a cross-encoder	Higher precision top-k results
Hybrid search (BM25 + dense)	Handles keyword-heavy queries better
Self-RAG — LLM decides when to retrieve	Avoids retrieval on questions it already knows
CTranslate2 / llama.cpp for generation	Edge-deployable offline inference

The last row is what my PhD research focuses on — building the full pipeline for offline disaster response, where cloud access is unavailable. A future post will cover that in detail.

References

Lewis et al. (2020). Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks. NeurIPS 2020.
Gao et al. (2023). RAG for Large Language Models: A Survey. arXiv:2312.10997.
FAISS documentation
sentence-transformers

Backpropagation from Scratch with NumPy

2026-03-25T09:00:00+00:00

Every deep learning framework — PyTorch, TensorFlow, Keras — does one thing at its core: automatic differentiation. It computes gradients of the loss with respect to every weight in the network, then adjusts those weights to reduce the loss. This process is called backpropagation.

Understanding backpropagation at the implementation level — not just the diagram — is the difference between using a neural network and understanding one. This post implements a two-layer network from scratch using only NumPy. Every forward computation is explicit. Every gradient is derived and coded by hand.

I use this approach in my Artificial Neural Networks course because students who implement backprop once never forget it.

The Network

We will build a network for binary classification:

\[\text{Input } \mathbf{x} \in \mathbb{R}^{n} \xrightarrow{W_1, b_1} \text{Hidden } \mathbf{h} \in \mathbb{R}^{d} \xrightarrow{W_2, b_2} \text{Output } \hat{y} \in (0, 1)\]

Hidden layer: ReLU activation
Output layer: Sigmoid activation
Loss: Binary cross-entropy

flowchart LR
    X["Input x\n(n features)"] --> Z1["z₁ = W₁x + b₁"]
    Z1 --> A1["a₁ = ReLU(z₁)\n(hidden layer)"]
    A1 --> Z2["z₂ = W₂a₁ + b₂"]
    Z2 --> A2["ŷ = σ(z₂)\n(output)"]
    A2 --> L["Loss\nBCE(y, ŷ)"]

    style X fill:#e3f2fd
    style L fill:#fce4ec

Setup

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split

np.random.seed(42)

No other imports needed.

Activation Functions and Their Derivatives

Backpropagation requires the derivative of every activation function. We implement each as a pair.

def sigmoid(z):
    return 1.0 / (1.0 + np.exp(-z))

def sigmoid_derivative(z):
    s = sigmoid(z)
    return s * (1 - s)         # d/dz σ(z) = σ(z)(1 − σ(z))

def relu(z):
    return np.maximum(0, z)

def relu_derivative(z):
    return (z > 0).astype(float)  # 1 where z > 0, else 0

Weight Initialisation

Poor initialisation causes vanishing or exploding gradients before training even starts.

def initialise_parameters(n_input, n_hidden, n_output):
    """
    He initialisation for ReLU layers:
        W ~ N(0, sqrt(2/n_in))
    Prevents vanishing gradients with ReLU.
    """
    W1 = np.random.randn(n_hidden, n_input) * np.sqrt(2.0 / n_input)
    b1 = np.zeros((n_hidden, 1))
    W2 = np.random.randn(n_output, n_hidden) * np.sqrt(2.0 / n_hidden)
    b2 = np.zeros((n_output, 1))
    return {"W1": W1, "b1": b1, "W2": W2, "b2": b2}

Forward Pass

The forward pass computes the network’s prediction given current weights. We cache intermediate values — we will need them for the backward pass.

def forward_pass(X, params):
    """
    X : (n_features, n_samples)

    Returns:
        y_hat : predicted probabilities (1, n_samples)
        cache : dict of intermediate values for backprop
    """
    W1, b1 = params["W1"], params["b1"]
    W2, b2 = params["W2"], params["b2"]

    Z1 = W1 @ X + b1          # (n_hidden, n_samples)
    A1 = relu(Z1)              # (n_hidden, n_samples)

    Z2 = W2 @ A1 + b2          # (1, n_samples)
    A2 = sigmoid(Z2)           # (1, n_samples) — predicted probabilities

    cache = {"Z1": Z1, "A1": A1, "Z2": Z2, "A2": A2, "X": X}
    return A2, cache

Loss Function

Binary cross-entropy penalises confident wrong predictions heavily:

\[\mathcal{L} = -\frac{1}{m}\sum_{i=1}^{m}\left[ y^{(i)} \log \hat{y}^{(i)} + (1 - y^{(i)}) \log(1 - \hat{y}^{(i)}) \right]\]

def compute_loss(y_hat, y, eps=1e-8):
    """
    y_hat : (1, n_samples) predicted probabilities
    y     : (1, n_samples) true binary labels
    eps   : small constant to avoid log(0)
    """
    m = y.shape[1]
    loss = -(1/m) * np.sum(
        y * np.log(y_hat + eps) + (1 - y) * np.log(1 - y_hat + eps)
    )
    return float(loss)

Backward Pass

This is the core of the post. We compute gradients by applying the chain rule layer by layer, starting from the loss and working backwards.

The key insight: the gradient of the loss with respect to a weight equals the gradient flowing back through all subsequent layers multiplied by the local derivative.

def backward_pass(y_hat, y, params, cache):
    """
    Compute gradients of loss w.r.t. all parameters.

    Derivations:
      dL/dA2 = -(y/ŷ) + (1-y)/(1-ŷ)   ← BCE derivative
      dL/dZ2 = A2 - y                    ← combined with sigmoid derivative
      dL/dW2 = dL/dZ2 · A1ᵀ / m
      dL/db2 = mean(dL/dZ2, axis=1)

      dL/dA1 = W2ᵀ · dL/dZ2
      dL/dZ1 = dL/dA1 * ReLU'(Z1)
      dL/dW1 = dL/dZ1 · Xᵀ / m
      dL/db1 = mean(dL/dZ1, axis=1)
    """
    m  = y.shape[1]
    W2 = params["W2"]
    Z1, A1, Z2, A2, X = (
        cache["Z1"], cache["A1"], cache["Z2"], cache["A2"], cache["X"]
    )

    # ── Output layer ──────────────────────────────────────────────────────────
    dZ2 = A2 - y                              # (1, m)  ← sigmoid + BCE simplification
    dW2 = (dZ2 @ A1.T) / m                   # (1, n_hidden)
    db2 = np.mean(dZ2, axis=1, keepdims=True) # (1, 1)

    # ── Hidden layer ─────────────────────────────────────────────────────────
    dA1 = W2.T @ dZ2                          # (n_hidden, m)
    dZ1 = dA1 * relu_derivative(Z1)           # element-wise: zero where Z1 ≤ 0
    dW1 = (dZ1 @ X.T) / m                    # (n_hidden, n_input)
    db1 = np.mean(dZ1, axis=1, keepdims=True) # (n_hidden, 1)

    return {"dW1": dW1, "db1": db1, "dW2": dW2, "db2": db2}

The simplification dZ2 = A2 - y comes from combining the derivative of BCE loss with the derivative of the sigmoid. It is elegant and numerically stable.

Parameter Update (Gradient Descent)

def update_parameters(params, grads, learning_rate):
    params["W1"] -= learning_rate * grads["dW1"]
    params["b1"] -= learning_rate * grads["db1"]
    params["W2"] -= learning_rate * grads["dW2"]
    params["b2"] -= learning_rate * grads["db2"]
    return params

Training Loop

def train(X_train, y_train, n_hidden=16, lr=0.1, epochs=2000, print_every=200):
    n_input  = X_train.shape[0]
    n_output = 1
    params   = initialise_parameters(n_input, n_hidden, n_output)
    losses   = []

    for epoch in range(epochs):
        # Forward
        y_hat, cache = forward_pass(X_train, params)
        # Loss
        loss = compute_loss(y_hat, y_train)
        losses.append(loss)
        # Backward
        grads  = backward_pass(y_hat, y_train, params, cache)
        # Update
        params = update_parameters(params, grads, lr)

        if epoch % print_every == 0:
            preds    = (y_hat > 0.5).astype(int)
            accuracy = np.mean(preds == y_train) * 100
            print(f"Epoch {epoch:4d} | Loss: {loss:.4f} | Accuracy: {accuracy:.1f}%")

    return params, losses

Run It

# ── Dataset ───────────────────────────────────────────────────────────────────
X, y = make_moons(n_samples=1000, noise=0.2)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Reshape for our (features, samples) convention
X_train = X_train.T                          # (2, 800)
X_test  = X_test.T                           # (2, 200)
y_train = y_train.reshape(1, -1)             # (1, 800)
y_test  = y_test.reshape(1, -1)              # (1, 200)

# ── Train ─────────────────────────────────────────────────────────────────────
params, losses = train(X_train, y_train, n_hidden=16, lr=0.1, epochs=3000)

# ── Evaluate ──────────────────────────────────────────────────────────────────
y_hat_test, _ = forward_pass(X_test, params)
test_preds     = (y_hat_test > 0.5).astype(int)
test_acc       = np.mean(test_preds == y_test) * 100
print(f"\nTest Accuracy: {test_acc:.1f}%")

# ── Plot loss curve ───────────────────────────────────────────────────────────
plt.figure(figsize=(8, 4))
plt.plot(losses, color="#2196F3", linewidth=1.5)
plt.xlabel("Epoch")
plt.ylabel("Binary Cross-Entropy Loss")
plt.title("Training Loss — 2-Layer Neural Network (NumPy)")
plt.grid(alpha=0.3)
plt.tight_layout()
plt.savefig("loss_curve.png", dpi=150)
plt.show()

Expected Output

Epoch    0 | Loss: 0.7041 | Accuracy: 49.5%
Epoch  200 | Loss: 0.4823 | Accuracy: 78.2%
Epoch  400 | Loss: 0.3156 | Accuracy: 87.6%
Epoch  600 | Loss: 0.2241 | Accuracy: 91.3%
Epoch  800 | Loss: 0.1874 | Accuracy: 93.0%
Epoch 1000 | Loss: 0.1693 | Accuracy: 93.8%
Epoch 2000 | Loss: 0.1421 | Accuracy: 95.1%

Test Accuracy: 94.5%

What You Have Built

Component	Implementation
Forward pass	Matrix multiply → ReLU → Matrix multiply → Sigmoid
Loss	Binary cross-entropy
Backward pass	Chain rule, layer by layer
Update	Gradient descent

No autograd. No framework. Every gradient derived from first principles.

Common Mistakes to Watch For

Shapes. NumPy will broadcast silently. Print shapes at every step until you trust them.

# Add this while debugging:
print(f"Z1: {Z1.shape}, A1: {A1.shape}, Z2: {Z2.shape}")

Learning rate too high. Loss explodes or oscillates. Start at 0.01 and increase.

Not caching intermediates. The backward pass needs Z1, A1, Z2, A2. Cache them in the forward pass.

Exercises

Replace ReLU with tanh. Derive and implement its gradient.
Add a third hidden layer. Generalise the forward and backward pass to L layers.
Replace vanilla gradient descent with momentum or Adam.
Plot the decision boundary over the moon dataset.

References

Rumelhart, Hinton & Williams (1986). Learning representations by back-propagating errors. Nature.
Nielsen, M. (2015). Neural Networks and Deep Learning — Chapter 2.
Goodfellow, Bengio & Courville (2016). Deep Learning. MIT Press.

Text Classification for Cyberbullying Detection: A Practical NLP Walkthrough

2026-03-10T09:00:00+00:00

Cyberbullying detection is one of the applied NLP problems that looks deceptively simple and turns out to be genuinely hard. The text is short, informal, and context-dependent. The same word that signals aggression in one sentence is harmless banter in another. And the class imbalance — most posts are not bullying — creates classifiers that learn to say “not bullying” for everything.

This post walks through the machine learning pipeline I used in our IEEE ACROSET 2024 paper on multi-class cyberbullying detection. The methodology is reproducible, the code is complete, and the design choices are explained.

The Problem

Given a short social media post, classify it into one of:

Label	Description
`not_bullying`	No harmful content
`gender`	Gender-based harassment
`religion`	Religious targeting
`age`	Age-based targeting
`ethnicity`	Ethnic harassment
`other_cyberbullying`	Harmful but doesn’t fit above

This is a multi-class classification problem, not just binary. That distinction affects feature engineering, model selection, and how we interpret metrics.

Dataset

We use the Cyberbullying Classification dataset from Kaggle — 47,000 tweets across 6 classes.

import pandas as pd
import numpy as np

df = pd.read_csv("cyberbullying_tweets.csv")
print(df["cyberbullying_type"].value_counts())

not_cyberbullying       8000
gender                  8000
religion                7998
age                     7992
ethnicity               7961
other_cyberbullying     7823

Roughly balanced — which is unusual in real-world moderation datasets, where harmful content is rare. Keep this in mind when deploying.

Pipeline Architecture

flowchart LR
    Raw["Raw Tweet Text"] --> Clean["Text Cleaning\n(lowercase, URLs, mentions)"]
    Clean --> Token["Tokenisation\n+ Stopword Removal"]
    Token --> Stem["Stemming / Lemmatisation"]
    Stem --> Features["TF-IDF\nVectorisation"]
    Features --> Model["SVM / Random Forest"]
    Model --> Pred["Predicted Label"]

    style Raw fill:#e3f2fd
    style Pred fill:#e8f5e9

Setup

import re
import string
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.svm import LinearSVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import Pipeline
from sklearn.metrics import (
    classification_report, confusion_matrix,
    ConfusionMatrixDisplay, f1_score
)
from sklearn.preprocessing import LabelEncoder

import nltk
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer

nltk.download("stopwords", quiet=True)
nltk.download("wordnet",   quiet=True)

SEED = 42
np.random.seed(SEED)

Step 1 — Text Preprocessing

Social media text is noisy. A tweet like @user ur so ugly wtf 😡 check http://t.co/xyz contains a mention, a URL, informal spelling, and an emoji — none of which help a bag-of-words model.

lemmatizer  = WordNetLemmatizer()
STOP_WORDS  = set(stopwords.words("english"))

# Keep negations — "not" flips sentiment
STOP_WORDS -= {"no", "not", "nor", "never", "neither"}

def clean_tweet(text: str) -> str:
    """
    Full preprocessing pipeline for a single tweet.
    Returns a cleaned, lemmatised string.
    """
    text = text.lower()
    text = re.sub(r"http\S+|www\S+",      "", text)   # remove URLs
    text = re.sub(r"@\w+",                "", text)   # remove @mentions
    text = re.sub(r"#(\w+)",          r"\1", text)   # keep hashtag text, drop #
    text = re.sub(r"[^a-z\s]",            "", text)   # remove punctuation + digits
    text = re.sub(r"\s+",               " ", text).strip()

    tokens = text.split()
    tokens = [lemmatizer.lemmatize(t) for t in tokens if t not in STOP_WORDS]
    return " ".join(tokens)


# Apply to full dataset
df["clean_text"] = df["tweet_text"].apply(clean_tweet)

# Quick sanity check
print(df[["tweet_text", "clean_text"]].head(3).to_string())

Design choices explained:

Lemmatisation over stemming. running → run (not runn). Stems are not real words; lemmas are — which helps interpretability.
Keeping negations. Removing “not” from “not bullying” destroys the label’s meaning.
Hashtag text retained. #stopbullying → stopbullying still carries signal.

Step 2 — Train / Test Split

X = df["clean_text"]
y = df["cyberbullying_type"]

X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    random_state=SEED,
    stratify=y          # preserve class distribution in both splits
)

print(f"Train: {len(X_train)}, Test: {len(X_test)}")

Always stratify when splitting multi-class data. Without it, random splits can under-represent minority classes in either set.

Step 3 — TF-IDF Feature Extraction

TF-IDF (Term Frequency–Inverse Document Frequency) converts each tweet into a sparse numeric vector. Words that are common everywhere (low IDF) get downweighted; words distinctive to a document get upweighted.

\[\text{TF-IDF}(t, d) = \underbrace{\frac{f_{t,d}}{\sum_k f_{k,d}}}_{\text{term frequency}} \times \underbrace{\log \frac{N}{|\{d: t \in d\}|}}_{\text{inverse document frequency}}\]

tfidf = TfidfVectorizer(
    max_features=30_000,    # vocabulary cap — filters rare/noisy tokens
    ngram_range=(1, 2),     # unigrams + bigrams: "not good" ≠ "not" + "good"
    sublinear_tf=True,      # replace tf with 1 + log(tf) — dampens high counts
    min_df=3,               # ignore tokens appearing in < 3 documents
    max_df=0.95             # ignore tokens in > 95% of documents (too common)
)

X_train_tfidf = tfidf.fit_transform(X_train)
X_test_tfidf  = tfidf.transform(X_test)

print(f"Feature matrix: {X_train_tfidf.shape}")  # (37600, 30000)

Why bigrams? Phrases like “not racist” or “just joking” carry meaning that unigrams alone miss.

Step 4 — Model Training

Linear SVM

SVMs with a linear kernel work exceptionally well on high-dimensional sparse text data. They find the maximum-margin hyperplane separating classes in TF-IDF space.

svm = LinearSVC(
    C=1.0,          # regularisation — lower C = stronger regularisation
    max_iter=2000,
    random_state=SEED
)
svm.fit(X_train_tfidf, y_train)

Random Forest

Random Forest provides a complementary approach: it builds an ensemble of decision trees, each trained on a bootstrap sample with random feature subsets.

rf = RandomForestClassifier(
    n_estimators=200,
    max_depth=None,
    min_samples_leaf=2,
    n_jobs=-1,
    random_state=SEED
)
rf.fit(X_train_tfidf, y_train)

Step 5 — Evaluation

Classification Report

def evaluate_model(model, X_test, y_test, name="Model"):
    y_pred = model.predict(X_test)
    print(f"\n{'='*60}")
    print(f" {name}")
    print(f"{'='*60}")
    print(classification_report(y_test, y_pred, digits=3))
    return y_pred

svm_preds = evaluate_model(svm, X_test_tfidf, y_test, "Linear SVM")
rf_preds  = evaluate_model(rf,  X_test_tfidf, y_test, "Random Forest")

============================================================
 Linear SVM
============================================================
                      precision    recall  f1-score   support

                 age      0.912     0.905     0.908      1599
           ethnicity      0.887     0.891     0.889      1594
              gender      0.933     0.940     0.936      1598
    not_cyberbullying      0.958     0.951     0.955      1600
  other_cyberbullying      0.821     0.819     0.820      1565
            religion      0.921     0.932     0.927      1604

           accuracy                          0.906      9560
          macro avg      0.905     0.906     0.906      9560
       weighted avg      0.906     0.906     0.906      9560

Confusion Matrix

def plot_confusion_matrix(y_true, y_pred, title, labels):
    cm = confusion_matrix(y_true, y_pred, labels=labels, normalize="true")
    fig, ax = plt.subplots(figsize=(8, 6))
    disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=labels)
    disp.plot(ax=ax, cmap="Blues", colorbar=False, xticks_rotation=45)
    ax.set_title(title)
    plt.tight_layout()
    plt.savefig(f"cm_{title.lower().replace(' ', '_')}.png", dpi=150)
    plt.show()

LABELS = sorted(y_test.unique())
plot_confusion_matrix(y_test, svm_preds, "Linear SVM", LABELS)

The normalised confusion matrix shows where the model confuses classes. Common confusions: other_cyberbullying ↔ ethnicity and other_cyberbullying ↔ age — both understandable given overlapping language.

Step 6 — Cross-Validation

A single train/test split can be lucky or unlucky. Stratified k-fold gives a more reliable estimate.

# Re-fit on raw features using a Pipeline (fits on each fold properly)
cv_pipeline = Pipeline([
    ("tfidf", TfidfVectorizer(max_features=30_000, ngram_range=(1,2),
                               sublinear_tf=True, min_df=3)),
    ("clf",   LinearSVC(C=1.0, max_iter=2000, random_state=SEED))
])

skf    = StratifiedKFold(n_splits=5, shuffle=True, random_state=SEED)
scores = cross_val_score(cv_pipeline, X, y, cv=skf, scoring="f1_macro", n_jobs=-1)

print(f"5-Fold CV F1 (macro): {scores.mean():.3f} ± {scores.std():.3f}")
# → 5-Fold CV F1 (macro): 0.901 ± 0.004

Why macro F1? It gives equal weight to each class regardless of size. For harm detection, we care about rare categories as much as common ones.

Step 7 — Full sklearn Pipeline

Package preprocessing and modelling into a single Pipeline object. This makes deployment and serialisation clean.

import joblib

full_pipeline = Pipeline([
    ("tfidf", TfidfVectorizer(
        max_features=30_000,
        ngram_range=(1, 2),
        sublinear_tf=True,
        min_df=3,
        max_df=0.95
    )),
    ("clf", LinearSVC(C=1.0, max_iter=2000, random_state=SEED))
])

full_pipeline.fit(X_train, y_train)

# Save
joblib.dump(full_pipeline, "cyberbullying_pipeline.pkl")

# Reload and predict
loaded = joblib.load("cyberbullying_pipeline.pkl")

test_inputs = [
    "You are so stupid and ugly, nobody likes you",
    "Great game everyone, well played!",
    "Go back to your country you don't belong here"
]

for text in test_inputs:
    clean = clean_tweet(text)
    pred  = loaded.predict([clean])[0]
    print(f"  [{pred:>20}]  {text}")

  [  other_cyberbullying]  You are so stupid and ugly, nobody likes you
  [     not_cyberbullying]  Great game everyone, well played!
  [           ethnicity]  Go back to your country you don't belong here

Key Findings

Model	Accuracy	Macro F1	Notes
Linear SVM	90.6%	0.906	Faster, better on rare classes
Random Forest	86.2%	0.861	Slower, worse on short texts
Majority baseline	16.7%	—	Always predicts most common class

The SVM outperforms Random Forest on this task — consistent with text classification literature. Sparse high-dimensional data is where linear SVMs shine.

Limitations and What’s Next

What this model does not handle:

Context and sarcasm. “Great, another racist joke” is sarcastic — the model may miss it.
Code-switching. Multilingual harassment (Hinglish, etc.) is out of vocabulary.
Class imbalance in deployment. Real feeds are not balanced 1:1. Calibrate decision thresholds.

Next steps explored in the paper:

BERT fine-tuning for context-aware classification
Ensemble of TF-IDF + BERT embeddings
Active learning for low-resource annotation

Exercises

Replace LinearSVC with LogisticRegression. Compare performance and speed.
Add character n-grams to the TfidfVectorizer (analyzer='char_wb'). Does it help on misspelt slurs?
Use SMOTE to oversample rare classes and re-evaluate macro F1.
Fine-tune bert-base-uncased on the same dataset using HuggingFace Trainer.

References

Mankar, A., Mahore, T., et al. (2024). Multi-class Cyberbullying Detection using NLP. IEEE ACROSET 2024.
Joachims, T. (1998). Text categorization with support vector machines. ECML.
Bird, S., Klein, E., & Loper, E. (2009). Natural Language Processing with Python. O’Reilly.
scikit-learn: Text Feature Extraction

Explainable AI in Healthcare: TabTransformer + SHAP for IoMT Security

2026-02-20T09:00:00+00:00

When a neural network flags a network packet as a cyberattack on a hospital’s IoMT infrastructure, the security engineer needs to know why — not just that it did. In healthcare settings, black-box decisions carry real consequences: a false positive may shut down a patient monitor; a false negative may allow ransomware onto a ventilator network.

This post covers the research I contributed to our 2026 Academic Press book chapter on Explainable AI for IoMT security. We apply a TabTransformer — a Transformer architecture adapted for tabular data — and explain its predictions with SHAP (SHapley Additive exPlanations). The result is a classifier that achieves strong detection accuracy and provides human-readable explanations.

The Problem

IoMT (Internet of Medical Things) devices — infusion pumps, wearables, imaging equipment — generate tabular network traffic logs. Detecting anomalies in this traffic is a classic tabular classification problem, but with unusually high stakes.

Two failure modes matter:

Failure	Consequence
False Positive	Alert fatigue; legitimate devices shut down
False Negative	Intrusion missed; patient safety at risk

Standard neural networks achieve high accuracy but provide no explanation. Clinicians and security auditors need to see which features drove a prediction — this is where SHAP comes in.

Architecture: TabTransformer

Standard feedforward networks treat all tabular features identically. TabTransformer (Huang et al., 2020) applies self-attention to categorical embeddings, learning contextual relationships between features, while processing numerical features separately through a layer normalisation branch.

flowchart TD
    subgraph Input
        Cat["Categorical Features\n(protocol, port, flag)"]
        Num["Numerical Features\n(packet size, duration, rate)"]
    end

    Cat --> Emb["Column Embeddings"]
    Emb --> TF["Transformer Encoder\n(Multi-Head Self-Attention × L)"]
    TF --> Flat1["Flatten"]

    Num --> LN["Layer Normalisation"]
    LN --> Flat2["Pass-through"]

    Flat1 --> Concat["Concatenate"]
    Flat2 --> Concat
    Concat --> MLP["MLP Head\n(FC → ReLU → Dropout → FC)"]
    MLP --> Out["Attack Class Prediction"]

    style Input fill:#e3f2fd
    style Out fill:#e8f5e9

The key innovation: self-attention allows the model to learn that protocol=TCP + port=22 + flag=SYN together signal an SSH brute-force, even if each feature individually is unremarkable.

Setup

pip install torch torchvision pytorch-tabnet shap scikit-learn pandas matplotlib

import numpy as np
import pandas as pd
import torch
import torch.nn as nn
import shap
import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.metrics import classification_report, f1_score
from pytorch_tabnet.tab_model import TabNetClassifier   # TabNet as baseline

SEED = 42
torch.manual_seed(SEED)
np.random.seed(SEED)

We use PyTorch-TabNet as a practical implementation. While TabTransformer and TabNet differ architecturally, both apply attention to tabular data and support SHAP-based explainability — TabNet is available as a maintained open-source library.

Dataset

We use the CICIDS-2017 dataset — a widely used benchmark for network intrusion detection with 14 attack types plus benign traffic.

# Load a sample (full dataset is ~2.8M rows)
df = pd.read_csv("CICIDS2017_sample.csv")
df.columns = df.columns.str.strip()           # dataset has trailing whitespace in headers
df = df.replace([np.inf, -np.inf], np.nan).dropna()

print(df[" Label"].value_counts().head(10))

BENIGN             67343
DoS Hulk           46158
PortScan           15890
DDoS               12832
DoS GoldenEye       2303
FTP-Patator         1296
SSH-Patator         1177
DoS slowloris        750
...

Class imbalance is severe. We address this through stratified sampling and the model’s class weights.

Preprocessing

TARGET = " Label"
DROP_COLS = ["Flow ID", " Source IP", " Destination IP", " Timestamp"]

df = df.drop(columns=[c for c in DROP_COLS if c in df.columns])

# Encode target
le = LabelEncoder()
y  = le.fit_transform(df[TARGET])
X  = df.drop(columns=[TARGET])

# Numerical features only (CICIDS is all-numerical after drop)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y,
    test_size=0.2,
    random_state=SEED,
    stratify=y
)

print(f"Train: {X_train.shape}, Test: {X_test.shape}")
print(f"Classes: {le.classes_}")

Training the TabNet Classifier

clf = TabNetClassifier(
    n_d=32,               # embedding dimension per step
    n_a=32,               # attention embedding dimension
    n_steps=5,            # number of sequential attention steps
    gamma=1.3,            # coefficient for feature reusage in steps
    n_independent=2,
    n_shared=2,
    lambda_sparse=1e-3,   # sparsity regularisation — forces feature selection
    optimizer_fn=torch.optim.Adam,
    optimizer_params={"lr": 2e-3},
    mask_type="sparsemax",
    verbose=10,
    seed=SEED
)

clf.fit(
    X_train, y_train,
    eval_set=[(X_test, y_test)],
    eval_metric=["accuracy"],
    max_epochs=100,
    patience=15,          # early stopping
    batch_size=1024,
    virtual_batch_size=128
)

epoch 10  | loss: 0.2841 | val_accuracy: 0.9512
epoch 20  | loss: 0.1763 | val_accuracy: 0.9698
epoch 40  | loss: 0.1124 | val_accuracy: 0.9801
epoch 60  | loss: 0.0932 | val_accuracy: 0.9847
Early stopping at epoch 71 | best val_accuracy: 0.9851

Evaluation

y_pred = clf.predict(X_test)

print(classification_report(
    y_test, y_pred,
    target_names=le.classes_,
    digits=3
))

                   precision    recall  f1-score   support

           BENIGN      0.992     0.987     0.990     13469
          DDoS           0.981     0.994     0.987      2566
     DoS GoldenEye      0.963     0.949     0.956       461
         DoS Hulk       0.978     0.983     0.981      9232
    DoS Slowloris       0.971     0.958     0.965       150
     FTP-Patator       0.994     0.991     0.993       259
          PortScan      0.979     0.982     0.981      3178
      SSH-Patator       0.989     0.986     0.988       235

         accuracy                          0.985     29550
        macro avg      0.981     0.979     0.980     29550
     weighted avg      0.985     0.985     0.985     29550

98.5% accuracy, 0.980 macro F1. Strong — but accuracy alone is not enough for a security system. We need to understand what the model learned.

Explainability with SHAP

SHAP computes Shapley values: for each prediction, how much did each feature contribute to pushing the output above or below the baseline?

\[\phi_i = \sum_{S \subseteq F \setminus \{i\}} \frac{|S|!(|F|-|S|-1)!}{|F|!} \left[ f(S \cup \{i\}) - f(S) \right]\]

Where \(\phi_i\) is the Shapley value for feature \(i\), \(F\) is the full feature set, and \(f(S)\) is the model output using only the feature subset \(S\).

TabNet has a built-in feature importance mechanism (via the sparse attention masks). We combine it with SHAP’s model-agnostic KernelExplainer for sample-level explanations.

Global Feature Importance (TabNet built-in)

feature_importances = clf.feature_importances_
feature_names       = X.columns.tolist()

# Top 15 features
fi_df = pd.DataFrame({
    "feature":    feature_names,
    "importance": feature_importances
}).sort_values("importance", ascending=False).head(15)

plt.figure(figsize=(9, 5))
plt.barh(fi_df["feature"][::-1], fi_df["importance"][::-1], color="#1976D2")
plt.xlabel("Mean Attention Weight")
plt.title("TabNet Global Feature Importance — IoMT Intrusion Detection")
plt.tight_layout()
plt.savefig("tabnet_global_importance.png", dpi=150)
plt.show()

Top features (representative): Flow Duration, Total Fwd Packets, Bwd Packet Length Max, Flow Bytes/s, Fwd IAT Total.

SHAP Summary Plot (Sample-Level)

# Use a background sample for SHAP KernelExplainer
background = shap.sample(X_train, 100)

# Predict probabilities (needed for KernelExplainer)
def predict_proba(x):
    return clf.predict_proba(x)

explainer   = shap.KernelExplainer(predict_proba, background)

# Explain 200 test samples (KernelExplainer is slow — sample wisely)
X_explain   = X_test[:200]
shap_values = explainer.shap_values(X_explain, nsamples=100)

# Summary plot for the DDoS class (index 1)
shap.summary_plot(
    shap_values[1],
    X_explain,
    feature_names=feature_names,
    max_display=15,
    show=False
)
plt.title("SHAP Summary — DDoS Class")
plt.tight_layout()
plt.savefig("shap_summary_ddos.png", dpi=150, bbox_inches="tight")
plt.show()

The SHAP summary plot shows:

Each dot = one sample
Position on X = SHAP value (positive → pushes toward DDoS prediction)
Colour = feature value (red = high, blue = low)

For DDoS: high Flow Bytes/s and high Total Fwd Packets with short Flow Duration strongly push toward DDoS — consistent with volumetric attack behaviour.

Single Prediction Explanation

# Pick a DDoS sample
ddos_indices = np.where(y_test == le.transform(["DDoS"])[0])[0]
sample_idx   = ddos_indices[0]
sample       = X_test[sample_idx:sample_idx+1]

shap_single = explainer.shap_values(sample, nsamples=200)

shap.force_plot(
    explainer.expected_value[1],
    shap_single[1][0],
    sample[0],
    feature_names=feature_names,
    matplotlib=True,
    show=False
)
plt.title(f"Force Plot — DDoS prediction (true label: DDoS)")
plt.tight_layout()
plt.savefig("shap_force_ddos.png", dpi=150, bbox_inches="tight")
plt.show()

The force plot shows which features pushed the prediction from the base rate toward “DDoS”: a high packet rate, uniform packet sizes, and near-zero inter-arrival time are the primary drivers — exactly what a DDoS flood looks like at the network level.

Why This Matters for Healthcare

XAI Benefit	Clinical Security Context
Auditability	Regulatory bodies (HIPAA, MDR) require documented decision rationale
Trust calibration	Engineers can sanity-check: “Does the model flag DDoS for the right reasons?”
Bias detection	SHAP reveals if model relies on artefacts (e.g., specific IP ranges from lab collection)
Incident reporting	Force plots translate directly into incident log entries

A model that correctly detects 98.5% of attacks but cannot explain a single prediction is not deployable in a hospital environment. SHAP bridges that gap.

Limitations

KernelExplainer is slow. For production, use TreeSHAP (tree-based models) or DeepSHAP (PyTorch models with hooks).
SHAP ≠ causality. High SHAP value for Flow Bytes/s means it correlates with the prediction — not that it causes the attack.
Distribution shift. IoMT devices in real hospitals produce different traffic patterns than CICIDS lab captures. Always validate on data from the deployment environment.

Exercises

Replace TabNet with a standard gradient-boosted tree (XGBoost). Compare SHAP TreeExplainer speed vs. KernelExplainer.
Use shap.dependence_plot to visualise how Flow Duration interacts with Fwd Packet Length Mean for the DDoS class.
Apply SHAP to identify and remove features that are artefacts of the data collection setup rather than real attack signals.
Implement LIME as an alternative explainability method. Compare its local explanations with SHAP on the same samples.

References

Pande, S., Mahore, T., et al. (2026). TabTransformer for Explainable IoMT Intrusion Detection. Academic Press Book Chapter.
Huang, X., et al. (2020). TabTransformer: Tabular Data Modeling Using Contextual Embeddings. arXiv:2012.06678.
Lundberg, S. M. & Lee, S.-I. (2017). A Unified Approach to Interpreting Model Predictions. NeurIPS 2017.
Arik, S. Ö. & Pfister, T. (2021). TabNet: Attentive Interpretable Tabular Learning. AAAI 2021.
Sharafaldin, I., et al. (2018). Toward Generating a New Intrusion Detection Dataset. ICISSP 2018.

Google Gemini updates: Flash 1.5, Gemma 2 and Project Astra

2024-05-14T00:00:00+00:00

Gemini breaks new ground with a faster model, longer context, AI agents and moreLearn more:Learn more:Learn more:Models & ResearchProductsInfrastructure & cloudTechnology Learn more: ProductsPlatformsDevices Learn more: Outreach & initiativesLeadershipInside Google Learn more: May 14, 2024 We’re introducing a series of updates across the Gemini family of models, including the new 1.5 Flash, our lightweight model for speed and efficiency, and Project Astra, our vision for the future of AI assistants. Demis HassabisCEO of Google DeepMind, on behalf of the Gemini teamIn December, we launched our first natively multimodal model Gemini 1.0 in three sizes: Ultra, Pro and Nano. Just a few months later we released 1.5 Pro, with enhanced performance and a breakthrough long context window of 1 million tokens.Developers and enterprise customers have been putting 1.5 Pro to use in incredible ways and finding its long context window, multimodal reasoning capabilities and impressive overall performance incredibly useful.We know from user feedback that some applications need lower latency and a lower cost to serve. This inspired us to keep innovating, so today, we’re introducing Gemini 1.5 Flash: a model that’s lighter-weight than 1.5 Pro, and designed to be fast and efficient to serve at scale.Both 1.5 Pro and 1.5 Flash are available in public preview with a 1 million token context window in Google AI Studio and Vertex AI. And now, 1.5 Pro is also available with a 2 million token context window via waitlist to developers using the API and to Google Cloud customers.We’re also introducing updates across the Gemini family of models, announcing our next generation of open models, Gemma 2, and sharing progress on the future of AI assistants, with Project Astra.Context lengths of leading foundation models compared with Gemini 1.5’s 2 million token capability1.5 Flash is the newest addition to the Gemini model family and the fastest Gemini model served in the API. It’s optimized for high-volume, high-frequency tasks at scale, is more cost-efficient to serve and features our breakthrough long context window.While it’s a lighter weight model than 1.5 Pro, it’s highly capable of multimodal reasoning across vast amounts of information and delivers impressive quality for its size.The new Gemini 1.5 Flash model is optimized for speed and efficiency, is highly capable of multimodal reasoning and features our breakthrough long context window.1.5 Flash excels at summarization, chat applications, image and video captioning, data extraction from long documents and tables, and more. This is because it’s been trained by 1.5 Pro through a process called “distillation,” where the most essential knowledge and skills from a larger model are transferred to a smaller, more efficient model.Read more about 1.5 Flash in our updated Gemini 1.5 technical report, on the Gemini technology page, and learn about 1.5 Flash’s availability and pricing.Over the last few months, we’ve significantly improved 1.5 Pro, our best model for general performance across a wide range of tasks.Beyond extending its context window to 2 million tokens, we’ve enhanced its code generation, logical reasoning and planning, multi-turn conversation, and audio and image understanding through data and algorithmic advances. We see strong improvements on public and internal benchmarks for each of these tasks.1.5 Pro can now follow increasingly complex and nuanced instructions, including ones that specify product-level behavior involving role, format and style. We’ve improved control over the model’s responses for specific use cases, like crafting the persona and response style of a chat agent or automating workflows through multiple function calls. And we’ve enabled users to steer model behavior by setting system instructions.We added audio understanding in the Gemini API and Google AI Studio, so 1.5 Pro can now reason across image and audio for videos uploaded in Google AI Studio. And we’re now integrating 1.5 Pro into Google products, including Gemini Advanced and in Workspace apps.Read more about 1.5 Pro in our updated Gemini 1.5 technical report and on the Gemini technology page.Gemini Nano is expanding beyond text-only inputs to include images as well. Starting with Pixel, applications using Gemini Nano with Multimodality will be able to understand the world the way people do — not just through text, but also through sight, sound and spoken language.Read more about Gemini 1.0 Nano on Android.Today, we’re also sharing a series of updates to Gemma, our family of open models built from the same research and technology used to create the Gemini models.We’re announcing Gemma 2, our next generation of open models for responsible AI innovation. Gemma 2 has a new architecture designed for breakthrough performance and efficiency, and will be available in new sizes.The Gemma family is also expanding with PaliGemma, our first vision-language model inspired by PaLI-3. And we’ve upgraded our Responsible Generative AI Toolkit with LLM Comparator for evaluating the quality of model responses.Read more on the Developer blog.As part of Google DeepMind’s mission to build AI responsibly to benefit humanity, we’ve always wanted to develop universal AI agents that can be helpful in everyday life. That’s why today, we’re sharing our progress in building the future of AI assistants with Project Astra (advanced seeing and talking responsive agent).To be truly useful, an agent needs to understand and respond to the complex and dynamic world just like people do — and take in and remember what it sees and hears to understand context and take action. It also needs to be proactive, teachable and personal, so users can talk to it naturally and without lag or delay.While we’ve made incredible progress developing AI systems that can understand multimodal information, getting response time down to something conversational is a difficult engineering challenge. Over the past few years, we’ve been working to improve how our models perceive, reason and converse to make the pace and quality of interaction feel more natural.Building on Gemini, we’ve developed prototype agents that can process information faster by continuously encoding video frames, combining the video and speech input into a timeline of events, and caching this information for efficient recall.By leveraging our leading speech models, we also enhanced how they sound, giving the agents a wider range of intonations. These agents can better understand the context they’re being used in, and respond quickly, in conversation.With technology like this, it’s easy to envision a future where people could have an expert AI assistant by their side, through a phone or glasses. And some of these capabilities are coming to Google products, like the Gemini app and web experience, later this year.We’ve made incredible progress so far with our family of Gemini models, and we’re always striving to advance the state-of-the-art even further. By investing in a relentless production line of innovation, we’re able to explore new ideas at the frontier, while also unlocking the possibility of new and exciting Gemini use cases.Learn more about Gemini and its capabilities.Collection Sign up for our newsletters with product updates, event information, special offers, and more. Done. Just one step more. Check your inbox to confirm your subscription.

You can also subscribe with a different email address.
  
        Your information will be used in accordance with Google's privacy policy. You may opt out at any time.

Displaying External Posts on Your al-folio Blog

2022-04-23T23:20:09+00:00

External Posts on Your al-folio Blog

If you prefer publishing blog posts on medium.com or other external sources, starting version v0.5.0, al-folio lets you to display your external posts in the blog feed of your website! 🎉🎉

Configuring external sources of super simple. After upgrading to v0.5.0, just add the following section to your _config.yml:

external_sources:
  - name: medium.com  # name of the source (arbitrary string)
    rss_url: https://medium.com/@/feed

The example above adds your medium.com blog post feed as an external source. But you can add arbitrary RSS feeds as sources.

Any questions or suggestions? 👉 Start a discussion on GitHub!