Welcome to the Udacity Projects Master Repo! If you are an MSc in Artificial Intelligence candidate at the Udacity Institute of AI & Technology, this repo can help you to succeed in your coursework.
This repo contains my solutions for various Nanodegree Programs (Robotics, Artificial Intelligence, Machine Learning, Deep Reinforcement Learning, Computer Vision, Sensor Fusion, Flying Cars, etc.). Additionally, several of the elective courses are covered.
The projects were originally sorted by the relative Udacity School, with the more recent completions at the top (my software development skills improved over time 🚀). However, some of the newer programs that succeeded previous content are intertwined (i.e., the Machine Learning with Pytorch replaced the original Machine Learning Nanodegree material).
All projects can be used for inspiration, but please follow the Udacity Honor Code and reference any "borrowed" material. Caveat emptor: use at your own risk (dura lex sed lex).
Jump to:
- School of Artificial Intelligence
- School of Autonomous Systems
- School of Data Science
- School of Business
- School of Programming and Software Development
Reinforcement learning, deep learning, computer vision, NLP, multi-agent systems, agents and orchestration, RAG, bioinformatics tooling, statistics and experiment design, SQL and data modeling, ETL and warehousing, ROS and robotics, sensor fusion and estimation, VR with Unity, product and project management, digital marketing analytics.
P1. EcoHome Energy Advisor
High-level goal: provide RAG + tool-using guidance for smart-home energy optimization using an agentic workflow.
Technologies used: LangChain, LangGraph, Python, notebooks for DB/RAG setup and evaluation, tool-backed agent.
P2. DocDacity - Document Assistant
High-level goal: route user intents to QA, summarization, or calculator agents for document question answering and reporting.
Technologies used: LangChain, intent classification and routing, calculator tool, document search/read/stats, session memory and logging.
P3. UDA-Hub - Multi-Agent Support System
High-level goal: triage support tickets with a LangGraph multi-agent system that uses tools, sentiment, and knowledge base lookups.
Technologies used: LangGraph multi-agent graph, FastMCP tools over SQLite, sentiment-aware routing, KB with ~14 articles, REPL demo and tests.
P1. Multi-Agent Orchestrator Logistics System
High-level goal: coordinate up to five agents to automate inventory, quoting, and fulfillment flows for a paper company.
Technologies used: Python, Pydantic AI multi-agent graph, SQLite or SQLAlchemy-backed tools, structured outputs, OpenAI proxy integration.
Scope: uses a compact graph of cooperating agents with shared tools and structured I/O, suited for quote-to-cash style flows.
P2. AI-Powered Genetic Workflow for Product Management
High-level goal: run persona-aware analysis, routing, and staged evaluation to generate and score product requirements.
Technologies used: Python, OpenAI-compatible APIs, RAG over CSV knowledge stores, modular agent harness.
Scope: orchestrates multi-step evaluation and reporting for PM artifacts with traceable intermediate products.
P3. AI Research Agent - Video Game Industry
High-level goal: answer executive queries on market structure using RAG over structured game data and vector embeddings.
Technologies used: Python, ChromaDB with SQLite, retrieval and summarization agents, notebook-driven workflows.
Scope: retrieval pipeline with lightweight vector store for exploratory industry analysis.
P4. Multi-Agent Travel Assistant System
High-level goal: prototype a travel concierge that plans itineraries, evaluates booking options, and coordinates customer messaging across specialized agents.
Technologies used: Python, framework-agnostic multi-agent orchestration patterns, OpenAI-compatible models.
Scope: modular assistants for planning, evaluation, and communications across a shared state.
P1. Orphan Finder: Rare Disease Variant-to-Therapy Matchmaker
High-level goal: rank candidate variants with ClinVar, synthesize PMID-backed evidence from PubMed, and match to ClinicalTrials.gov trials to produce a clinician-style, auditable brief.
Technologies used: Python 3.10, three-agent orchestration (Orchestrator, VariantPrioritizer, EvidenceSynthesizer, TrialMatcher), ClinVar queries, PubMed E-utilities, ClinicalTrials.gov API, JSONL run logging.
Scope: integrates three public biomedical sources with an auditable JSONL trace of tool calls and selections, producing a report.md and ranked_variants.csv per run for reproducibility.
P1. UdaciScan - An AI Research Agent for Drug-Repurposing Insights
High-level goal: answer drug repurposing questions by retrieving PubMed abstracts, gating on retrieval confidence, extracting and ranking candidate drugs, and emitting reproducible briefs with traces.
Technologies used: Python 3.10+, ChromaDB vector store, OpenAI-compatible endpoint via Vocareum, PubMed and NCBI integrations, YAML configuration, CLI runner with JSON/Markdown outputs.
Scope: end-to-end CLI and notebook workflows with vector search, ranked outputs, and artifact logging.
P1. AI Photo Editing & Inpainting
High-level goal: build an interactive app for targeted inpainting and style edits on user-uploaded photos.
Technologies used: Python, Streamlit, diffusers or Stable Diffusion inpainting, Pillow, OpenCV.
P2. Custom Architecture Framework Chatbot
High-level goal: create an LLM assistant that answers questions about a proprietary architecture governance framework using RAG.
Technologies used: LangChain, OpenAI via Vocareum, ChromaDB or FAISS, pandas, Python notebooks and CLI.
Scope: RAG pipeline with configurable ingestion and vector store, designed for governance corpus Q&A and reproducible CLI runs.
P3. Lightweight Fine-Tuning of a Foundational Model
High-level goal: fine-tune DistilBERT for sentiment classification with parameter-efficient techniques.
Technologies used: Hugging Face Transformers, PEFT/LoRA, PyTorch, datasets, scikit-learn metrics.
P4. HomeMatch - Personalized Real Estate Agent
High-level goal: generate synthetic listings, store text and image embeddings, collect buyer preferences, and return GPT-personalized property narratives.
Technologies used: LangChain, LangChain-OpenAI, ChromaDB, CLIP and Sentence Transformers, Pillow, pandas.
P1. Navigation
High-level goal: train an agent to collect target items and avoid distractors in a Unity environment to maximize cumulative reward.
Technologies used: PyTorch, DQN/Double DQN with experience replay and target networks, Unity ML-Agents environment.
P2. Continuous Control
High-level goal: learn a continuous control policy to keep a robotic arm’s end-effector at target positions in the Reacher environment.
Technologies used: PyTorch, actor-critic (DDPG/TD3), Ornstein-Uhlenbeck noise, Unity ML-Agents environment.
P3. Collaboration and Competition
High-level goal: train two cooperative agents to sustain rallies in a shared tennis-like environment under multi-agent dynamics.
Technologies used: PyTorch, multi-agent DDPG or MADDPG variants, parameter noise/exploration strategies, Unity multi-agent environment.
P1. GAN Face Generator
High-level goal: synthesize realistic human faces from random latent vectors by training a GAN on CelebA.
Technologies used: PyTorch, torchvision, DCGAN/WGAN-GP training loop with gradient penalty, NumPy, Matplotlib, Jupyter.
P2. Landmark Classification & Social Media Tagging
High-level goal: identify which of 50 global landmarks appears in a user photo to enable automatic social-media tagging.
Technologies used: PyTorch CNNs, transfer learning with pretrained backbones, PIL, numpy/pandas, Matplotlib/Seaborn, helper training utilities.
P3. MNIST Handwritten Digit Classifier
High-level goal: reach greater than 98 percent accuracy on MNIST with a compact MLP and documented training pipeline.
Technologies used: PyTorch, torchvision datasets, BatchNorm and dropout, AdamW with LR scheduling, Jupyter.
P4. Text Translation & Sentiment Analysis with Transformers
High-level goal: translate multilingual movie reviews to English and attach sentiment labels to produce a unified analytics-ready CSV.
Technologies used: Hugging Face Transformers, MarianMT translation, DistilBERT sentiment pipeline, pandas, PyTorch, sacremoses.
P1. Facial Keypoint Detection
High-level goal: localize facial landmarks to support downstream tasks such as tracking, pose estimation, or expression analysis.
Technologies used: PyTorch CNNs, data augmentation, MSE loss, OpenCV-based visualization.
P2. Image Captioning
High-level goal: generate natural language descriptions from images using an encoder-decoder architecture.
Technologies used: CNN encoder (e.g., ResNet) with RNN/LSTM decoder, PyTorch, beam search or greedy decoding.
P3. Landmark Detection & Robot Tracking
High-level goal: detect landmarks and estimate robot pose in a mapping task using probabilistic state estimation.
Technologies used: EKF-SLAM or particle filtering, NumPy, OpenCV, Python visualization.
P1. HMM Part-of-Speech Tagger
High-level goal: train a hidden Markov model POS tagger over the universal tagset and decode sequences on held-out text.
Technologies used: Python, Pomegranate, NumPy, Jupyter (GraphViz optional for graph rendering).
P2. Machine Translation
High-level goal: translate sentences from English to French with a sequence-to-sequence neural model.
Technologies used: PyTorch, RNN/LSTM/GRU encoder-decoder with attention, tokenization, batching.
P3. DNN Speech Recognizer
High-level goal: build an end-to-end speech recognizer that maps raw audio to text using deep neural networks with CTC decoding.
Technologies used: Python, TensorFlow/Keras, NumPy, SoundFile, Jupyter.
P1. Backtest a Dynamic Investment Strategy
High-level goal: implement and evaluate a rule-based strategy with historical data to compute risk/return characteristics.
Technologies used: Jupyter Notebook, pandas, NumPy, rolling metrics, basic backtesting utilities and plotting.
P2. Data Transformation for Trading Models
High-level goal: prepare market time series for modeling by cleaning, aligning, and deriving predictive features.
Technologies used: pandas, feature engineering, normalization, windowed aggregations, technical indicators.
P1. Finding Donors
High-level goal: predict potential charitable donors from census-like attributes to optimize outreach.
Technologies used: scikit-learn (SVM, RandomForest, GradientBoosting), pandas, feature scaling, cross-validation.
P2. Create Your Own Image Classifier
High-level goal: implement transfer learning for image recognition with configurable hyperparameters and saved checkpoints.
Technologies used: PyTorch, torchvision models, command-line training and inference utilities.
P3. Identifying Customer Segments
High-level goal: discover latent customer groups to support targeted marketing and product decisions.
Technologies used: PCA for dimensionality reduction, KMeans clustering, scikit-learn, pandas.
P1. Predicting Boston Housing Prices
High-level goal: model median home value as a function of neighborhood features and evaluate generalization.
Technologies used: scikit-learn regressors, grid search, learning curves, cross-validation.
P2. Finding Donors
High-level goal: rank prospective donors to improve campaign efficiency and ROI.
Technologies used: scikit-learn classifiers, feature engineering, model selection and evaluation metrics.
P3. Titanic Survival Exploration
High-level goal: predict passenger survival to illustrate supervised learning pipelines and error analysis.
Technologies used: decision trees, ensemble baselines, scikit-learn, pandas.
P4. Smart Cab
High-level goal: learn a driving policy that obeys rules and reaches destinations in a simulated city.
Technologies used: Q-learning, epsilon-greedy exploration, Python simulation.
P5. Customer Segments
High-level goal: segment customers to enable differentiated strategies for retention and growth.
Technologies used: PCA, clustering (KMeans), scikit-learn, pandas.
P6. Dog Breed Classifier
High-level goal: detect whether an image contains a dog or human and classify the dog breed.
Technologies used: CNN transfer learning (e.g., VGG, ResNet), PyTorch, data augmentation.
P7. Plagiarism Detection
High-level goal: identify potential plagiarism by measuring document similarity against known sources.
Technologies used: engineered text similarity features, SVM or Logistic Regression, scikit-learn.
P8. Capstone: Deep Traffic (MIT)
High-level goal: learn a high-throughput driving policy in a browser-based multi-lane traffic simulator.
Technologies used: deep reinforcement learning policy networks in JavaScript, simulator-provided APIs, hyperparameter search.
P1. GitHub Copilot Starter
High-level goal: refactor a simple Sudoku game to a modern React and Next.js web app, adding generator, timer, hints, difficulty selection, validation, and persistence of top scores.
Technologies used: JavaScript, React, Next.js, HTML, CSS, optional Tailwind or modular CSS, localStorage for leaderboard.
P1. Image Classification for a City Dog Show
High-level goal: classify images of dogs and humans and identify dog breeds using a pre-trained convolutional neural network.
Technologies used: Python, PyTorch, torchvision, NumPy, PIL, transfer learning.
P2. Create Your Own Image Classifier
High-level goal: build and train a flower classifier and expose a command-line interface for training and inference.
Technologies used: PyTorch, torchvision, argparse, PIL, checkpointing for transfer learning.
P1. LiDAR Obstacle Detection
High-level goal: separate ground from obstacles and cluster objects in 3D point clouds.
Technologies used: C++, PCL, RANSAC plane fitting, KD-Tree Euclidean clustering.
P2. 2D Object Tracking
High-level goal: detect and track keypoints across frames to measure motion and build correspondences.
Technologies used: C++, OpenCV (detectors/descriptors), descriptor matching.
P3. 3D Object Tracking
High-level goal: associate camera detections with lidar points and track objects over time.
Technologies used: C++, OpenCV, PCL, bounding box association, time-to-collision estimation.
P4. Radar Target Generation and Detection
High-level goal: simulate FMCW radar signals and implement CFAR to detect targets.
Technologies used: MATLAB/Octave signal processing, CFAR, range-Doppler maps.
P5. Unscented Kalman Filter
High-level goal: estimate object state under nonlinear dynamics using UKF on lidar and radar measurements.
Technologies used: C++, Eigen, CTRV process model, sigma-point filtering.
P1. Backyard Flyer
High-level goal: plan and execute a simple waypoint mission to validate control and state estimation.
Technologies used: Python, drone simulator APIs, waypoint planning.
P2. 3D Motion Planner
High-level goal: compute collision-free global paths in a mapped environment.
Technologies used: Python, occupancy grids, A* search, heuristic tuning.
P3. Building a Controller
High-level goal: design attitude and position controllers for a quadrotor to track trajectories.
Technologies used: C++ or Python control loops, PID/linear controllers, simulator integration.
P4. Building an Estimator
High-level goal: estimate vehicle state from noisy IMU and GPS using probabilistic filtering.
Technologies used: C++ Extended Kalman Filter, sensor fusion, tuning and validation.
P1. Autonomous Search Rover
High-level goal: perceive obstacles and navigable terrain to autonomously explore and retrieve samples.
Technologies used: Python, OpenCV perception pipeline, decision logic, telemetry logging.
P2. Kinematics (Kuka-KR210)
High-level goal: compute forward and inverse kinematics for a 6-DOF manipulator and validate poses.
Technologies used: Python, ROS, DH parameterization, SymPy for IK.
P3. 3D Perception (PR2)
High-level goal: segment scenes and recognize tabletop objects for pick-and-place tasks.
Technologies used: ROS, PCL (voxel grid, RANSAC), clustering, SVM or template matching.
P4. Follow Me
High-level goal: detect and follow a target person in video streams.
Technologies used: semantic segmentation or object detection CNNs, ROS nodes for perception and control.
P5. Robotic Inference
High-level goal: apply deep learning inference for robotic perception or manipulation tasks.
Technologies used: TensorFlow or PyTorch models, ROS integration, inference optimization.
P6. Where am I?
High-level goal: localize a robot within a known map using probabilistic techniques.
Technologies used: ROS AMCL or particle filter localization, sensor models, map server.
P7. Map My World
High-level goal: build a map while estimating pose from onboard sensors.
Technologies used: ROS with RTAB-Map or SLAM backends, bagging and visualization tools.
P8. Deep Reinforcement Learning Arm (Kuka KR-210)
High-level goal: learn a control policy for a manipulator to reach or grasp under uncertainty.
Technologies used: PyTorch RL algorithms, robotics simulator interfaces, reward shaping.
P9. Home Service Robot
High-level goal: perform autonomous pick-and-deliver tasks in a house map.
Technologies used: ROS Navigation stack (mapping, localization, planning), Gazebo, custom state machine.
P1. Communication Embedded Systems
High-level goal: simulate three embedded nodes exchanging data across LIN, CAN, I2C, and SPI with separate modules.
Technologies used: C++ and CMake builds, ISR loops and port separation, Linux builds for sensor monitor, battery module, and data logger.
P2. Embedded Input Reader (Raspberry Pi Pico W)
High-level goal: implement a muxed switch reader with button passcode logic and LED control, runnable in Wokwi.
Technologies used: MicroPython, Wokwi simulator (diagram.json, wokwi.toml), debounce logic, GPIO handling and LED toggling.
P1. Design an HR Database
High-level goal: elicit business requirements and design a normalized relational schema for HR operations.
Technologies used: ER modeling, PostgreSQL 9.5 DDL, access control and backup considerations.
P2. Design a Data Warehouse
High-level goal: model analytical workloads with star schemas and implement an end-to-end ETL pipeline.
Technologies used: dimensional modeling, PostgreSQL, SQL-based ETL, performance tuning.
P3. Medical Data Processing Enterprise Data Lake
High-level goal: design an open-source enterprise data lake to replace a single-node SQL Server system processing ~77K daily files across ~8K medical facilities, with layered ingestion, processing, and serving.
Technologies used: Apache NiFi, Kafka, HDFS/HBase, Spark, Flink, Hive, Presto, Druid, Superset, Ranger/Knox/Kerberos, Mermaid diagrams and design docs. :contentReference[oaicite:1]{index=1}
P4. SneakerPark Data Governance
High-level goal: establish Phase 1 enterprise data management, including a critical data catalog, data quality profiling, and an MDM design spanning multiple microservices.
Technologies used: PostgreSQL, SQL, Mermaid for ERDs and architecture, HTML/CSS dashboard mockups, Excel/CSV templates. :contentReference[oaicite:0]{index=0}
P1. Investigate a Dataset
High-level goal: explore and analyze a firearm and census dataset, articulate key questions, and document visual findings.
Technologies used: Jupyter Notebook, pandas, NumPy, Matplotlib, exploratory data analysis workflow.
P2. Cybersecurity Data Wrangling
High-level goal: gather, assess, clean, and analyze Kaggle Cyber Security Attacks and MITRE ATT&CK datasets, including an optional graph export.
Technologies used: pandas, NumPy, programmatic data collection, data quality and tidiness fixes, NetworkX for graph representation, GraphQL.
P3. Communicate Nuclear IAEA Data Findings
High-level goal: produce exploratory and explanatory visualizations on nuclear infrastructure and electricity statistics using merged country-level data.
Technologies used: Jupyter Notebook, pandas, Matplotlib, HTML exports for presentation-ready deliverables.
P1. Salary Prediction via Linear Regression
High-level goal: build, fit, and interpret a salary prediction model using linear regression with clear diagnostics and interpretation.
Technologies used: Python, pandas, NumPy, statsmodels or scikit-learn linear models, Matplotlib, Jupyter.
P2. A/B Test Results Analysis
High-level goal: evaluate an online experiment for conversion differences using hypothesis tests and effect size.
Technologies used: pandas, SciPy statistical tests, confidence intervals, Matplotlib, Jupyter.
P3. Basketball Scoring Probabilities
High-level goal: model and compute scoring probabilities for game scenarios with worked, notebook-based examples.
Technologies used: probability rules, combinatorics, NumPy, pandas, Jupyter.
P4. Health and Sleep Quality Description
High-level goal: explore and describe health and sleep quality data to surface descriptive insights and visual patterns.
Technologies used: pandas, descriptive statistics, Matplotlib or Seaborn visualization, Jupyter.
P1. Deforestation Exploration
High-level goal: explore deforestation datasets with relational queries to surface trends and comparisons.
Technologies used: SQL querying, joins and aggregations, result interpretation and basic visualization exports.
P2. Social News Aggregator (Udiddit) - Schema Redesign and Migration
High-level goal: normalize a flawed forum database, migrate existing data, and validate integrity at scale.
Technologies used: PostgreSQL DDL/DML/DQL, indexes and constraints, Dockerized Postgres 15 workflow, validation queries and expected counts.
P1. Flight Delays and Cancellations
High-level goal: analyze air travel performance and factors driving delays and cancellations.
Technologies used: SQL queries, relational joins and aggregations, data visualization.
P1. Agentic Expense Reporting System
High-level goal: automate receipt parsing, policy checks, and payment decisions through a multi-agent workflow.
Technologies used: OCR and data extraction, spreadsheet APIs, rule evaluation, payment service integration.
P1. Delivering an ML/AI Strategy
High-level goal: define a practical ML/AI strategy aligned with product and organizational constraints.
Technologies used: strategic planning artifacts, data maturity assessment, roadmap and KPI definition.
P1. Create a Medical Image Data Annotation Job
High-level goal: specify a labeling task with clear guidelines to ensure high-quality medical image annotations.
Technologies used: labeling tool configuration, JSON schemas, quality control workflows.
P2. Build a Model with Google AutoML
High-level goal: train and evaluate a classification model using a managed AutoML service.
Technologies used: Google Cloud AutoML, dataset curation, evaluation metrics and model export.
P3. Capstone: AI for Space
High-level goal: propose an AI product concept for space applications with problem framing and feasibility.
Technologies used: product requirement definition, risk and stakeholder analysis, experimental roadmap.
P2. Design Sprint
High-level goal: validate a product idea through a structured multi-day sprint workflow.
Technologies used: sprint artifacts, user journey mapping, prototyping and feedback capture.
P1. Crafting an Analytics Brief
High-level goal: build a strategic analytics brief for Boston Dynamics Spot Enterprise with a 14-slide HTML deck and funnel visualization.
Technologies used: Python, Matplotlib, HTML presentation export.
P2. Sales Objective Analysis
High-level goal: compare Black Friday 2017 vs 2018 across objectives, audience, marketing, sales, and products, producing a structured analysis report and charts.
Technologies used: pandas, openpyxl, matplotlib, seaborn, numpy.
P3. Visual Storytelling with Data
High-level goal: explain seasonal gift-shopping behavior using minimalist visuals and an HTML narrative for UK ecommerce.
Technologies used: pandas, matplotlib, numpy, HTML story output.
P2. Facebook Campaign
High-level goal: plan, launch, and analyze a paid social campaign against business objectives.
Technologies used: Facebook Ads Manager, audience targeting, KPI tracking and reporting.
P5. Udacity Enterprise Portfolio
High-level goal: present a cohesive digital marketing portfolio for enterprise stakeholders.
Technologies used: portfolio structuring, analytics summaries, content curation.
P1. Carnival
High-level goal: build interactive VR mini-games to demonstrate physics and interaction design.
Technologies used: Unity, C#, VR interaction frameworks.
P2. Design an Apartment
High-level goal: create a navigable VR interior scene with lighting and materials suitable for presence.
Technologies used: Unity, C#, scene layout and optimization.
P3. Maze
High-level goal: implement a VR maze experience with locomotion and collision handling.
Technologies used: Unity, C#, VR controller input and physics.