Ruthuraraj R

RAG-LMS · EdTech AI Long-Term Vision

R-B.A.T — RAG-Based Academic Tutor

An offline-first academic learning system that transforms textbooks and PDFs into an interactive tutor, assessment engine, presentation assistant, and evaluation tool. Built around a shared RAG backbone and local LLMs, R.B.A.T. explores how AI can make subject-specific learning more accessible, private, and grounded in course material.

One retrieval backbone, four learning workflows. R.B.A.T. uses shared course knowledge to power tutoring, assessment, presentation, and evaluation experiences through specialised prompting strategies.

Why this matters: R.B.A.T. is my long-term exploration of local-first educational AI systems that can operate without dependence on frontier cloud models.

Tutor Mode

Context-aware Q&A grounded in uploaded textbooks

Assessment Mode

Automated question bank generation from source material

Presentation Mode

Structured note & slide generation from PDF content

Evaluation Mode

Response scoring and feedback against retrieved context

Local LLMs ChromaDB SentenceTransformers pypdf Streamlit Ollama Diagram-Aware Retrieval

Problem

Students preparing for BCM examinations often work with static PDFs and textbooks that cannot answer questions, generate practice material, or explain concepts interactively. Generic chatbots frequently introduce information outside the prescribed syllabus, reducing trust in the learning process.

Key Decision

Chose fully local LLMs over API models so the system runs on student laptops with no internet dependency, no API cost, and no data leaving the machine.

Architecture

Single ChromaDB vector store backing four distinct modes — each mode uses the same retrieval backbone but a different prompt strategy, output format, and evaluation criteria.

⚠ Failure mode: Important information in engineering textbooks often resides inside diagrams rather than surrounding text. Early versions retrieved relevant passages but missed figure-level context, producing incomplete answers. Fixed by introducing a dedicated figure extraction pipeline that indexes diagrams separately and injects semantically relevant visuals alongside retrieved text during response generation.

✅ Outcome: Students can interact with their own course material through tutoring, assessment, presentation, and evaluation workflows while remaining grounded in uploaded textbooks. The system demonstrates how local-first AI can support education without cloud APIs, recurring costs, or external data transfer.

Architecture

PDF / Textbook Upload

↓ chunk · embed · index

ChromaDB Vector Store

↓ semantic retrieval

RAG Context Builder

↓ mode-specific prompting

🎓 Tutor

📝 Assessment

📊 Presentation

✅ Evaluation

↓ local LLM generation

Grounded Academic Response

Proof 📖 Read the Deep Dive → ▶ Demo Video — coming soon

CrewAI · Adaptive Assessment System ✦ New

Adaptive AI Engineer Interview System

An adaptive interview system that selects the next question based on a candidate's live performance, generates it against a fixed competency graph, and scores spoken or typed answers against a rubric — built as two orchestrated CrewAI flows over deterministic Pydantic domain models, not free-form LLM judgment.

The competency graph, difficulty progression, and rubrics are deterministic Pydantic models. The LLM is scoped to exactly two jobs — generate the next question within that structure, and evaluate an answer against the rubric it's given — it never decides on its own what "good" looks like.

Dual CrewAI Flows

Generation and Evaluation run as separate orchestrated flows

Competency Graph

Deterministic blueprint drives question selection, not the LLM

Live Speech-to-Text

Groq Whisper-large-v3, auto-transcribed the moment recording stops

Dual-View UI

Candidate flow + an "Observability" reasoning-trace dashboard

CrewAI Pydantic Gemini Groq Whisper-large-v3 Streamlit LiteLLM

GitHub →

Problem

Interview prep tools typically generate static question banks with no adaptivity — difficulty doesn't respond to how the candidate is actually performing, and evaluation is usually a keyword match or a single ungrounded LLM call.

Key Decision

Kept the competency graph, difficulty progression, and rubrics as deterministic Pydantic domain models — the LLM only generates the next question within that structure and scores answers against a fixed rubric, rather than deciding on its own what counts as a good answer.

Architecture

An InterviewController orchestrates two CrewAI Flows — AssessmentGenerationFlow (Strategy Agent selects the next competency/difficulty, Question Agent writes the question) and AssessmentEvaluationFlow (Evaluation Agent scores the answer) — with Gemini and Groq as interchangeable providers via CrewAI's LLM wrapper.

