The catalog

300+ projects to build

Every project comes with a complete PRD, HLD & LLD. Filter by domain, difficulty or tech stack to find your next build.

15 projects

Sort

Easy

Train-and-Download Regression Network Builder for CSV Data

The distance between understanding neural networks and having trained one on your own data is shorter than most beginners think. This project removes the setup friction entirely: bring a CSV file, train a real network in the browser, and leave with a working model file. The intern builds a Streamlit web application where users upload a CSV dataset, pick the target column, and train a regression neural network built with Keras on TensorFlow. Training progress is visualized live through loss curves, and once training completes the app plots predictions against actual values so users can judge the fit at a glance. A download button exports the trained model, completing the cycle from raw data to portable artifact. The intern handles the practical engineering underneath: parsing uploads, basic preprocessing, choosing sensible default architectures, and keeping training responsive inside a web application. The project gives the intern end-to-end experience with the deep learning workflow — data ingestion, network construction, training visualization, and model export — while producing an approachable tool that makes a first neural network achievable for the next learner who uses it.

educationreal-estatedata-sciencedeep-learning+4

View project

Easy

Learning Rate and Batch Size Effects Visualizer for Deep Learning

Ask a beginner why their network is not learning and the answer is usually hiding in two numbers: the learning rate and the batch size. Their effects are far easier to understand seen than described, and this project builds the tool that shows them clearly. The intern creates a visualizer, developed in Jupyter with Keras and TensorFlow, that trains a small neural network on a compact dataset repeatedly under different learning rates and batch sizes, then plots the resulting training curves together for comparison. The characteristic patterns become recognizable at a glance: divergence when the rate is too high, glacial progress when it is too low, the noisy-but-fast trajectories of small batches versus the smooth ones of large batches. Users can adjust the settings and re-run experiments quickly enough to explore the space themselves and form their own rules of thumb. The project builds diagnostic instinct — the ability to look at a loss curve and name the likely cause — which is among the most practical skills in deep learning. The intern also practices designing controlled experiments and communicating their results visually, habits that transfer directly to research and production work.

educationresearchdata-sciencedeep-learning+4

View project

Easy

Dropout and Weight Regularization Experiments Notebook

Overfitting is the default fate of neural networks trained on limited data, and regularization is the cure — but learners rarely get to watch the cure actually work. This project builds a notebook laboratory where dropout and weight penalties are applied, varied, and observed rather than memorized. Working in Jupyter with Keras and TensorFlow, the intern constructs a small neural network prone to overfitting by design, then runs controlled experiments: adding dropout layers at different rates, applying L1 and L2 weight regularization at different strengths, and combining the techniques. For every configuration the notebook plots training and validation loss together, so the divergence signature of overfitting — and each technique's effect in narrowing that gap — is directly visible. The experiments are organized so users can modify parameters and rerun cells to test their own hypotheses about what will happen next. The intern comes away understanding not just what regularization is but how each technique behaves and how much of it is enough, along with experience structuring reproducible notebook experiments — the same discipline that underpins credible deep learning research.

educationresearchdata-sciencedeep-learning+4

View project

Easy

Optimizer Comparison Lab for SGD, Adam, and RMSProp

SGD, Adam, and RMSProp appear in every deep learning tutorial as a dropdown choice, but the differences between them are dynamic — visible only in how training actually unfolds over time. This project builds a playground for racing the optimizers against each other on equal terms. Working in Jupyter with Keras and TensorFlow, the intern trains identical copies of a simple neural network on a toy dataset, one per optimizer, and renders live loss and accuracy plots that update as training proceeds. The overlaid curves reveal each algorithm's temperament: plain SGD's steady but slow descent, RMSProp's adaptive pace, and Adam's typically rapid early progress. The intern extends the comparison by varying learning rates per optimizer, discovering that rankings between optimizers can flip when their settings change — a nuance most tutorials never mention. The project replaces cargo-cult optimizer selection with observed understanding. The intern learns what adaptive gradient methods actually adapt, how to design fair model comparisons, and how to present training dynamics visually — foundations for principled experimentation in any deep learning role.

educationresearchdata-sciencedeep-learning+4

View project

Hard

Explainable Segmentation and Diagnosis Platform for Medical Scans

