8 Machine Learning Capstone Project Ideas With Datasets

Choosing a machine learning capstone means choosing a question you can test with data you can access. These eight machine learning capstone project ideas help U.S. college seniors and master's students compare datasets, workload, baselines, and evaluation before committing.

The shortlist covers tabular prediction, text classification, forecasting, and recommendation. Each idea includes a manageable experiment and a limitation worth discussing with your advisor. An executed hourly bike-rental example also shows why the model with the lowest overall error may perform worse during an important time slice.

What makes a strong machine learning capstone?

A machine learning capstone connects a defined problem to data preparation, modeling, evaluation, and communication. Its contribution might be a useful comparison, a reliability study, or an application evaluated under realistic constraints.

Start with Python, pandas, and basic regression or classification. Scikit-learn can support the initial models; a notebook and simple local interface can support an early demonstration. Your instructor's rubric determines the required depth and deliverables.

Before choosing, inspect a capstone dataset: load a sample, confirm labels and permissions, and identify inputs available at prediction time. If access or usable outcomes remain unresolved, choose another candidate before expanding the architecture.

Which project fits your skills?

Difficulty describes the proposed scope, not a university grading standard. The project names link to their full plans.

Read the metrics correctly: MAE is average absolute error in the target's units; lower is better. Macro-F1 averages each class's F1 equally. Average precision summarizes the precision–recall trade-off and is not interchangeable with every PR-AUC calculation. Calibration checks whether predicted probabilities match observed frequencies. Recall@10 measures the share of held-out relevant items found in ten recommendations; NDCG@10 also rewards better ranking positions.

1. Predict home sale prices in Ames, Iowa

Question and data: Can property characteristics improve on a median-price estimate? Use the original Ames Housing file and De Cock's dataset paper, which describes 2,930 residential sales from 2006–2010.

Build: Compare the training-price median, regularized linear regression, and a tree regressor. Reserve later sales for validation and testing. Audit repeated property IDs and state whether the study evaluates new properties, repeat sales, or both. Fit imputation and encoding on training data only; exclude sale outcomes from inputs.

Evaluate and deliver: Report MAE in dollars and errors by price band. Add a property-input demo. Historical Iowa sales cannot establish current nationwide valuation accuracy.

2. Forecast hourly bike rentals

Question and data: Can calendar information and past rentals improve next-hour count forecasts? Download `hour.csv` from UCI Bike Sharing, covering Capital Bikeshare in 2011–2012.

Build: Compare the same hour last week with a calendar model and the same model plus historical counts. Match lags by timestamps: 168 recorded rows may span more than seven days when hours are absent. Exclude `casual` and `registered`, whose sum is the target `cnt`; exclude future observed weather.

Evaluate and deliver: Train on earlier records and evaluate later periods on identical eligible hours. Report overall and commute-hour MAE in a dashboard. Recorded rentals measure completed usage, not unmet demand when bikes are unavailable.

3. Classify archived consumer complaints

Question and data: Can complaint text predict a selected financial-product category? The CFPB narratives archive lists previously published complaints received through August 14, 2026. Select a dated export and verify nonempty narratives and product labels.

Build: Keep three to five sufficiently represented categories selected from development data. Compare majority prediction with TF-IDF text features and logistic regression. Fit the vocabulary only on training records. Remove later duplicate narratives using a documented rule, then evaluate later dates. Define how excluded or unseen categories are handled.

Evaluate and deliver: Report macro-F1, category recall, and class counts. Show uncertain cases in the demo. Archive labels support category prediction, not judgments about complaint validity or representative consumer experiences.

4. Estimate airline departure-delay risk

Question and data: Which scheduled flights will depart at least 15 minutes late? In BTS reporting-carrier records, `DepDel15` identifies that outcome. Use the table's Download route to select one origin airport and a complete historical year; confirm export access first.

Build: Compare a training-set delay probability with logistic regression and gradient boosting. Use scheduled time, destination, carrier, and calendar features; evaluate later months. Exclude actual departure times, arrival outcomes, and recorded delay causes. Document cancellations and missing labels rather than treating them as on-time departures.

Evaluate and deliver: Report average precision, calibration, and precision/recall at a validation-selected threshold. Present a historical risk dashboard; conclusions concern the evaluated departures.

5. Classify Colorado forest cover

Question and data: Can terrain and soil attributes distinguish forest cover types? UCI Covertype uses cartographic variables from northern Colorado wilderness areas, rather than photographs.

Build: Start with a documented subset and compare majority prediction, logistic regression, and random forest. Audit duplicate feature records; remove exact duplicate rows or keep matching records together when splitting. Fit preprocessing within training data. Use a stratified holdout for a benchmark comparison.

