I am an AI and machine learning professional with an M.Tech in Data Science and Artificial Intelligence from the Indian Institute of Technology Bhilai.

My work and technical interests focus on building intelligent systems that can retrieve information, reason over context, interact with tools, and generate reliable responses.

I have hands-on experience with:

• Large Language Model applications
• Retrieval-Augmented Generation systems
• Semantic search and information retrieval
• Vector databases and embedding models
• Retrieval and reranking pipelines
• Agentic AI workflows
• Structured model outputs
• AI system evaluation
• Model fine-tuning and experimentation
• Local LLM and vision-language model inference
• Backend integration for AI applications
• Industrial time-series anomaly detection
• CUDA and GPU-accelerated deep learning
• Custom PyTorch extensions and performance benchmarking

I enjoy taking technically complex ideas and converting them into practical, measurable, and maintainable software systems.

I work on applications that combine Large Language Models with enterprise data, search systems, external tools, and structured workflows.

My areas of focus include:

• Prompt and context engineering
• Structured response generation
• Tool-integrated AI systems
• Multi-step reasoning workflows
• Retrieval quality improvement
• Response validation
• Hallucination reduction
• Model migration and evaluation
• Failure handling and fallback strategies

I have worked extensively on retrieval pipelines for answering questions from technical and enterprise documentation.

My RAG-related work includes:

• Converting documents into retrieval-ready content
• Generating dense vector embeddings
• Query expansion using multiple search formulations
• Semantic similarity search
• Retrieval threshold tuning
• Candidate deduplication
• Document and chunk reranking
• Context selection
• Retrieval retries when the available evidence is insufficient
• Citation and source mapping
• Incremental document ingestion

I am especially interested in improving RAG systems through systematic evaluation rather than relying only on subjective response quality.

I work with retrieval and ranking metrics to understand whether an AI system is actually improving.

Metrics and evaluation concepts I have explored include:

• Mean Reciprocal Rank
• Normalized Discounted Cumulative Gain
• Hit rate
• Precision and recall
• Retrieval coverage
• Relevance scoring
• Human evaluation
• LLM-assisted evaluation
• Context sufficiency
• Response grounding
• Latency and quality trade-offs

Contributed to the development and improvement of an enterprise Retrieval-Augmented Generation system for searching and answering questions from technical documentation.

• Dense embedding-based document retrieval
• Query expansion into multiple search phrases
• Retrieval of candidate chunks from a vector database
• Similarity threshold tuning
• Candidate aggregation and deduplication
• Reranking of retrieved content
• Selection of the strongest evidence for the final response
• Evaluation using ranking and retrieval metrics
• Iterative retrieval when initial context was insufficient
• Incremental document update handling

Python · LLMs · Embeddings · Qdrant · Semantic Search · Reranking · RAG Evaluation

Worked on ingestion workflows for converting technical documentation into structured, searchable knowledge.

Areas explored include:

• HTML document parsing
• Topic and section identification
• Processing tables, figures, and code blocks
• Stable content identifiers
• Document-to-URL mapping
• Metadata preservation
• Change detection
• Incremental indexing
• Updating only changed documentation
• Maintaining traceability between retrieved content and source pages

Explored a reflective retrieval approach in which an AI system evaluates whether the retrieved evidence is sufficient before generating a final answer.

The workflow can:

1. Analyse the user’s question
2. Generate multiple search formulations
3. Retrieve relevant evidence
4. Evaluate whether the evidence is sufficient
5. Reformulate the search when necessary
6. Retrieve additional information
7. Produce a grounded response from the strongest available context

This approach is useful for reducing premature answers and improving coverage for complex questions.

Worked with systems where a language model can select and interact with external tools or data sources.

Areas explored include:

• Tool definition and selection
• Structured function arguments
• Multi-step execution
• Context management
• Tool result validation
• Error recovery
• Response synthesis
• Model Context Protocol concepts
• Agent observability
• Agent evaluation

Title: Anomaly Detection of Multivariate Time Series Data and Acceleration Using GPUs
Institution: Indian Institute of Technology Bhilai
Department: Computer Science and Engineering
Degree: M.Tech in Data Science and Artificial Intelligence
Completed: June 2023
Supervisor: Dr. Vishwesh Jatala

