←back to projects
DBS Foundation Coding Camp 2024/AI/ML/course

Animals10 Image Classification Project

Promoted from explicit local README, model artefacts, notebook, requirements, and insight evidence, this project is framed as a conservative ML learning artefact rather than a deployed computer-vision product.

project links
Repositoryrepo
Domain
AI/ML
Role
Machine Learning Engineer
Output
ML Pipeline
Category
Computer Vision Classification
Project Framing

A source-backed case study built for recruiter review

This reading path makes the problem choice, evidence quality, user framing, execution decisions, and proof trail visible without overstating what the sources support.

Project Type
course

Image-classification coursework project that trains a CNN to distinguish chicken, dog, and spider images from the Animals10 dataset.

Orientation
Tech

Provides source-level evidence of computer-vision experimentation, model packaging, and multi-format export discipline without claiming production deployment or real-world adoption.

Core Stack
Python · TensorFlow · Keras · CNN

Notebook-driven TensorFlow/Keras workflow with local requirements metadata, saved model artefacts, TF Lite export, TensorFlow.js export, and H5 model output preserved in the archive.

Why This Problem Mattered

Problem framing before execution

The case-study layer starts with why this problem was selected and how the context justified investment.

Problem Framing Map

Issue

The coursework objective was to build an image classifier while keeping training, evaluation, and export outputs reviewable.

Context

The project intentionally narrows the Animals10 dataset into three classes so the learning workflow can stay understandable and auditable.

Why Selected

It is valuable as a portfolio case because it demonstrates disciplined scoping, documented data split choices, and multi-format model packaging rather than vague ML claims.

Problem statement

The coursework objective was to classify images across selected animal classes while keeping model training, evaluation, and export artefacts reviewable.

Solution thesis

Built a CNN-based image-classification workflow for chicken, dog, and spider classes, with preprocessing, training, evaluation notes, and saved model outputs in multiple serving formats.

Research and Evidence

What supports the narrative

Evidence is surfaced with its source type and credibility note so the recruiter can quickly see what is directly backed versus intentionally constrained.

Dataset and class scope
local

The README explicitly identifies chicken, dog, and spider as the selected classes.

Credibility: Directly documented in the source-backed README and supported by notebook artefacts.
Evaluation framing
local

The README documents an 80/20 split and an accuracy target of at least 85% for training and validation.

Credibility: These are explicit training-governance facts rather than inferred performance claims.
Portability evidence
local

SavedModel, TF Lite, TensorFlow.js, and H5 outputs are all preserved in the archive.

Credibility: Model artefacts provide direct evidence that export pathways were implemented.

Credibility Notes

  • ●The project is presented as a conservative coursework artefact, not a deployed production CV system.
  • ●Accuracy discussion stays at documented goals and workflow evidence unless explicit evaluation output is present in source.
Who The User Was

User framing stays explicit

When formal research artefacts are not available, the page still explains who the work served and why that user framing is justified by the existing sources.

Primary user
Reviewers evaluating whether the ML workflow is scoped, documented, and exportable.

The strongest evidence is in the reproducibility and artefact trail rather than a deployed end-user interface.

Secondary stakeholder
Future developers or learners who may want to consume the trained model in different runtime environments.

The project exports TF Lite, TensorFlow.js, SavedModel, and H5 artefacts to support multiple consumption paths.

Decision Flow

How design thinking translated into decisions

The goal is to show the trace from research and insight to concrete product or system decisions, then to the outcomes those decisions supported.

Design Thinking Flow

Each step keeps the movement from evidence to action explicit before the rationale expands it.

  1. Step 1
    Scope narrowing

    Reduced the broader Animals10 space into a three-class problem that was easier to train, inspect, and explain.

    Signal: Chicken, dog, and spider became the explicit target classes.
  2. Step 2
    Training governance

    Defined split and accuracy expectations to make experimentation more reviewable.

    Signal: README documents 80/20 split and target performance threshold.
  3. Step 3
    Model packaging

    Treated model export as part of the deliverable rather than only a notebook conclusion.

    Signal: Multiple serving formats are preserved in the archive.

Decision Rationale

Each decision keeps the path from insight to execution visible before ending on the outcome signal.

Notebook-first workflow
Insight

The project needed to keep experimentation and visual evaluation traceable in a coursework setting.

Decision

Used TensorFlow/Keras inside a notebook-driven workflow.

Outcome

The training story remains reviewable from preprocessing through export.

Multi-format export
Insight

Model usefulness increases when outputs can be carried across runtime targets.

Decision

Exported the model to TF Lite, TensorFlow.js, SavedModel, and H5.

Outcome

The project demonstrates packaging discipline beyond raw model training.

Solution and System Execution

Execution choices and delivery details

This section preserves the technical and operational substance: architecture, responsibilities, trade-offs, and implementation quality signals.

System Design

Notebook-driven TensorFlow/Keras workflow with local requirements metadata, saved model artefacts, TF Lite export, TensorFlow.js export, and H5 model output preserved in the archive.

Source-backed Impact

Provides source-level evidence of computer-vision experimentation, model packaging, and multi-format export discipline without claiming production deployment or real-world adoption.

Responsibilities

  • ●Prepared selected Animals10 image classes for model training
  • ●Implemented a CNN workflow using TensorFlow and Keras
  • ●Exported model artefacts into multiple reviewable formats

Stack Decisions

  • ●Used TensorFlow and Keras for a coursework-sized CNN implementation
  • ●Kept a notebook workflow to make experimentation and visual evaluation traceable
  • ●Saved outputs in TF Lite, TensorFlow.js, SavedModel, and H5 formats to support different consumption paths

Trade-offs

  • ●Kept public wording to source-visible training and export evidence instead of deployment claims
  • ●Accepted notebook-first delivery because the source does not document a production inference service

Challenges

  • ●Preparing a focused three-class subset from a larger image dataset
  • ●Balancing model experimentation with portable artefact export
Outcomes and Proof

What was delivered and what can be verified

Outcome claims remain conservative and source-backed, while proof records and recruiter-safe links surface the strongest verification trail available.

Validation Signals

  • ●README identifies class scope, data split, and training target explicitly.
  • ●Archive preserves notebook, requirements, and multiple exported model formats.

Source-backed Outcomes

  • ●README identifies chicken, dog, and spider as the selected image classes
  • ●README documents an 80% training and 20% test split
  • ●README states an accuracy goal of at least 85% for training and validation
  • ●Archive includes SavedModel, TF Lite, TensorFlow.js, and H5 model artefacts
Retrospective and Limits

What the project proves, and what it does not

Strong case studies show both what was learned and where the current evidence stops.

Retrospective

Next iteration should add a reproducible training script, model-card summary, and source-backed evaluation output before claiming stronger model performance or deployment readiness.

Evidence Limits

  • ●Current sources do not provide a production inference service or real-world adoption proof.
  • ●Stronger performance claims should wait for source-backed evaluation outputs such as confusion matrices or benchmark tables.

Lessons

  • ●Computer-vision projects become more reviewable when dataset scope, split, architecture, and export formats are documented together
  • ●Multi-format model packaging should be treated as part of the ML delivery story, not an afterthought