## Context
This is my personal digital home and long-term publishing platform. I use it to document projects, ideas, reading notes, writing, and ongoing experiments while keeping full ownership of content and presentation.

The goal is to make the site feel less like a static resume and more like a living system that evolves with my work.

## Product Structure
The website is organized into focused sections so each type of content has its own clear surface.

- Home and About pages for identity and current direction
- Projects pages with individual deep-dive routes for each build
- Reading and Writing sections for books and long-form posts
- Studio pages for curated resources and personal artifacts
- Additional pages like Arsenal, Facts, Quotes, and Heuristics

This structure supports both fast skimming and deep exploration.

## Technical Architecture
The site is built with Next.js and TypeScript, using static generation patterns for fast load times and predictable deploys.

- Framework: Next.js
- Language: TypeScript
- UI system: Chakra UI
- Content rendering: MDX via `next-mdx-remote`
- SEO: route-level metadata with `next-seo`

Most pages are data-driven through JSON/MDX content sources, which keeps editorial updates separate from UI logic.

## Content System and Authoring Workflow
A core design principle is content-first development: write or edit data files, then let reusable page templates handle rendering.

- Portfolio data lives in structured JSON (project metadata, links, artwork)
- Long-form pages use MDX for readable writing + embedded media support
- Dynamic routes (for example, project and reading detail pages) are statically generated
- Shared components ensure a consistent visual language across sections

This approach makes it easy to expand the site without repeatedly changing page code.

## Design Direction
The interface favors clean typography, restrained color usage, and subtle editorial framing. Artwork banners and curated visuals are used intentionally to give each page a distinct mood without sacrificing readability.

Navigation is deliberately minimal so users can quickly move between identity, work, and thought.

## What This Project Demonstrates
This project demonstrates end-to-end ownership of product, engineering, and narrative: information architecture, frontend implementation, content strategy, and iterative refinement.

It is both a portfolio and an operating system for my work, designed to keep growing as new projects and writing are published.

Personal Website

## Context
Built as an intern onboarding task for the MD25010 grant project at New Uzbekistan University, this project implements a full SLAM and autonomous navigation pipeline in ROS2 using TurtleBot3 in Gazebo.

The objective was to produce a reproducible, end-to-end robotics workflow: containerized setup, map creation, autonomous mission execution, and measurable results.

## System Architecture
The stack combines ROS2, Nav2, SLAM Toolbox, Gazebo, and RViz inside Docker, with browser-based VNC for launching and observing the robotics desktop environment.

- ROS2 package build and runtime orchestration inside a consistent container
- Gazebo simulation for robot/world dynamics
- SLAM Toolbox for map generation in lifelong mapping mode
- Nav2 for localization, planning, and goal-following
- RViz for map and navigation state inspection

This architecture avoids local dependency drift and makes reruns predictable across machines.

## Execution Flow
The workflow is intentionally divided into three stages so each milestone is independently verifiable.

### Part A - Environment and Package Setup
- Build and launch containerized workspace with Docker Compose
- Build the ROS2 package via colcon
- Configure TurtleBot3 model and runtime environment

### Part B - Mapping (SLAM)
- Launch Gazebo + RViz + SLAM stack
- Teleoperate the robot to maximize map coverage
- Export occupancy grid map artifacts for reuse

### Part C - Autonomous Navigation
- Switch from mapping to full navigation stack
- Run scripted multi-goal execution (`send_nav_goals`) or manual goal placement
- Log mission outcomes into CSV for evaluation

## Results
Navigation evaluation reached 5 out of 5 goal completions with low terminal error, and every run produced auditable artifacts (saved maps, screenshots, and navigation logs).

- Goal completion: 5/5 SUCCESS
- Arrival error range: approximately 0.03m to 0.11m
- Runtime metrics: per-goal timing stored for comparison and tuning

## Engineering Decisions and Reliability Work
A key part of the project was making robotics-in-container execution reliable enough for repeated testing.

- Enabled software rendering (`LIBGL_ALWAYS_SOFTWARE=1`) to stabilize Gazebo without GPU passthrough
- Mounted map directories to preserve outputs between container sessions
- Blocked problematic external model host lookup to prevent startup hangs

These choices improved startup stability and made the environment practical for iterative experimentation.

## Deliverable Value
This repository is a reference implementation for ROS2 simulation workflows that need repeatability, observability, and measurable navigation outcomes.

It provides a clean base for future extensions such as Nav2 parameter tuning, map quality analysis, expanded waypoint missions, and benchmarking alternative planning strategies.

A full ROS2 mapping and navigation pipeline for TurtleBot3 in Gazebo, from SLAM map generation to autonomous multi-goal execution.

ROS2 SLAM & Autonomous Navigation

