Simplilearn AI Capstone Project Architect

// When should you use the AI Capstone Project Architect?

Use this skill when you need to design or implement an end-to-end AI project and must choose between object detection, image classification with recommendations, or time-series sales forecasting as your primary track.

// What do you need before starting a capstone track?

• Project Track Choicerequired
  Which of the three capstone tracks applies: (1) Autonomous Driving / Object Detection, (2) Tourism / Image Classification + Recommendation, or (3) Sales Forecasting / Regression
• Dataset Descriptionrequired
  What data is available — images with label files, CSV files, folder-organized image sets, or transaction records
• Target Predictionrequired
  What the model must output — vehicle type + bounding box, structure category, recommended location, or sales quantity
• Evaluation Constraint
  Any performance metric requirement (e.g., RMSE for regression, accuracy for classification) or time horizon for forecasting
• Compute Environment
  Local machine, Google Colab, Azure — determines GPU availability and library setup

// What core principles guide each capstone track?

// How do you execute a capstone project step by step?

1. 1

   Select your capstone track

   Choose exactly one of three tracks: Track 1 = Autonomous Driving (YOLO object detection + accident data analysis), Track 2 = Tourism (transfer learning image classification + item-based collaborative filtering), Track 3 = Sales Forecasting (multi-DataFrame merge + three-model regression). You only complete one track, but must complete both parts of that track.

2. 2

   Audit and prepare your datasets

   Track 1: Confirm you have an images/ folder, a labels/ folder with YOLO-format .txt files (class + box coordinates per line), and an accident CSV. Track 2: Confirm folder-organized images (one subfolder per structure class), user CSV, tourism_with_id CSV, and tourism_rating CSV. Track 3: Confirm restaurants CSV, items CSV, and sales CSV. For all tracks: run .info(), .head(), and check for nulls and duplicates before any modelling.

3. 3

   Handle missing values and data types

   Track 1 accident CSV: fill numeric null columns with 0; drop irrelevant ID columns (case number, etc.). Track 2 rating CSV: drop null rows or duplicates; check for outlier ratings using z-score, drop rows with ratings significantly far from the mean. Track 3: check for outliers in sales CSV using z-score or Isolation Forest; convert date column to datetime using pd.to_datetime() immediately.

4. 4

   Execute Part 1 of your chosen track

   TRACK 1 — Object Detection with YOLO: Clone the YOLO repository. Verify data.yaml points to your images/ and labels/ directories. Update the 'names' field in data.yaml to match your vehicle class labels. Run train.py with GPU enabled. After training, run detect.py on test images and use a visualization helper to display bounding boxes + class labels. Reference: Deep Learning Lesson 10 notebook (object detection with YOLO). TRACK 2 — Transfer Learning Image Classification: Use image_dataset_from_directory() to load folder-organized images with an 80/20 train/validation split. Load VGG16 with include_top=False. Flatten → Dense(relu) → Dropout (optional) → Dense(num_classes, softmax). Compile with Adam optimizer, categorical crossentropy, accuracy metric. Train once without augmentation, then train again with a Sequential augmentation block (RandomFlip, RandomRotation, RandomZoom) prepended. Compare validation accuracy between the two runs. Reference: Deep Learning Lesson 9 notebook (transfer learning, 9.04) and Lesson 8.08 (image loading from directories). TRACK 3 — Data Merging and Exploration: Merge restaurants CSV + items CSV on store_id → capture result. Merge result + sales CSV on item_id → final unified DataFrame. Create sales column = unit_price × item_count. Group by date, sum sales → daily_sales DataFrame. Use .resample('W'), .resample('M'), .resample('Q') to produce weekly, monthly, quarterly views. Plot each. Group by restaurant_id and sum sales to rank restaurants. Group by item_id + store_id to find most popular item per store.

5. 5

   Execute Part 2 of your chosen track

   TRACK 1 — Accident Data Analysis: Filter to rows with at least one death for mortality analysis. Use value_counts() on columns: driver_death, occupants, cyclist_collision, other_vehicle. Build histograms for distributions. Group by country, state, year with .groupby().count() to get event frequencies. Filter autopilot == 1 rows to count autopilot-involved incidents. Visualize with seaborn bar plots. TRACK 2 — Item-Based Collaborative Filtering: Use the tourism_rating CSV (user_id, place_id, rating) as your primary data. Merge with tourism_with_id on place_id to add place names and city metadata. Build an item-based collaborative filtering model (not user-based — input is a place, output is recommended places). Reference: Machine Learning Lesson 7 (recommendation systems). TRACK 3 — Regression Forecasting: Extract time features from the datetime column: day_of_week, month, quarter, year, day_of_month using .dt accessor. Sort by date. Use all data except last 6 months as training; last 6 months as test. Train Linear Regression, Random Forest Regressor, XGBoost Regressor — all predicting the daily sales column. Evaluate each with RMSE. Select lowest-RMSE model. Use champion model to forecast next year's sales.