⚠ Failure mode: An early version of the difficulty-selection logic had a rationale mismatch — the system reported choosing a difficulty for one reason while the underlying stub logic used to select it didn't actually match that reasoning. Traced directly to the difficulty-stub logic and fixed before layering the UI on top, rather than patching around it visually.

✅ Outcome: A live, publicly deployed adaptive interview system with real-time speech transcription, and a dual-view UI toggling between a candidate-facing flow and an interviewer "Observability" dashboard rendered as a monospace reasoning trace — shipped and deployed rather than staying a local prototype.

Adaptive Assessment Flow

Competency Graph (deterministic)

↓ AssessmentGenerationFlow

Strategy Agent → Question Agent

↓ candidate answers (voice/text)

Whisper-large-v3 Transcription

↓ AssessmentEvaluationFlow

Evaluation Agent → Rubric Score

↓ render

Candidate View + Observability Trace

Live Demo 🚀 Try the Live Demo

LangGraph · Agentic Research System ✦ New

D.A.R.I.A. — Domain-Specific Agentic Research, Intelligence & Analysis System

A memory-driven multi-agent research system that turns a query into an evidence-backed report through planning, hybrid retrieval, critique, reflection, and persistent learning. Combines domain-specific RAG with web research, evidence curation, and a dedicated Research Critic to move beyond one-shot question answering.

Retrieved evidence isn't trusted by default — a Research Critic independently evaluates it, flags missing concepts, and triggers replanning when research quality falls short. Plans, gaps, critic feedback, and final reports persist as memory and get reused in future investigations.

Research Critic

Evaluates evidence quality, flags gaps, triggers replanning

Parallel Hybrid Retrieval

Domain RAG + web search run concurrently, merged pre-critique

Persistent Memory

Research plans & critic feedback reused across future sessions

Structured Reports

Evidence-backed summaries with DOCX export

LangGraph LiteLLM Gemini 2.5 Flash ChromaDB Docling Tavily Pydantic python-docx

GitHub →

Problem

One-shot research agents retrieve evidence and generate a report in a single pass — there's no check on whether the retrieved evidence was actually sufficient before the report gets written.

Key Decision

Introduced a dedicated Research Critic agent that independently evaluates curated evidence, identifies missing concepts, and can force the graph back to a replanning step rather than letting weak evidence flow straight to the report.

Architecture

LangGraph StateGraph: Memory Agent → Information Needs Analyst → parallel Hybrid RAG/Web Retrieval → Evidence Curator → Research Critic → Reflection Loop → Summarizer → Memory Update.

⚠ Failure mode: The Critic's judgments about evidence sufficiency have no quantitative evaluation harness behind them yet — without RAGAS- or LangSmith-style scoring, the system can confidently approve weak evidence with nothing external to check the critique itself against. Documented as the clear next build, not papered over.

✅ Outcome: Confirmed end-to-end runs producing evidence-backed reports, with research plans and critic feedback persisted and reused across sessions — rated the strongest piece in the portfolio for reproducibility, precisely because its remaining gaps (evaluation infrastructure, single-domain knowledge base) are named rather than hidden.

LangGraph Research Workflow

Memory Agent → Needs Analyst

↓ parallel dispatch

📚 Domain RAG

🌐 Web Retrieval

↓ merge

Evidence Curator

↓ critique

Research Critic → Reflection Loop

INSUFFICIENT → replan · SUFFICIENT ↓

Summarizer + Memory Update

Demo

▶ Watch Demo Walkthrough

CrewAI Flow · Multi-Agent · Multi-LLM ✦ New

Logistics Decision Intelligence Platform

A multi-agent decision intelligence platform for supply chain optimization built with CrewAI Flows. Parallel Inventory and Delivery analysis branches converge into a strategy engine, followed by an independent critique stage before recommendations are finalized.

Four specialized LLMs — Groq Llama-3.3-70B, Gemma-4-26B, Gemma-4-31B, Gemini Flash Lite 3.1 are assigned to distinct cognitive roles—inventory analysis, geospatial routing, strategy synthesis, and independent critique—allowing each stage to balance capability, latency, and cost rather than relying on a single model for every task.

Why this matters: Most AI agent systems solve a problem once. This platform explores how multi-agent systems can accumulate organizational knowledge over time and improve decisions across repeated operational cycles.

Parallel Execution