## Context
Apollo AI is an AI500 Hackathon 2025 Stage 2 submission focused on democratizing precision agriculture by making crop diagnostics accessible from standard phone and drone images.

The project is built as a deployed prototype, combining an interactive product experience with a production-style inference backend.

## Problem and Objective
Farmers and field operators often lack quick, low-cost diagnostic tools that can be used directly in real-world conditions.

Apollo AI addresses this by providing:
- Fast image-based crop stress classification
- A low-friction user experience that works on mobile devices
- Multiple access paths (web interface and Telegram bot)

## System Architecture
The platform is split into a modern frontend and a Python inference backend.

- Frontend: Next.js 15 (App Router), React 19, Tailwind CSS
- Backend: FastAPI deployed as serverless functions on Vercel
- Inference runtime: ONNX Runtime for efficient model execution
- Visualization: Three.js-based interactive 3D Drone Scanner

This architecture supports responsive UX, clear API boundaries, and deployment-ready scalability for prototype usage.

## AI Model
The classification engine is based on a ResNet-18 model trained on PlantVillage data.

- Dataset scale: 70k+ images
- Target: crop stress and disease class detection
- Reported demo-class performance: up to 99% accuracy

The model pipeline is integrated into a user-facing flow so inference is not isolated from product behavior.

## Product Experience
The frontend emphasizes usability for non-technical users and field-friendly workflows.

- Mobile-first responsive layouts
- Glass-morphism visual language for clear, modern UI
- Dedicated demo route (`/demo`) for testing classification flow
- Visual storytelling via 3D scanner interaction

## Telegram Bot Integration
A Telegram assistant extends access for users who prefer messaging-first interactions.

- Provides instant analysis support and app access flow
- Uses a polling architecture
- Runs locally or on a VPS even when web deployment is on Vercel

This makes the platform more reachable across different user behavior patterns.

## What This Project Demonstrates
Apollo AI demonstrates end-to-end product engineering across ML inference, backend API design, interactive frontend experience, and multi-channel delivery.

It also shows practical deployment thinking: model serving on serverless infrastructure, modern React architecture, and user-facing tooling designed for fast iteration in a hackathon-to-product trajectory.

An AI-powered crop stress detection platform that classifies plant conditions from smartphone or drone imagery with a web-first, mobile-friendly workflow.

Apollo AI

## Context
This is the first project in my Vibecoding Ascent challenge and was designed as a full sentiment analysis pipeline for movie reviews, from preprocessing to model training to browser-based inference.

Instead of relying only on framework abstractions, I built the core model logic myself to understand the mechanics of text classification at a first-principles level.

## Problem and Objective
The goal was to classify IMDB reviews as positive or negative while comparing a custom implementation against a standard library baseline.

I wanted to answer two questions:
- Can a NumPy-only logistic regression implementation reach competitive performance?
- Which parts of the text pipeline matter most for practical sentiment quality?

## Modeling Approach
The primary model is logistic regression implemented from scratch in NumPy and optimized with gradient descent.

- Loss function: binary cross-entropy
- Training iterations: 1,000
- Learning rate: 0.1
- Output: binary sentiment prediction

Building the optimizer manually made it easier to inspect training behavior and understand how parameter updates respond to sparse features.

## Feature Engineering Pipeline
Review text is transformed into TF-IDF vectors with both unigrams and bigrams, capped at 5,000 features.

- Unigrams capture broad sentiment-bearing words
- Bigrams capture short phrase context that can flip polarity
- Preprocessing/cleaning modules keep train-time and inference-time transformations consistent

This setup balances representation quality with computational efficiency.

## Benchmarking and Performance
To validate the custom implementation, I trained a parallel scikit-learn baseline on the same data setup and compared outcomes directly.

- Dataset: IMDB movie reviews (50,000 total)
- Custom NumPy logistic regression: approximately 85-88% validation accuracy
- scikit-learn comparison model: similar accuracy range

The comparison showed that the custom model remains competitive while being fully transparent and inspectable.

## Productization and Tooling
The project is wrapped in a Flask web app so users can input any review and receive an immediate sentiment prediction.

Supporting scripts handle the full workflow:
- Model training
- Feature extraction and visualization generation
- Prediction testing

This made experimentation repeatable and reduced friction between model iteration and UI-facing inference.

## What This Project Demonstrates
This project demonstrates practical ML engineering across data preprocessing, feature design, optimization, benchmarking, and deployment integration.

More importantly, it built strong intuition for linear models and NLP feature spaces, which provides a grounded foundation for later work with larger frameworks and deep learning systems.

TF-IDF Feature Engineering for Text Classification

Logistic Regression via Gradient Descent

A Flask web app that classifies IMDB movie reviews with a NumPy logistic regression model and compares results against scikit-learn.