6. 6

   Visualize and interpret results

   All tracks require visualization beyond raw numbers. For object detection: display bounding box images with class labels. For image classification: plot sample images in a 3×3 grid with class name as title (use class_names attribute from dataset); plot training vs. validation accuracy curves for both augmentation runs. For recommendation: show top-N recommended locations given a sample input location. For forecasting: plot actual vs. predicted sales over the test period; plot the next-year forecast as a time series.

7. 7

   Validate and document model performance

   Report the metric appropriate to your task: accuracy (classification), RMSE (regression). For Track 3, explicitly compare all three models in a summary table before declaring the champion. For Track 2 Part 1, explicitly compare the with-augmentation and without-augmentation runs and state which generalized better and why.

// What do real capstone track applications look like?

// What mistakes should you avoid in an AI capstone project?

• Building a CNN from scratch instead of using transfer learning (VGG16, ResNet) — pre-trained architectures will outperform custom scratch builds for standard image classification tasks.
• Forgetting include_top=False when loading a pretrained Keras model — without this, the original classification head remains and your custom output layers cannot be attached correctly.
• Not matching the number of neurons in the final Dense layer to the exact number of output classes — this causes shape mismatches during training.
• Shuffling or randomly splitting time-series data — always sort by date and use a chronological split (last 6 months = test) to preserve temporal order.
• Skipping the sales column derivation (price × item_count) and trying to model raw price or quantity separately — the target variable for forecasting is the derived total sales amount.
• Attempting a three-way DataFrame merge in a single pd.merge() call — always merge two DataFrames first, capture the result, then merge with the third.
• Leaving nulls unfilled in accident/event count columns — null values in numeric columns will break aggregations; fill with zero to represent 'no recorded event'.
• Using user-based collaborative filtering when the input is an item (location) — when the recommendation trigger is a place, not a user profile, item-based collaborative filtering is the correct approach.
• Running YOLO training without verifying data.yaml points to the correct local directory — the training script will fail silently or use wrong data if the path is misconfigured.
• Not using a GPU in Colab for vision tasks — training CNNs or YOLO on CPU in Colab will be prohibitively slow; always connect to a GPU runtime for image-based projects.

// What key terms should you know for the capstone tracks?

Two-Part Project Structure

Every capstone track consists of exactly two parts — one modelling/detection task and one analysis/recommendation/forecasting task — both of which must be completed if that track is chosen.

Transfer Learning

The process of taking a pretrained model (e.g., VGG16, ResNet) off the shelf, removing its top classification layers (include_top=False), inserting custom dense layers matching your output classes, and retraining on your specific dataset.

include_top=False

The Keras parameter that strips the original classification head from a pretrained model, allowing the user to attach custom output layers for a new classification task.

Augmentation With-and-Without Comparison

A training protocol where the same model architecture is trained twice — once with a prepended Sequential block of image transformations (flips, rotations, zooms) and once without — to empirically measure the generalization benefit of data augmentation.

image_dataset_from_directory()

A TensorFlow/Keras utility that loads images from a folder structure where each subfolder name becomes a class label, automatically splitting into training and validation sets.

Item-Based Collaborative Filtering

A recommendation approach where the input is an item (e.g., a tourist location) and the output is a ranked list of similar items based on shared user rating patterns — used when no specific user profile is given as input.

Generate-Then-Aggregate Sales Column

The two-step process of first creating a sales column (unit_price × item_count) at the row level, then grouping by date and summing to produce a daily total sales time series suitable for forecasting.

Time-Ordered Train/Test Split

A splitting strategy for time-series data where data is sorted by date ascending, and the final 6 months are held out as the test set while all earlier data forms the training set — no random shuffling is applied.

Three-Model Regression Comparison

The practice of training Linear Regression, Random Forest Regression, and XGBoost Regression in parallel on the same dataset, evaluating each with RMSE, and selecting the lowest-RMSE model as the champion for final forecasting.

Merge-in-Two-Steps Pattern

The technique of combining three DataFrames by first merging two on a shared key column, saving the result, and then merging that result with the third DataFrame on its shared key — necessary because pd.merge() operates on two DataFrames at a time.

YOLO (You Only Look Once)

A PyTorch-based real-time object detection model used via a cloned repository; it produces bounding box coordinates plus class labels for every detected object in an image, and is trained/evaluated using train.py and detect.py scripts with a data.yaml configuration file.

data.yaml

The YOLO configuration file that specifies the local directory paths for training and validation image data, the number of classes, and the string names of each class — must be manually updated to match the user's local or Colab directory structure.

Resample

A pandas time-series method (.resample('W'), .resample('M'), .resample('Q')) that aggregates a datetime-indexed DataFrame up to weekly, monthly, or quarterly frequency, enabling multi-scale trend analysis of sales data.

// FREQUENTLY ASKED QUESTIONS