Inventory & Delivery branches run concurrently; and_() sync barrier gates Strategy

Reflection Loop

Strategist → Critic → Reflection Router → Revision or Approve

Delta Memory

SQLite stores every run per product; historical strategies injected at init

Portfolio Comparison

Comparison Agent ranks products by ROI, risk, and complexity

CrewAI Flow Pydantic State Groq Llama-3.3-70B Gemma-4-31B Gemini Flash Lite SQLite Memory Gradio DataCo Supply Chain

Problem

Traditional logistics dashboards surface what happened — late deliveries, stock gaps — but leave a human expert to decide what to do. Each analysis starts from scratch, never building on prior recommendations.

Key Decision

Used CrewAI Flow's and_() synchronization barrier to execute Inventory and Delivery analysis in parallel, ensuring the Strategist only receives a complete operational picture once both branches finish.

Architecture

Four-tier Multi-LLM: Groq Llama-3.3-70B for inventory, Gemma-4-26B for geospatial routing, Gemma-4-31B for strategy synthesis, Gemini Flash Lite for independent critique — each matched to workload and cost.

⚠ Failure mode: Early runs passed critique outputs as stringified dictionaries instead of structured objects, causing downstream revision failures. A normalize_output() layer was introduced to standardize communication across all agent outputs.

✅ Outcome: A context-aware decision platform that accumulates organizational knowledge. The Strategist on run 3 knows what was recommended on runs 1 and 2 — avoiding redundant suggestions and building delta reasoning on top of stored history.

CrewAI Flow Pipeline

State Init + SQLite Memory Hydration

↓ @router → "inventory" / "delivery" / "full"

📦 Inventory Branch

🚚 Delivery Branch

↓ and_() sync barrier

Memory-Aware Strategist Crew

↓ Critic Audit

Reflection Router → APPROVED / REVISE

↓ finalize + persist to SQLite

Final Strategy Playbook

Demo

▶ Watch Demo Walkthrough

GitHub →

CrewAI · AI Code Debugging ✦ New

AI-Powered Code Debugging Assistant

A multi-agent debugging assistant that turns Python source code into structured debugging reports through collaborative analysis, automated correction, and workflow verification — combining specialized Analyzer, Corrector, and Manager agents with code execution and a live Streamlit dashboard.

Instead of asking an LLM to directly generate complex application objects, a Builder Pattern separates reasoning from artifact construction — lightweight LLM output gets converted into strongly-typed Pydantic domain artifacts, cutting schema validation failures.

Builder Pattern

Converts loose LLM output into typed domain artifacts

Code Interpreter

Executes and validates corrected code automatically

Execution Tracing

Custom observability layer logs every pipeline stage

Diff Console

Live Ace code editor with side-by-side diff view

CrewAI CodeInterpreterTool Groq Llama 3.3 70B Streamlit streamlit-ace Pydantic LiteLLM

GitHub →

Problem

Asking an LLM to directly generate complex, strongly-typed application objects — analysis reports, corrected code artifacts — is unreliable, since the model is handling both reasoning and object construction at once.

Key Decision

Adopted a Builder Pattern: agents produce lightweight, loosely-structured output, which a dedicated builder layer converts into strongly-typed Pydantic artifacts — separating what the model reasons about from what the application consumes.

Architecture

Sequential CrewAI pipeline: Analyzer Agent → Analysis Builder → Analysis Report → Corrector Agent → Correction Builder → Corrected Code Artifact → Manager Agent → Verification → Streamlit Dashboard.

⚠ Failure mode: The Manager agent's verification stage remains the weakest link — it currently returns unstructured raw text instead of a validated Pydantic object (no output_pydantic), so final verification doesn't yet get the same reliability guarantees as the Analyzer and Corrector stages. Left as an open item rather than hidden.

✅ Outcome: A working sequential debugging pipeline with a strongly-typed schema layer, an execution tracer for observability, and a redesigned Streamlit console — sidebar layout, live code editor, side-by-side diff view — with the Manager verification gap documented as the clear next fix.

Sequential CrewAI Pipeline

Source Code Input

↓ analyze

Analyzer → Analysis Builder

↓ correct

Corrector → Correction Builder

↓ verify

Manager Agent (Verification)

↓ render

Streamlit Diff Dashboard

Demo

▶ Watch Demo Walkthrough