Radiology departments face rising imaging volumes while specialist time remains scarce, and clinicians are understandably reluctant to trust opaque model outputs when reviewing X-rays and MRIs. What is needed is tooling that both accelerates review and shows its reasoning, so a human expert can verify every automated finding. The intern builds a web application in Streamlit where medical images are uploaded and processed live: a U-Net model produces semantic segmentation masks that outline anatomical structures or suspected lesions, while an EfficientNet classifier proposes a diagnostic label for the scan. Segmentation overlays are rendered directly on the source image with OpenCV, and an explainability dashboard surfaces confidence scores and saliency views so reviewers can see which regions influenced each prediction. Model work spans both PyTorch and TensorFlow, NumPy and pandas handle array manipulation and results tabulation, and a FastAPI layer exposes REST endpoints for batch inference across large scan archives. Docker packaging makes the stack reproducible for hospital IT or research deployment. The project demonstrates advanced skills in medical computer vision, multi-framework model serving, explainable AI presentation, and building clinical software that keeps the human decision-maker in control.

healthcareresearchcomputer-visiondocker+10

View project

Medium

Field Crop Health Analysis via Image Segmentation

Assessing crop health across a field by eye is slow and inconsistent, and by the time stress or disease is visible during a casual walk-through, yield has often already been affected. Agronomists and agricultural researchers need a way to turn ordinary crop photographs into quantitative health measurements they can track over time. This project has the intern build a Streamlit application that segments crop imagery using two complementary approaches: classical computer vision methods, implementing Watershed and GrabCut with OpenCV, and a deep learning path using a U-Net style model built with Keras and TensorFlow. Once plants are isolated from soil and background, the app computes health indicators from the segmentation masks, such as vegetation coverage ratios and color-based stress signals derived with NumPy, and presents side-by-side visual comparisons of each technique's output so users can judge where classical methods suffice and where learned models win. By finishing the project, the intern develops a practical understanding of both traditional and neural segmentation pipelines, learns to derive domain-meaningful metrics from pixel masks rather than stopping at pretty pictures, and demonstrates the ability to package agricultural analytics into an interactive tool a non-programmer can operate.

agriculturecomputer-visionkeras+5

View project

Medium

Webcam-Based Face Mask Compliance Monitor

Hospitals, clinics, laboratories, and food production facilities enforce face covering policies for safety, but relying on staff to visually police compliance at every entrance is impractical and inconsistent. An automated check at the door provides continuous coverage and frees people for higher-value work. The intern builds a Flask web application that captures live webcam video, detects faces in each frame with OpenCV, and classifies each detected face as masked or unmasked using a convolutional neural network trained in TensorFlow. The interface streams the annotated video feed to the browser with bounding boxes and prediction labels overlaid in real time, and the intern tunes the pipeline so detection and classification keep pace with the camera frame rate. The finished system is containerized with Docker, making it straightforward to host in the cloud or drop onto a small machine at a facility entrance. The project teaches the full arc of a deployed vision product: assembling and training a CNN classifier, wiring model inference into a live video loop, serving real-time results through a Python web framework, and packaging everything for repeatable deployment. It is a strong portfolio piece showing the intern can move a model from notebook experiment to a working safety tool.

healthcaresecuritycomputer-visiondocker+4

View project

Medium

Face Recognition Attendance Tracking for Classrooms and Offices

Taking attendance by roll call or paper sign-in sheets wastes teaching time, invites proxy sign-ins, and produces records that are tedious to compile. Schools, training centers, and HR teams want attendance capture that is fast, hard to game, and automatically logged, without requiring badges or manual data entry. This project has the intern build a Flask web application that automates the entire flow: OpenCV detects faces from a live webcam stream, a convolutional neural network built with TensorFlow recognizes each enrolled individual, and the system records a timestamped attendance entry the moment a known face is confirmed. The intern implements an enrollment workflow for registering new people with sample images, real-time prediction overlays on the video feed so users get immediate confirmation, and attendance views for reviewing who was present on a given day. The application ships as a Docker container for painless installation on a classroom or office machine. Completing the system teaches face detection and recognition pipelines end to end, the practical differences between detecting a face and identifying a person, and how to design biometric software responsibly. The intern leaves with a deployable product demonstrating applied vision, web development, and deployment skills together.

educationhuman-resourcescomputer-visiondocker+4

View project

Medium