My thesis addressed anomaly detection in high-volume industrial sensor data collected from the Bar and Rod Mill at Bhilai Steel Plant. The objective was to detect abnormal operating behaviour—particularly cobble-related events—while reducing the computational cost of multivariate deep-learning analysis.

• Analysed approximately 1,860 PLC-generated industrial signals
• Studied univariate and multivariate time-series anomaly patterns
• Detected HMD flickering through Roll-ON/Roll-OFF period analysis
• Analysed looper-signal abnormalities using moving averages, lag-based comparisons, and percentage deviation
• Modelled overshoot and undershoot events using the MSCRED framework
• Used an unsupervised ConvLSTM encoder-decoder to capture temporal and inter-signal dependencies
• Generated reconstruction-based anomaly scores for multivariate signals

The multivariate model contained computationally expensive convolution operations across the encoder, ConvLSTM, and decoder. I investigated this bottleneck by transforming Conv2D into a GEMM-based operation using lowering/im2col, then accelerating the matrix multiplication with CUDA.

Key implementation areas included:

• CUDA programming for parallel matrix multiplication
• GEMM-based Conv2D acceleration
• GPU global-memory and shared-memory analysis
• GPU shared-memory optimisation to reduce high-latency global-memory access
• A custom PyTorch extension for GPU computation
• CPU-versus-GPU performance benchmarking
• Scalability analysis for larger time-series workloads

The experiments were conducted on an NVIDIA RTX A6000 GPU with 48 GB memory, alongside a 16-core Intel Xeon Gold 5218 CPU and 64 GB RAM.

For a benchmark with 36,000 data points, 30 features, batch size 128, and 32 threads:

The shared-memory GPU implementation achieved approximately:

• 12.68× faster encoder execution than the CPU implementation
• 1.82× faster total execution, equivalent to about a 45.1% reduction in total runtime
• Comparable predictive quality across implementations, with F1 remaining around 0.93–0.94

Time-Series Analysis · Anomaly Detection · Industrial AI · MSCRED · ConvLSTM · PyTorch · CUDA · GEMM · Conv2D · GPU Shared Memory · High-Performance Computing

The raw industrial dataset should not be published publicly unless the data owner has explicitly authorised its release. A public thesis repository can instead contain the abstract, architecture, synthetic examples, implementation notes, benchmark tables, and non-confidential code.

Participated in NVIDIA's structured-reasoning competition using the Nemotron-3-Nano-30B model family. The objective was to improve reasoning accuracy and submit a compatible LoRA adapter with rank no greater than 32, evaluated through deterministic vLLM inference and final-answer extraction from \boxed{} output.

The benchmark tested whether a language model could infer hidden rules from worked examples and apply the discovered rule to a new query. The tasks required more than general language generation: the model needed to identify the task family, infer the latent transformation, verify its hypothesis against the examples, perform the final computation, and return the exact answer in the required format.

The challenge allowed prompting, data curation, synthetic-data generation, reinforcement learning, and lightweight fine-tuning. My approach focused on reasoning-oriented synthetic data engineering and QLoRA-style supervised fine-tuning rather than full-parameter fine-tuning or reinforcement learning.

• Achieved a 0.676 public leaderboard score, ranking 2,695
• Achieved a 0.668 final private leaderboard score, ranking 3,020
• Completed two compute-intensive QLoRA training and submission cycles; Kaggle displays the first run with an error status despite recording 0.532 public / 0.536 private scores

1. Analysed the benchmark structure and separated problems into reusable reasoning families, including bit manipulation, physics and gravity, unit conversion, substitution ciphers, numeral systems, and custom arithmetic/operator transformations.
2. Designed deterministic reasoning procedures for each family instead of relying on unconstrained free-form chain-of-thought generation.
3. Created and curated synthetic reasoning traces containing task classification, the key diagnostic, the inferred rule, verification against examples, application to the query, and a strict boxed answer.
4. Compressed the reasoning traces to approximately 50–150 tokens where possible so that training capacity was spent on the successful reasoning path instead of verbose or repetitive text.
5. Applied 4-bit QLoRA-style parameter-efficient fine-tuning to the Nemotron base model using the Hugging Face ecosystem.
6. Resolved model-architecture and low-precision compatibility problems involving Mamba kernels, RMSNorm fallbacks, Mixture-of-Experts dtype mismatches, and 4-bit execution.
7. Evaluated multiple checkpoints and iterations, selected the strongest adapter checkpoint, validated the required files, and packaged the submission in Kaggle's expected format.
8. Used limited leaderboard feedback and error analysis to refine the data distribution, reasoning format, and final-answer reliability.

