Category: AI Frontiers

We’ve all been there: you ask an LLM a question about a recent event or a specific technical paper, and it either hallucinates or admits its knowledge cutoff. That’s why the paper “Enhancing Large Language Models with Retrieval-Augmented Generation: A Comprehensive Overview” caught my eye.

RAG isn’t just a “feature”—it’s a fundamental shift in how we build AI. It’s the difference between a student trying to memorize a whole library (Standard LLM) and a student who knows exactly how to use the library’s index (RAG).

Living in Istanbul, I decided to put this to the test by building a local RAG system that “reads” my entire collection of downloaded arXiv papers stored on my 6TB HDD.

The Architecture: Why My Setup Shines

To reproduce the “Comprehensive Overview” findings, I needed more than just a good GPU. RAG is a three-legged stool: Embedding, Retrieval, and Generation.

1. The SSD Advantage: I moved my Vector Database (ChromaDB) to my 2TB M.2 SSD. When you are performing similarity searches across thousands of document chunks, disk I/O latency is the enemy.
2. Dual-GPU Parallelism: I used one RTX 4080 to handle the heavy lifting of the Llama-3 8B generation and the second card specifically for the Embedding Model (HuggingFace bge-large-en-v1.5). This prevents VRAM bottlenecks during simultaneous “search and talk” operations.

The Reproduction Code: Building the Retriever

Following the paper’s “Naive RAG vs. Advanced RAG” comparison, I implemented a recursive character splitter to ensure the context windows weren’t losing information at the edges.

Python

from langchain_community.vectorstores import Chroma
from langchain_huggingface import HuggingFaceEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter

# Utilizing my 2TB SSD for the local vector store
persist_directory = '/mnt/nvme_ssd/vector_db'

# Using my second RTX 4080 for embeddings to keep the main GPU free
model_kwargs = {'device': 'cuda:1'} 

embeddings = HuggingFaceEmbeddings(
    model_name="BAAI/bge-large-en-v1.5",
    model_kwargs=model_kwargs
)

text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
# Processed my 6TB HDD library of PDF research papers here...

The “Advanced RAG” Challenge: Re-ranking

The paper highlights that “Retrieval” isn’t always “Relevant.” In my testing, the biggest breakthrough came from implementing a Re-ranker.

I noticed that standard vector search sometimes brought up papers that had the right keywords but the wrong context. By adding a Cross-Encoder re-ranking step (as described in the “Advanced RAG” section of the overview), my accuracy on technical queries jumped significantly.

My Local Benchmarks: RAG vs. No-RAG

I tested the system on 50 questions regarding 2025 AI trends that weren’t in the model’s original training data.

Export to Sheets

RAG and the Road to AGI

In my discussions with readers, I often argue that AGI won’t just be a “bigger model.” It will be a model that knows how to interact with external memory. Human intelligence relies on our ability to look things up, verify facts, and cite sources. By reproducing this RAG overview locally, I’ve realized that the “General” in AGI might actually stand for “General Access to Information.”

One of the most frustrating limits of early Neural Radiance Fields (NeRF) was their “statue-like” nature. They were great for static objects, but as soon as something moved, the math broke. Recently, I’ve been obsessed with the paper “Unlocking Dynamic Scene Understanding: Neural Radiance Fields for Deformable Objects.” The premise is brilliant: instead of just mapping coordinates (x,y,z) to color and density, we add a time dimension (t) and a canonical deformation field.

Living in Istanbul, I tested this by filming a short clip of a spinning Sema (whirling dervish) figurine on my desk. Here’s how I reproduced the paper’s findings using my local dual-GPU rig.

The Technical Setup: Taming the Time Dimension

Training D-NeRF is significantly more compute-intensive than static NeRFs. You aren’t just learning a volume; you’re learning how that volume warps over time.

On my Ubuntu workstation, I utilized both Nvidia RTX 4080s. Since the paper relies on a “Coarse-to-Fine” training strategy, I dedicated one GPU to the canonical space mapping and the second to the deformation field gradients.

The Implementation Logic

The core of the reproduction lies in the Deformation Network. It takes a point and a timestamp and “un-warps” it back to a static reference frame.

Python

import torch
import torch.nn as nn

class DeformationField(nn.Module):
    def __init__(self, d_in=3, d_out=3, latent_dim=128):
        super().__init__()
        # The paper suggests 8 layers for the MLP to capture complex motion
        self.network = nn.Sequential(
            nn.Linear(d_in + 1, 256), # x, y, z + time t
            nn.ReLU(),
            nn.Linear(256, 256),
            nn.Linear(256, d_out) # Output: Displacement Delta(x, y, z)
        )

    def forward(self, x, t):
        # Concatenate spatial coordinates with time
        input_pts = torch.cat([x, t], dim=-1)
        return self.network(input_pts)

# Initializing on my primary 4080
def_field = DeformationField().to("cuda:0")

Hurdles in the Lab: The “Ghosting” Effect

The biggest issue I faced during reproduction was “ghosting”—where the object appeared blurry during fast movements. The paper suggests using a Spatio-Temporal Importance Sampling strategy.

Initially, I skipped this to save time, but the results were mediocre. Once I implemented the importance sampling (focusing the rays on areas with high temporal variance), the sharpness returned. My 64GB of RAM was crucial here, as I had to cache a significant amount of temporal metadata to keep the GPUs fed with data.

Performance Benchmarks

I compared my local run against the paper’s benchmark on the “Bouncing Ball” and “Human Motion” datasets.

Export to Sheets

Note: My 4080s actually outperformed the paper’s V100 benchmarks in terms of raw training speed, thanks to the Ada Lovelace architecture’s superior clock speeds.

AGI and Dynamic Intelligence

Why does this matter for AGI? In my blog, I often discuss how AGI must perceive the world not as a series of still photos, but as a continuous, flowing reality. If an AI can’t understand how an object deforms—like a hand clenching or a leaf bending—it cannot interact with the physical world. D-NeRF is a massive step toward “Visual Common Sense.”