Evaluate and deliver: Report macro-F1, class counts, and a confusion matrix. Build a feature-input classifier with a failure note. A random holdout does not demonstrate transfer to unseen forests; an extension using wilderness-area holdouts must discuss changed class coverage.

6. Recommend movies with a ranking test

Question and data: Can personalization outperform a popularity list? MovieLens 100K is a stable GroupLens benchmark. Read its attribution, redistribution, and commercial-use conditions. Its university provenance does not establish a nationally representative U.S. audience.

Build: Choose global chronological training, validation, and final-test cutoffs. Use validation outcomes to choose the method and settings. Then refit using only interactions before the final-test cutoff and freeze that history for the final ranking test. Compare popular unseen movies with item-based collaborative filtering using the same frozen history, candidate catalog, and exclusions. Define relevant held-out ratings, such as four or five, and eligible users before scoring. Remove previously rated movies; do not update either method with final-test interactions.

Evaluate and deliver: Report Recall@10 and NDCG@10 using identical eligible users and catalogs. State exclusions for users without held-out positives and evaluate new users or movies separately. Build an explorer without redistributing data contrary to its terms.

7. Forecast next-day electricity demand

Question and data: Can past demand improve forecasts for each hour of the next day? Use EIA's hourly balancing-authority operating data. A balancing authority manages electricity supply and demand within an operating area. Select one authority, a demand series, units, and a fixed historical period. For API access, follow the current APIv2 documentation, obtain the required free key, and test series selection and pagination before committing. A documentation link alone does not verify an export.

Build: Compare weekly seasonal predictions with a lag-based regressor. Produce all next-day predictions from one forecast origin; target-day observations cannot update that forecast. Preserve time conventions and distinguish absent readings from zero demand.

Evaluate and deliver: Use rolling chronological evaluation, overall MAE, and peak-hour errors with the peak rule defined during development. A dashboard based on revised historical data needs release-delay checks before it can support live operating claims.

8. Model next-day particulate pollution

Question and data: Can past readings improve next-day PM2.5 concentration forecasts? EPA daily downloads provide monitor-level summaries. Choose one monitor, a consistent measurement definition and units, and adequate consecutive-day coverage. PM2.5 means fine particulate matter; concentrations here use micrograms per cubic meter.

Build: Compare persistence with a lag-based regressor using chronological splits. Audit duplicate summaries and missing dates; construct lags by calendar date. For a next-day forecast, report days without a usable previous-day reading rather than silently changing the horizon.

Evaluate and deliver: Report MAE and high-concentration-period errors using a development-defined threshold. Create an experimental trend viewer. Validated monitoring archives do not establish timely input availability for public health alerts.

Worked example: a model can win overall and lose at commute hours

A reproducible benchmark used the hourly Bike Sharing file, rather than the daily dataset. The downloaded `hour.csv` contained 17,379 rows, with 165 absent slots across its nominal date-and-hour grid. No absent targets were filled with zero.

These counts describe the downloaded file: the UCI catalog displays 17,389 instances. Absent date/hour slots differ from null fields within recorded rows. The checksum in the runnable appendix identifies the exact hourly input used.

Training used eligible January–September 2011 records; validation used October–December 2011. Both fixed model configurations were then refitted on eligible 2011 records and evaluated on 8,634 eligible 2012 hours. The file contains 8,734 recorded 2012 hours; 100 lacked a required lag and were excluded from every method's comparison.

The calendar model used hour, weekday, month, holiday, and working-day flags. Its counterpart added counts from exactly 1, 24, and 168 recorded-clock hours earlier. Both used `HistGradientBoostingRegressor` with 100 iterations, learning rate 0.1, 31 maximum leaves, minimum leaf size 20, early stopping disabled, and random seed 42. No parameter search was performed.

Commute hours were Monday–Friday, 7–9 a.m. and 4–6 p.m., including holidays: 1,542 eligible observations. The calendar-plus-lag model had the lowest overall MAE among the four compared methods. The weekly baseline had lower MAE during this commute-hour slice. This fixed comparison does not establish the best possible calendar-only model or the best method for every period.

The same lag-model configuration had an overall MAE of 20.80 in 2011 validation and 47.97 in 2012 evaluation. Commute-hour MAE changed from 39.22 to 117.53. The periods and final training set differ, so this does not identify a single cause. It shows why validation performance should not be presented as a promise of later accuracy.

This is one historical comparison, not a significance test or a live service. Previous counts are assumed immediately available; timestamps use the file's recorded date/hour keys without a daylight-saving conversion. Evaluation-period counts enter only later predictions as past observations; model parameters stay fixed. Missing-lag exclusions may affect the result.