The training traces followed a compact structure:

<think>
Type: <reasoning category>
Key observation or diagnostic
Hypothesis and verification across examples
RULE FOUND: <concise transformation>
Applying to query: <calculation>
</think>
\boxed{<final answer>}

Important design decisions included:

• Teaching the model to classify before computing
• Selecting the simplest hypothesis that explains all examples
• Rejecting a hypothesis immediately when an example fails
• Verifying the selected rule on multiple examples
• Adding numerical sign, magnitude, precision, and formatting checks
• Keeping only the successful reasoning path in fine-tuning data
• Ensuring that \boxed{} contains only the final answer

Bit manipulation

• XOR, AND, OR, NOT, rotations, reversals, shifts, and nibble swaps
• Compositions such as rotation followed by XOR with a constant
• Neighbour and majority/choice Boolean functions
• Per-bit GF(2) analysis as a systematic fallback when simpler whole-byte rules failed

Physics and numerical reasoning

• Recovering hidden constants from examples
• Applying physical relationships such as quadratic distance-time behaviour
• Full-precision intermediate arithmetic with final-step rounding
• Interval-based estimation around rounded observations

Unit conversion and numeral systems

• Identification and application of conversion factors
• Binary, octal, hexadecimal, Roman-numeral, and custom representations
• Explicit output-format matching, including leading zeros and precision

Cipher and transformation problems

• Building substitution mappings from demonstrations
• Elimination over unused characters
• Testing candidate mappings against vocabulary and all examples
• Inferring custom arithmetic operators through difference tables, algebraic decomposition, and hypothesis competition

The two runs were deliberately different rather than simple repetitions. The second configuration changed the LoRA scaling, projection targets, optimizer, and effective batch size.

Across the two submission cycles, the public score improved from 0.532 to 0.676, while the private score improved from 0.536 to 0.668.

Full training runs on a 30B-class model were computationally expensive, so experimentation focused on reasoning-data preparation, controlled configuration changes, offline checkpoint evaluation, and model compatibility work rather than frequent leaderboard submissions.

Fine-tuning and packaging workflow

• Used PEFT LoRA adapters for parameter-efficient fine-tuning rather than full-model retraining
• Used the Hugging Face stack: Transformers, PEFT, bitsandbytes, TRL, Accelerate, and Safetensors
• Performed supervised fine-tuning on structured synthetic reasoning traces
• Preserved the competition requirement that the final adapter rank be no greater than 32
• Evaluated intermediate checkpoints offline and selected checkpoint-1056 for the final adapter
• Cast trainable adapter weights to float16 for compact packaging
• Verified adapter_config.json and adapter_model.safetensors, then packaged only the required files into submission.zip

Submission history

Public leaderboard — Score 0.676, Rank 2,695

Final private leaderboard — Score 0.668, Rank 3,020

Hybrid model and 4-bit compatibility

The Nemotron architecture required additional engineering for QLoRA-style execution. I prepared a reproducible RunPod setup and applied compatibility patches that:

• Replaced unavailable fused RMSNorm behaviour with a PyTorch fallback
• Disabled a fused Mamba execution path that was incompatible with 4-bit weights
• Corrected dtype mismatches in Mixture-of-Experts aggregation
• Corrected dummy-expert dtype handling
• Cleared cached model modules so that patched source was loaded consistently
• Validated all downloaded safetensors shards before training

Reasoning quality and answer extraction

• Reduced verbose reasoning that wasted sequence capacity
• Added explicit rule summaries and cross-validation
• Prevented explanations from leaking into the final boxed answer
• Matched the competition's deterministic decoding and exact-answer evaluation behaviour

Submission reliability

• Loaded the selected checkpoint explicitly rather than relying on the last training state
• Reduced adapter size using float16
• Validated mandatory adapter files before zipping
• Removed intermediate checkpoint directories from the final package

Python · PyTorch · Transformers · PEFT · QLoRA · LoRA · bitsandbytes · TRL · Accelerate · Adafactor · Safetensors · vLLM · Synthetic Data · Reasoning Evaluation · RunPod · NVIDIA H100

I experiment with running language models locally to understand their quality, speed, memory requirements, and suitability for practical applications.

Models and model families explored include:

• Mistral
• DeepSeek distilled models
• Qwen
• Vision-language models
• Quantized GGUF models

Tools used for experimentation include:

• LM Studio
• Ollama
• Hugging Face
• Jupyter Notebook

Areas of investigation include:

• Quantization levels
• Model size versus response quality
• Prompt behaviour
• Inference latency
• Memory utilisation
• Local privacy
• CPU and GPU constraints
• Vision-language understanding
• Application integration

Worked with a large evaluation dataset containing thousands of questions for comparing retrieval and response quality.

Areas evaluated include:

• Search relevance
• Retrieved context quality
• Ranking performance
• Answer completeness
• Citation accuracy
• Failure patterns
• Model consistency
• Performance across different question categories

Developed and experimented with an Electron-based desktop companion application designed to combine animation, interaction, and productivity.

The application concept includes:

• A desktop puppy that moves around the screen
• Cursor-following behaviour
• Natural movement and momentum
• Rest and play states
• Interactive animations
• Multiple companion characters
• Menu-bar controls
• Persistent preferences
• Low-resource operation
• Pomodoro-based focus sessions
• Task completion prompts
• Productivity reminders
• Desktop notifications

I have also explored how such an application could be extended with:

• Natural-language interaction
• Voice responses
• AI-generated behaviour
• User authentication
• Payment workflows
• Cloud persistence
• Subscription management
• Landing-page deployment

Electron · JavaScript · Desktop Applications · UI Interaction · Productivity Tools

I regularly build small prototypes and experiments involving:

• LLM-powered assistants
• Retrieval pipelines
• Local model interfaces
• Prompt evaluation tools
• Data processing utilities
• Desktop productivity software
• API integrations
• Interactive AI applications

Some experiments are research-oriented, while others focus on learning how complete software products are designed, deployed, monitored, and improved.

• CUDA-based GPU computation
• GPU global and shared memory
• GEMM and matrix-multiplication optimisation
• Lowering/im2col-based convolution
• Conv2D and ConvLSTM acceleration
• Custom PyTorch extensions
• CPU/GPU benchmarking
• Throughput, latency, memory, and scalability analysis

• Large Language Models
• Retrieval-Augmented Generation
• Natural Language Processing
• Dense vector retrieval
• Embedding models
• Vector databases
• Semantic search
• Query expansion
• Reranking
• Prompt engineering
• Model evaluation
• Fine-tuning
• LoRA
• Quantized inference
• AI agents
• Model Context Protocol
• Structured outputs
• Information retrieval
• Document processing
• REST API integration
• Software architecture
• Industrial time-series analysis
• Anomaly detection
• ConvLSTM and encoder-decoder models
• CUDA and GPU acceleration
• GEMM-based convolution
• GPU shared-memory optimisation
• High-performance computing

I consistently practise data structures and algorithms to improve problem-solving ability, coding precision, and interview readiness.

I have solved more than 240 problems across areas such as:

• Arrays and strings
• Hash maps
• Two pointers
• Sliding window
• Binary search
• Linked lists
• Stacks and queues
• Trees and binary search trees
• Recursion and backtracking
• Dynamic programming
• Graphs
• Intervals
• Matrix traversal
• Greedy algorithms

Representative problems include:

• Add Two Numbers
• Longest Substring Without Repeating Characters
• Longest Palindromic Substring
• Container With Most Water
• 3Sum
• 4Sum
• Search in Rotated Sorted Array
• Rotate Image
• Group Anagrams
• Maximum Subarray
• Spiral Matrix
• Merge Intervals
• Set Matrix Zeroes
• Word Search
• Validate Binary Search Tree
• Recover Binary Search Tree

• Advanced data structures and algorithms
• Distributed systems
• System design
• AI application architecture
• Advanced CUDA kernel optimisation
• GPU inference systems and model serving
• Model serving
• Scalable retrieval infrastructure
• AI observability
• Evaluation-driven development
• Backend engineering
• Cloud deployment
• Production-grade agent systems

Master of Technology in Data Science and Artificial Intelligence

2021 – 2023

Academic and research areas included:

• Machine learning
• Deep learning
• Artificial intelligence
• Data science
• Statistical modelling
• Optimisation
• Natural language processing
• Research methodology
• Computational problem-solving

My postgraduate experience strengthened my ability to approach engineering problems through a combination of theoretical understanding, experimentation, evaluation, and implementation.