U-Net Segmentation Dashboard for MRI Scan Review

Outlining anatomical structures and abnormalities on MRI scans is one of the most time-consuming tasks in medical imaging, often requiring slice-by-slice manual tracing by trained specialists. Research groups and imaging teams need accessible tools that generate candidate segmentations automatically so expert time is spent verifying results rather than drawing boundaries. In this project the intern builds a Streamlit web application around a U-Net model implemented with Keras and TensorFlow. Users upload a medical image, the app runs a preprocessing pipeline using OpenCV and NumPy to normalize and resize the input, and the model produces a semantic segmentation mask identifying the target regions. The intern implements clear visualization of results, showing the original scan, the predicted mask, and a blended overlay so reviewers can immediately judge segmentation quality, and uses pandas to summarize mask statistics such as segmented area for each processed image. The build gives the intern hands-on experience with the model architecture most widely used in biomedical segmentation, teaches the preprocessing discipline that medical imagery demands, and demonstrates the ability to wrap a trained network in an interface that a clinical researcher can operate without touching code.

healthcarekerasnumpy+5

View project

Easy

Image Classifier Deployment Template for Product Photos

Many teams train a capable image classification model and then stall at the last step: nobody can use a model that only lives in a notebook. E-commerce companies in particular need lightweight ways to put product photo classifiers, for example distinguishing categories of merchandise, in front of catalog and operations staff quickly. The intern builds a reusable deployment template with Streamlit that wraps a pre-trained TensorFlow image classifier in a clean web interface. Users upload a product photo, the app preprocesses it to the model's expected input format, and predictions are displayed live with class probabilities and a simple explanation view showing why the model favored its top choice. The intern structures the code so that swapping in a different trained model requires minimal changes, which is what makes the project a template rather than a one-off demo, and documents the steps a teammate would follow to reuse it. Though scoped for beginners, the project delivers a professional lesson: the intern learns the standard pattern for serving an image model behind a Python web interface, practices handling user-supplied images defensively, and finishes with a working, demonstrable deployment that proves they can carry a computer vision model over the line from training artifact to usable product.

e-commercecomputer-visionpython+2

View project

Easy

Model Persistence Walkthrough for TensorFlow Beginners

Newcomers to machine learning routinely lose hours of training work because they never learn how models are saved, restored, and reused; every session starts from scratch and nothing they build survives a restart. Understanding persistence is also the conceptual gateway to deployment, since every production system depends on loading a previously trained model. The intern builds an interactive Streamlit application that makes the save-and-load lifecycle tangible. Users train a small TensorFlow model directly from the interface on a simple image dataset, watch training progress, and then persist the result to disk. The app demonstrates saving weights versus saving full models, lets users restart the session and reload the saved model, and proves the round trip worked by running predictions with the restored network and comparing them against the pre-save outputs. Clear in-app explanations accompany each step so the tool doubles as a teaching resource for other learners. By completing the walkthrough, the intern internalizes how trained parameters are serialized in TensorFlow, why persistence formats matter when moving models between environments, and how to build a Python and Streamlit interface that teaches a technical concept interactively, a skill directly transferable to documentation and developer tooling work.

educationcomputer-visionpython+2

View project

Easy

Beginner Transfer Learning Lab with MobileNet and ResNet

Training an image classifier from scratch requires data and compute that beginners rarely have, which is why transfer learning, reusing networks pre-trained on millions of images, is the technique that actually unlocks practical computer vision for newcomers. Yet the concept stays abstract until a learner sees a pre-trained model classify their own photographs correctly. The intern builds a Streamlit application that makes transfer learning tangible: users upload any image and classify it using pre-trained MobileNet or ResNet models loaded through TensorFlow. The app displays the top predicted classes with confidence scores and lets users switch between the two architectures on the same image to compare their answers and inference speed. The intern implements the specific preprocessing each network expects, presents results clearly, and adds explanatory content describing what the models were trained on and why their knowledge transfers to new images, turning the app into a genuine self-serve lesson. Completing the lab gives the intern a working understanding of pre-trained architectures and the trade-off between lightweight and heavyweight models, practical TensorFlow inference skills, and a deployed Python application demonstrating they can make advanced ideas accessible, a foundation for the fine-tuning projects that come next.

educationcomputer-visionpython+2

View project