Preparation note: The benchmark was prepared with Python and AI assistance for this guide. It is a historical educational comparison, not an official UCI finding or a university-reviewed result. The complete code, pinned dependencies, and input checksum appear below. The other seven project briefs remain proposed studies.

The runnable appendix contains the complete script and pinned dependencies; it needs no private attachment. It recreates the manifest, validation metrics, per-hour predictions, monthly errors, and largest failures. Credit: Hadi Fanaee-T, Bike Sharing, UCI, DOI 10.24432/C5W894, CC BY 4.0.

How to build your capstone in eight weeks

Adapt this editorial plan to your semester, team, and experience. If access fails in week two, switch to an inspected fallback dataset.

A model card briefly describes intended use, data, evaluation, limitations, and unsuitable uses. Use your instructor's required format when you organize the methodology and results.

Proposal template: “Using [dataset/version] for [population and period], predict [target] at [prediction time]. Compare [baseline] with [model] on [held-out data] using [metric]. Test [one contribution], deliver [demo/report], and document [main limitation].”

How do you avoid leakage and add useful depth?

Keep fitted preparation inside training. Scaling, imputation, feature selection, and TF-IDF vocabulary must not learn from evaluation records. A scikit-learn pipeline helps preserve that boundary during fitting and cross-validation.

Keep the comparison population fixed. Do not let one model score only easy cases while another includes missing-history or unfamiliar-user cases. Report excluded observations and their reasons.

Test a contribution you can explain. A feature ablation adds or removes one feature group while holding the model and evaluation conditions fixed. The bike example compares calendar features with calendar plus historical counts. Also inspect time slices: a lower average error can coexist with poorer peak-period predictions.

Match uncertainty to the data. Adjacent hours are related; confidence intervals that treat every hour as independent may mislead. Predictive feature importance also does not establish causation.

Frequently asked questions

Which machine learning capstone is best for beginners?

Ames housing is a practical choice for students who know Python, tabular cleaning, and basic regression. Start with a median baseline and a small feature set before adding models.

Can I complete an ML capstone without a GPU?

Yes. The classical models here can start on a CPU with bounded datasets. Prototype a small sample before committing; memory needs depend on the selected rows, text vocabulary, and model.

How can I make a common idea original?

Test a specific contribution: remove one feature group, evaluate a later season, or examine recommendation cold-start behavior. Keep the comparison conditions fixed and explain both improvements and failures. Check that your course accepts the proposed contribution.

What accuracy should my capstone achieve?

There is no universal accuracy target. Regression needs error metrics such as MAE; classification and ranking need task-appropriate measures. Establish improvement over a credible baseline without leakage, then explain important failures.

Can I use free datasets?

Yes, but public access and redistribution permission are separate questions. Check the exact release's attribution and use conditions. MovieLens 100K, for example, includes restrictions on redistribution and commercial use.

What changes for a master's-level capstone?

Your program's rubric decides. A deeper study could examine calibration, temporal robustness, feature ablation, or cold-start users. A larger model alone does not establish a stronger research contribution.

Can I choose computer vision instead?

Yes, if your skills, data permissions, compute, and course requirements support it. This shortlist focuses on tabular data, text, forecasting, and ranking. A vision project still needs defined labels and a defensible split.

What should my final submission contain?

Include the question, data provenance, preparation code, baseline, comparison, held-out results, failures, limitations, and reproduction instructions. Add the demo, model card, report, and presentation your course requires, and attribute reused material.

Choose the experiment you can defend

Shortlist two ideas, load their data, and complete the proposal template. Choose the option whose target, available inputs, baseline, evaluation, and limitations you can explain clearly to your advisor.

For analytical alternatives, compare FileMakr's broader data science capstone ideas. If implementation references would help, browse machine learning project resources, cite reused code, and develop the contribution your course requires.

Reproduce the bike-rental benchmark

The complete source below recreates the benchmark without a private attachment or an unpublished download URL. Save the dependency block as `requirements.txt` and the Python block as `run_bike_experiment.py`. Use Python 3.12; the recorded run used 3.12.14.

numpy==2.3.5
pandas==2.2.3
scikit-learn==1.8.0
threadpoolctl==3.6.0

Run these commands from the directory containing both files:

python -m pip install -r requirements.txt
python run_bike_experiment.py --output rerun-results

The script retrieves the original UCI ZIP. For offline reruns, download that ZIP first and pass its path:

python run_bike_experiment.py --source-zip /absolute/path/bike-sharing-source.zip --output rerun-results