PEFT · LoRA & QLoRA Fine-Tuning

Parameter-Efficient Fine-Tuning of BERT & Gemma using LoRA & QLoRA

A hands-on exploration of Parameter-Efficient Fine-Tuning, progressing from LoRA-based adaptation of BERT to QLoRA-based instruction tuning of Gemma 2B — adapting large models by training a tiny fraction of their parameters while cutting memory requirements through 4-bit quantization.

The repository preserves a failed QLoRA attempt on BERT alongside the successful Gemma 2B run — encoder vs. decoder architecture differences don't surface until quantized training actually starts, and that failure is documented rather than edited out.

BERT + LoRA

90.41% accuracy · 591K trainable params (0.54%)

Gemma 2B + QLoRA

97.04%* accuracy · 6.39M trainable params (0.24%)

Quantization

4-bit NF4 via BitsAndBytes

Hardware

Single Tesla T4 (free-tier Colab)

BERT Gemma 2B LoRA QLoRA PEFT BitsAndBytes Hugging Face

Problem

Full fine-tuning updates every parameter and holds full-precision gradients in memory — infeasible on a free-tier Colab T4 (~16GB) for anything beyond small encoder models.

Key Decision

Working within Colab's runtime and memory ceiling, proved PEFT first on BERT with LoRA — cheap to validate — then took the harder step of QLoRA fine-tuning a 2B-parameter decoder model under the same hardware constraint.

Architecture

LoRA adapters in BERT's attention layers (591K trainable params) for stage one; 4-bit NF4 quantization + QLoRA adapters on Gemma 2B (6.39M trainable params) for stage two, using BitsAndBytes for quantized weight loading.

⚠ Failure mode: An initial attempt to apply QLoRA directly to BERT failed — bitsandbytes 4-bit quantization and PEFT's QLoRA path are built around decoder architectures, and encoder-only BERT hit compatibility issues that only surfaced once quantized training actually started. Fixed by keeping plain LoRA (no quantization) for BERT and reserving QLoRA for the decoder-based Gemma 2B.

✅ Outcome: Two working PEFT pipelines on a single T4 — LoRA/BERT at 90.41% accuracy with 0.54% trainable parameters, and QLoRA/Gemma 2B at 97.04%* accuracy with 0.24% trainable parameters — with the encoder-vs-decoder compatibility failure kept in the repo as a documented learning artifact.

Results Comparison

BERT + LoRA (Encoder)

90.41%

591K params trained · 0.5372%

↓ QLoRA fails on encoder · pivot to decoder

Gemma 2B + QLoRA (Decoder)

97.04%*

6.39M params trained · 0.2438% · 4-bit NF4

*Metrics on valid predictions mappable to sentiment labels

GitHub →

AutoGen AgentChat · Financial Intelligence ✦ New

Financial Intelligence Platform

A multi-agent financial intelligence platform that turns bill images into actionable insights through deterministic analytics, expense forecasting, and collaborative AI reasoning. Combines OCR, recurring-expense detection, and a dedicated Advisor–Reviewer workflow to produce explainable, verified recommendations.

Deterministic financial analytics are deliberately kept separate from LLM reasoning. Structured reports are computed first; a Financial Reviewer independently checks them before the Advisor produces the final verified consultation — every recommendation traces back to real numbers, not model arithmetic.

OCR Bill Processing

EasyOCR extraction feeding deterministic categorization

Recurring Expense Detection

Flags patterns feeding into monthly spend forecasting

Advisor–Reviewer Loop

Every consultation independently reviewed before delivery

Intent-Based UI

Streamlit flows routed by three distinct agent paths

AutoGen AgentChat Gemini Groq Streamlit EasyOCR Plotly Pydantic

GitHub →

AutoGen Consultation Pipeline

OCR Bill Processing

↓ categorize + detect recurring

Expense Analytics + Forecast

↓ hand off to agents

Financial Advisor

↓ independent review

Financial Reviewer

↓ synthesize

Verified Consultation

Demo

Financial Intelligence Platform Walkthrough

▶ Watch Demo Walkthrough

LangGraph · ReAct · RAG ✦ New

Competitor Intelligence Agent

A LangGraph-powered ReAct-style agentic platform for retail market analysis — discovering nearby clothing store competitors via Apify's Google Places crawler, enriching each with empirical traffic data from BestTime API, and running a reflection-driven validation loop before synthesising AI executive reports. Built in 2 days as a fully functional intelligence system.