M.Tech Thesis: Anomaly Detection of Multivariate Time Series Data and Acceleration Using GPUs

The thesis combined industrial time-series analytics, unsupervised deep learning, and GPU computing. It used statistical methods for univariate anomaly detection, MSCRED with ConvLSTM for multivariate signals, and CUDA-accelerated GEMM-based convolution with GPU shared-memory optimisation.

I prefer building systems that are:

• Measurable rather than based only on intuition
• Reliable rather than impressive only in demonstrations
• Grounded in evidence
• Modular and maintainable
• Observable and testable
• Designed around real user problems
• Evaluated using clearly defined metrics
• Improved through structured experimentation

I believe strong AI engineering requires more than connecting an application to a model API. It requires careful work across data quality, retrieval, prompts, evaluation, architecture, latency, cost, safety, and user experience.

Beyond implementation, I enjoy analysing complex decisions using data, assumptions, comparisons, and scenario-based reasoning.

Topics I frequently explore include:

• AI industry trends
• Emerging technologies
• Software products
• Model and hardware comparisons
• Personal computing
• Technology investments
• Real-estate market dynamics
• Infrastructure development
• Long-term economic and technology trends
• Product feasibility
• Risk and return trade-offs
• Consumer technology evaluation

I enjoy breaking large decisions into measurable factors, challenging assumptions, and comparing multiple scenarios before arriving at a conclusion.

Some projects I plan to develop or expand include:

A platform for comparing:

• Embedding models
• Chunking strategies
• Search configurations
• Reranking methods
• Prompt templates
• Language models
• Retrieval metrics
• Response quality

A privacy-focused assistant that:

• Runs with local language models
• Searches personal documents
• Supports citations
• Works offline
• Compares multiple models
• Tracks response latency and quality

An extended version of my desktop companion project with:

• Natural-language conversations
• Voice interaction
• Productivity coaching
• Local AI inference
• Custom behaviour
• Task tracking
• Cross-device preference synchronisation

A collection of architecture notes and practical implementations covering:

• RAG architecture
• Vector search
• Agent systems
• Model serving
• Evaluation pipelines
• Caching
• Observability
• Scaling
• Cost optimisation
• Failure recovery

Replace the following placeholders with your strongest repositories.

Research implementation and documentation based on my IIT Bhilai M.Tech thesis on anomaly detection in industrial multivariate time-series data and CUDA acceleration of GEMM-based convolution.

Technologies: Python, PyTorch, CUDA, MSCRED, ConvLSTM, GEMM, time-series analysis, anomaly detection

View Repository · Read Thesis

A reproducible project documenting synthetic reasoning-data generation, compact chain-of-thought formatting, 4-bit QLoRA-style adapter training, architecture compatibility fixes, checkpoint selection, and Kaggle submission packaging.

Result: Score improved from approximately 0.53 to 0.668; final private leaderboard rank approximately 3,020.

Technologies: Python, PyTorch, Transformers, PEFT, QLoRA, bitsandbytes, TRL, Accelerate, Safetensors, vLLM

View Repository · View Competition

An evaluation-oriented RAG project demonstrating document ingestion, vector search, reranking, context selection, and retrieval metrics.

Technologies: Python, Qdrant, embeddings, LLMs, information retrieval

View Repository

An interactive Electron desktop application combining animated companion behaviour with productivity and Pomodoro features.

Technologies: Electron, JavaScript, desktop UI, productivity systems

View Repository

A collection of notebooks and experiments comparing local language models, quantisation settings, latency, and response quality.

Technologies: Python, Ollama, LM Studio, Hugging Face, Jupyter

View Repository

A collection of academic and independent machine-learning experiments, notebooks, evaluations, and implementation notes.

Technologies: Python, machine learning, data analysis, Jupyter

View Repository

Language statistics are calculated from public repository content and do not represent my complete technical proficiency.

I am open to conversations about:

• Artificial intelligence

• Machine learning engineering

• Generative AI

• Retrieval-Augmented Generation

• AI agents

• Information retrieval

• System design

• Technical collaboration

• Research and experimentation

• AI engineering opportunities

• GPU computing and CUDA optimisation

• Industrial AI and time-series anomaly detection

• LinkedIn: Connect with me

• Email: YOUR_EMAIL_ADDRESS

• LeetCode: View my profile

• Kaggle: View my profile

• Portfolio: Visit my portfolio