The hourly CSV must have SHA-256 `e03de4ee4ef4dc376ac6e04bf829673c6269e8eba5c60fa121640fa2f829504f`. The script stops before writing results if the source differs. Review a changed file as a new snapshot instead of silently comparing it with this benchmark.

Expected checks: 17,379 source rows, 165 absent nominal hour slots, 6,071 initial training rows, 2,192 validation rows, 8,263 final-fit rows, and 8,634 evaluation rows. Compare `manifest.json` and `metrics.csv` with these counts and the result table. The script also writes per-hour predictions, missing-hour keys, monthly errors, and ten largest failures; inspect those outputs before drawing conclusions. Exact floating-point equality across platforms is not promised.

"""Reproduce the article's hourly Bike Sharing benchmark (no raw data bundled)."""
from __future__ import annotations

import argparse
import hashlib
import io
import json
import platform
import urllib.request
import zipfile
from pathlib import Path

import numpy as np
import pandas as pd
import sklearn
from sklearn.ensemble import HistGradientBoostingRegressor
from sklearn.metrics import mean_absolute_error
from threadpoolctl import threadpool_limits

SOURCE = "https://archive.ics.uci.edu/static/public/275/bike+sharing+dataset.zip"
EXPECTED_HOUR_SHA256 = "e03de4ee4ef4dc376ac6e04bf829673c6269e8eba5c60fa121640fa2f829504f"
CALENDAR = ["hr", "weekday", "mnth", "holiday", "workingday"]
LAGS = ["lag_1h", "lag_24h", "lag_168h"]
PARAMETERS = dict(max_iter=100, learning_rate=0.1, max_leaf_nodes=31,
                  min_samples_leaf=20, early_stopping=False, random_state=42)


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--source-zip", type=Path)
    parser.add_argument("--output", type=Path, default=Path("results"))
    args = parser.parse_args()
    if args.source_zip:
        raw = args.source_zip.read_bytes()
    else:
        with urllib.request.urlopen(SOURCE, timeout=60) as response:
            raw = response.read()
    with zipfile.ZipFile(io.BytesIO(raw)) as archive:
        csv_bytes = archive.read("hour.csv")
    if hashlib.sha256(csv_bytes).hexdigest() != EXPECTED_HOUR_SHA256:
        raise ValueError(
            "The hourly source differs from the published benchmark. "
            "Review it as a new source snapshot before comparing results."
        )
    args.output.mkdir(parents=True, exist_ok=True)
    frame = pd.read_csv(io.BytesIO(csv_bytes))
    original_columns = list(frame.columns)
    frame["timestamp"] = (pd.to_datetime(frame["dteday"])
                          + pd.to_timedelta(frame["hr"], unit="h"))
    frame = frame.sort_values("timestamp").set_index("timestamp")
    assert frame.index.is_unique, "Resolve duplicate recorded date/hour pairs first."
    assert frame["cnt"].notna().all()
    assert (frame["cnt"] == frame["casual"] + frame["registered"]).all()
    grid = pd.date_range(frame.index.min(), frame.index.max(), freq="h")
    counts = frame["cnt"]
    for hours in [1, 24, 168]:
        # Exact timestamp join; never shift a potentially incomplete row sequence.
        frame[f"lag_{hours}h"] = counts.reindex(
            frame.index - pd.Timedelta(hours=hours)).to_numpy()
    eligible = frame.dropna(subset=LAGS).copy()
    train = eligible.loc[eligible.index < "2011-10-01"]
    validation = eligible.loc[(eligible.index >= "2011-10-01")
                              & (eligible.index < "2012-01-01")]
    development = eligible.loc[eligible.index < "2012-01-01"]
    evaluation = eligible.loc[eligible.index >= "2012-01-01"]
    assert len(train) and len(validation) and len(evaluation)
    assert train.index.max() < validation.index.min() < evaluation.index.min()
    assert set(CALENDAR + LAGS).isdisjoint({"cnt", "casual", "registered"})

    metric_rows = []
    prediction_frames = []
    for stage, fitting, scoring in [
        ("validation", train, validation),
        ("evaluation", development, evaluation),
    ]:
        predictions = {
            "last_observed_hour": scoring["lag_1h"].to_numpy(),
            "same_hour_last_week": scoring["lag_168h"].to_numpy(),
        }
        for name, columns in [("calendar_model", CALENDAR),
                              ("calendar_plus_lags_model", CALENDAR + LAGS)]:
            model = HistGradientBoostingRegressor(**PARAMETERS)
            with threadpool_limits(limits=1):
                model.fit(fitting[columns], fitting["cnt"])
                predictions[name] = model.predict(scoring[columns])
        commute = (scoring.index.dayofweek < 5) & scoring.index.hour.isin(
            [7, 8, 9, 16, 17, 18])
        out = pd.DataFrame({"observed": scoring["cnt"], **predictions})
        out["stage"] = stage
        prediction_frames.append(out)
        for name, predicted in predictions.items():
            metric_rows.append({
                "stage": stage, "method": name, "n": len(scoring),
                "mae_rentals_per_hour": float(mean_absolute_error(scoring["cnt"], predicted)),
                "commute_n": int(commute.sum()),
                "commute_mae": float(mean_absolute_error(scoring.loc[commute, "cnt"],
                                                         predicted[commute])),
            })
    metrics = pd.DataFrame(metric_rows)
    metrics.to_csv(args.output / "metrics.csv", index=False)
    all_predictions = pd.concat(prediction_frames)
    all_predictions.to_csv(args.output / "predictions.csv", index_label="timestamp")
    errors = all_predictions.loc[all_predictions["stage"] == "evaluation"].copy()
    errors["absolute_error"] = (errors["observed"] - errors["calendar_plus_lags_model"]).abs()
    errors.nlargest(10, "absolute_error").to_csv(args.output / "largest_errors.csv",
                                               index_label="timestamp")
    by_month = []
    for month, block in errors.groupby(errors.index.month):
        by_month.append({"month": int(month), "n": len(block), **{
            name: float(mean_absolute_error(block["observed"], block[name]))
            for name in predictions
        }})
    pd.DataFrame(by_month).to_csv(args.output / "monthly_mae.csv", index=False)
    missing = grid.difference(frame.index)
    pd.DataFrame({"missing_recorded_hour": missing}).to_csv(
        args.output / "missing_hours.csv", index=False)
    report = {
        "source": SOURCE,
        "source_attribution": "Fanaee-T, Hadi. Bike Sharing. UCI Machine Learning Repository. DOI: 10.24432/C5W894",
        "license": "See the current UCI dataset page; CC BY 4.0 was listed at preparation.",
        "zip_sha256": hashlib.sha256(raw).hexdigest(),
        "hour_csv_sha256": hashlib.sha256(csv_bytes).hexdigest(),
        "recorded_rows": len(frame), "original_columns": original_columns,
        "first_recorded_hour": str(frame.index.min()),
        "last_recorded_hour": str(frame.index.max()),
        "expected_nominal_hour_slots": len(grid), "unrecorded_hour_slots": len(missing),
        "duplicate_timestamps": int(frame.index.duplicated().sum()),
        "rows_eligible_for_all_methods": len(eligible),
        "train_rows": len(train), "validation_rows": len(validation),
        "final_fit_rows": len(development), "evaluation_rows": len(evaluation),
        "2012_recorded_rows": int((frame.index >= "2012-01-01").sum()),
        "2012_rows_excluded_for_missing_lags": int((frame.index >= "2012-01-01").sum()) - len(evaluation),
        "calendar_features": CALENDAR, "additional_lag_features": LAGS,
        "fixed_parameters": PARAMETERS,
        "protocol": {
            "training": "Eligible recorded hours before 2011-10-01",
            "validation": "2011-10-01 through 2011-12-31",
            "final_fit": "All eligible 2011 hours, same fixed model configurations",
            "evaluation": "2012 recorded hours with all 1h, 24h and 168h lags available",
            "selection": "No parameter search or selection among alternative runs. Both models reported.",
            "forecast": "One recorded-hour ahead; past observed counts assumed available immediately after each hour.",
            "availability": "Historical simulation; no verified real-time feed or publication-lag modeling.",
            "timestamp": "Naive date/hour keys as recorded; no claim of DST-aware elapsed UTC hours.",
            "common_rows": "All four methods scored on identical eligible rows, including the calendar-only model.",
            "missingness": "No missing target or lag values filled with zeros; exclusions are reported.",
            "commute_slice": "Monday-Friday hours 7,8,9,16,17,18; holidays not separately excluded.",
            "statistical_scope": "One fixed historical benchmark; no significance, interval, or universal improvement claim.",
        },
        "versions": {"python": platform.python_version(), "pandas": pd.__version__,
                     "numpy": np.__version__, "scikit_learn": sklearn.__version__},
        "metrics": metric_rows,
    }
    (args.output / "manifest.json").write_text(json.dumps(report, indent=2) + "\n")
    print(json.dumps({k: v for k, v in report.items() if k not in ["protocol", "metrics"]}, indent=2))
    print(metrics.to_string(index=False))


if __name__ == "__main__":
    main()