The dual-layer traffic strategy is the key engineering decision: BestTime empirical data where available, an analytical inference fallback engine everywhere else — guaranteeing 100% traffic profile coverage even when the primary API returns nothing.

Reflection Engine

SUFFICIENT / INSUFFICIENT loop-back validation on data quality

Dual-Layer Traffic

BestTime API + analytical inference fallback for all competitors

Persistent Memory

ChromaDB vectorises every analysis; Gemini RAG for cross-session Q&A

Export Suite

Presentation-grade PDF reports + structured Excel data downloads

LangGraph LangChain Gemini Flash Lite ChromaDB Apify BestTime API Plotly Streamlit ReportLab OpenPyXL

GitHub →

LangGraph ReAct Cycle

Apify Google Places Search

↓ discover competitors

BestTime + Inference Enrichment

↓ KPIs + competitive scores

Analytics Engine

↓ validate coverage

Reflection Engine

INSUFFICIENT → loop back · SUFFICIENT ↓

Gemini Executive Summary + ChromaDB Memory

Demo

Competitor Intelligence Platform Walkthrough

▶ Watch Demo Walkthrough

Agentic AI · LangGraph

Reflective Travel Assistant

A memory-aware agentic travel planner built on LangGraph's StateGraph. The system collects weather and destination data, then runs a self-evaluation loop — the agent reflects on its own information quality, scores its confidence, identifies specific knowledge gaps, and conditionally re-searches before generating the final personalised itinerary.

The reflection loop produces observable, logged state transitions in the UI — "INSUFFICIENT (confidence 40%) → re-query → SUFFICIENT (confidence 80%)" — making the agent's internal reasoning auditable, not a black box.

Reflection Engine

LLM scores confidence + identifies missing topics per cycle

Conditional Re-search

Targeted Tavily queries for exactly the identified gaps

Image Enrichment

Pexels API attaches photos only after data quality confirmed

Personalisation

Diet, style, budget, transport enforced at prompt level

LangGraph LangChain Gemini Flash Lite Tavily Search WeatherAPI Pexels API Streamlit Session Memory

GitHub →

LangGraph StateGraph

WeatherAPI + Tavily Discovery

↓ initial collection

Reflection Engine (LLM)

↓ INSUFFICIENT? → re-search

Query Generator + Researcher

↑ loops back · max 2 cycles

Pexels Image Enrichment

↓ SUFFICIENT

Personalised Travel Guide

Demo

▶ Watch Demo Walkthrough

Multimodal RAG · LLM Systems ✦ New

Paperwise RAG — Multimodal Research Paper Q&A

A multimodal RAG pipeline for research paper question answering — handling text, tables, and figures from academic PDFs in a unified system. Papers are parsed with Docling (preserving cross-modality structure), embedded with BGE embeddings into FAISS, and answered via Gemini with vision-enabled summarisation for figures and tables. Most RAG pipelines lose structured information in tables and visual content in figures; Paperwise RAG queries each modality separately and merges results before generation.

A real production challenge solved: OOM crashes on high-resolution page rasterisation on large PDFs were fixed by tuning Docling's image scale and disabling full-page generation — the kind of engineering detail that only comes from building against real data.

Text Chunks

Prose extracted + chunked with structure preserved by Docling

Tables

Structured table cells embedded and retrieved independently

Figures

Vision-enabled Gemini summarisation of extracted images

Merged Generation

Three-modality results fused before Gemini generates the answer

Docling BGE Embeddings FAISS Gemini Flash Lite Vision-Language Gradio Python

GitHub (under maintenance) →

Three-Modality Pipeline

Research PDF Upload

↓ Docling parse (structure-preserving)

📄 Text

📊 Tables

🖼 Figures

↓ BGE embed → FAISS index (per modality)

Query → Retrieve from all 3 modalities

↓ merge results

Gemini: Vision-aware Answer Generation

Agentic AI · Multi-LLM

ReAct Web Research Agent

An autonomous research intelligence system built on the ReAct (Reasoning + Acting) paradigm. Given a topic, the agent generates 6 targeted research questions, then runs a full Thought → Action → Observation → Summary loop per question — combining Gemini for planning and synthesis with Groq LLaMA for fast, tight reasoning at each step.

The multi-LLM split is intentional: Gemini handles structure-heavy tasks (question generation, final report), while Groq LLaMA handles latency-sensitive reasoning loops. Two models, two roles — not interchangeable.

Planning

Gemini generates 6 structured research questions

Reasoning

Groq LLaMA generates Thought and Observation per cycle

Retrieval

Tavily Search fetches live web results per question

Output

Exportable report.md + full ReAct trace.md

Gemini Flash Lite Groq LLaMA 3.3 70B Tavily Search ReAct Loop Research Memory Streamlit

GitHub →

ReAct Loop (per question)

User Topic Input

↓ Gemini: generate 6 questions

Groq LLaMA: Generate Thought

↓ Action

Tavily: Live Web Search

↓ Observation

Groq LLaMA: Observation + Summary

↓ store in Research Memory

📄 report.md

🔍 trace.md

Demo

▶ Watch Demo Walkthrough

Multi-Agent

AI Content Studio — Multi-Agent System

Transforms a topic prompt into structured educational content via four specialised agents: Research (RAG) → Image (diffusion) → Reviewer → Manager. Failure cases in agent handoffs and RAG retrieval are documented alongside the working pipeline.

CrewAI Gemini Groq FLUX RAG

GitHub →

RAG · ReAct-lite

Workshop Assistant — ReAct-lite RAG Agent

Built as a live demo for the 3-day AI workshop. Answers questions grounded in workshop PDFs and notebooks using a heuristic ReAct-style loop — LLM routing replaced with a FAISS L2 distance threshold, making reasoning fully deterministic and transparent to a non-CS audience.

Gemini API SentenceTransformers FAISS pypdf Streamlit

GitHub →

Embeddings

Word2Vec Embedding Explorer

End-to-end Word2Vec (Skip-Gram + Negative Sampling) built from scratch in PyTorch, with an interactive browser-based explorer showing how semantic structure emerges from random vectors across training epochs.

Word2Vec PyTorch FAISS WikiText-2

GitHub → Live Demo →

Generative AI

Image Super-Resolution — SRGAN & ESRGAN

×4 super-resolution built from scratch with patch-based training, warm-up stability phases, and adversarial fine-tuning. Perceptual trade-offs and mode collapse behaviour are honestly documented without cherry-picked results.

SRGAN ESRGAN RRDB VGG Loss DIV2K

GitHub →

Multimodal AI

Image Caption Generator

Progresses from CNN–LSTM baseline (InceptionV3 + LSTM) through Transformer decoder to pretrained vision–language models. Validates learning via controlled overfitting and honestly documents why pretrained models outperform naive fine-tuning on small datasets.

InceptionV3 LSTM Transformer HuggingFace

GitHub →

Classical ML

XOR Problem — Why Deep Learning Exists

A concept-driven bridge from classical ML to deep learning. Deliberately breaks logistic regression on XOR before solving it with a single hidden layer MLP — focusing entirely on decision boundaries and architectural necessity, not accuracy.

scikit-learn MLP Decision Boundaries

GitHub →

I build AI systems that retrieve, reason, and collaborate — and document the engineering decisions, failures, and lessons behind them.

Workshops I've Organised & Led

From Machine Learning to AI Agents: A Practical Hands-on Introduction

AI Content Studio: Multi-Agent AI System

Build Your Own Local AI Assistant: From Tools to Grounded AI Agents

The Transition

Systems, Experiments & Learning Journey

R-B.A.T — RAG-Based Academic Tutor

Adaptive AI Engineer Interview System

D.A.R.I.A. — Domain-Specific Agentic Research, Intelligence & Analysis System

Logistics Decision Intelligence Platform

AI-Powered Code Debugging Assistant

Parameter-Efficient Fine-Tuning of BERT & Gemma using LoRA & QLoRA

Financial Intelligence Platform

Competitor Intelligence Agent

Reflective Travel Assistant

Paperwise RAG — Multimodal Research Paper Q&A

ReAct Web Research Agent

AI Content Studio — Multi-Agent System

Workshop Assistant — ReAct-lite RAG Agent

Word2Vec Embedding Explorer

Image Super-Resolution — SRGAN & ESRGAN

Image Caption Generator

XOR Problem — Why Deep Learning Exists

Skills & Tools

Certifications

Active on Coding Platforms

Build Logs & Articles

Let's Build Something Together