Instructions to use nina357/flower-classification-model with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Keras
How to use nina357/flower-classification-model with Keras:
# !pip install -U keras tensorflow huggingface_hub # Keras needs TensorFlow installed to read "hf://" paths, so the tensorflow backend is selected here; # "jax" and "torch" also work for computation once TensorFlow is installed. import os os.environ["KERAS_BACKEND"] = "tensorflow" import keras model = keras.saving.load_model("hf://nina357/flower-classification-model") - Notebooks
- Google Colab
- Kaggle
- πΈ MobileNetV2 Flower Classifier: Model Registry & Technical Specification
πΈ MobileNetV2 Flower Classifier: Model Registry & Technical Specification
This directory serves as the centralized Model Registry module within the MLOpsPortfolioExercise production system. When synchronized with the Hugging Face Hub, this document acts as the official Model Card and operational manual for model governance, consumption, deployment, and optimization.
π Table of Contents
- Model Architecture & Specifications
- Quickstart: Download & Inference
- Model Registry & MLOps Architecture
- Directory Structure & Artifact Manifest
- Publishing Guide to Hugging Face Model Hub
- Model Improvement Strategies & Roadmap
1. Model Architecture & Specifications
ποΈ Architecture Overview
The production model utilizes transfer learning using a lightweight convolutional backbone optimized for real-time mobile and web inference.
- Base Architecture: MobileNetV2 (pre-trained on ImageNet, top classification layers omitted,
include_top=False,pooling="avg"). - Classification Head:
Dense(512, activation="relu")$\to$Dropout(0.2)$\to$Dense(5, activation="softmax"). - Target Classes (5):
daisy,dandelion,roses,sunflowers,tulips. - Input Resolution:
(180, 180, 3)RGB. - Input Scaling: Pixel values scaled to the range $[-1, 1]$ via $x_{\text{norm}} = \frac{x}{127.5} - 1.0$.
- Serialized Model Weights:
flower_model.keras(~13.6 MB). - Metadata & Config:
classes.json,config.json. - Experiment Run: Tracked in MLflow under
Flower_Classification_DAI6.
π― Intended Use & Scope
- Primary Use Case: Real-time identification of flower species from consumer photographs via the FastAPI serving layer (
src/flower_web.py). - Intended Users: Educational applications, botanical cataloging tools, and automated floriculture classification services.
- Limitations & Out-of-Scope:
- Unopened flower buds or wilted flowers with unexposed petals may exhibit lower confidence.
- Inputs significantly cropped, heavily obscured, or lacking botanical features will trigger degraded predictions.
- The current model supports only the 5 target species; out-of-domain flora will be mapped to the closest matching class.
2. Quickstart: Download & Inference
Method 1: Load Directly from Hugging Face Hub (Recommended for Remote Serving)
import cv2
import json
import numpy as np
import tensorflow as tf
from huggingface_hub import hf_hub_download
# 1. Download model weights and class labels from Hugging Face Hub
REPO_ID = "nina357/flower-classification-model"
model_path = hf_hub_download(repo_id=REPO_ID, filename="flower_model.keras")
classes_path = hf_hub_download(repo_id=REPO_ID, filename="classes.json")
# 2. Load model and class names
model = tf.keras.models.load_model(model_path)
with open(classes_path, "r", encoding="utf-8") as f:
class_names = json.load(f)
# 3. Preprocess input image (180x180 RGB, normalized to [-1, 1])
image = cv2.imread("sample_flower.jpg")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image_resized = cv2.resize(image_rgb, (180, 180))
image_normalized = (image_resized / 127.5) - 1.0
input_batch = np.expand_dims(image_normalized, axis=0)
# 4. Run prediction
probabilities = model.predict(input_batch)[0]
predicted_index = int(np.argmax(probabilities))
confidence = float(probabilities[predicted_index])
print(f"Predicted Flower: {class_names[predicted_index]} ({confidence * 100:.2f}%)")
Method 2: Load from Local Repository Artifacts
import json
import numpy as np
import tensorflow as tf
# Load directly from the models/ directory
model = tf.keras.models.load_model("models/flower_model.keras")
with open("models/classes.json", "r", encoding="utf-8") as f:
class_names = json.load(f)
# Batch inference
sample_batch = np.random.uniform(-1.0, 1.0, size=(1, 180, 180, 3)).astype(np.float32)
preds = model.predict(sample_batch)
print("Output logits shape:", preds.shape)
3. Model Registry & MLOps Architecture
Beginner-Friendly Intuition
When training deep learning models over several weeks, practitioners often end up with disorganized artifacts:
flower_model.kerasflower_model_final.kerasflower_model_final_v2.kerasflower_model_best_accuracy_final.keras
When deploying to production, critical questions emerge:
- Which exact dataset and train/test split was this model trained on?
- What hyperparameters and learning rate schedule were used?
- Which code commit generated these weights?
- What was the validation accuracy on ambiguous classes like roses vs. tulips?
Without a system of record, binary weights are anonymous blobs.
The Analogy:
- GitHub stores, reviews, and versions your Code.
- DVC / Cloud Object Stores version and snapshot your Data.
- Model Registry governs, versions, audits, and delivers your Trained Models.
Just as modern app marketplaces provide version tags, system dependencies, changelogs, and release stages, a Model Registry maintains immutable lineage and transition rules for models moving from experimentation to production.
Enterprise MLOps Architecture
A Model Registry is a centralized, governed metadata store and artifact repository that manages the complete lifecycle of machine learning models from experimentation and validation to production serving, monitoring, and retirement.
flowchart LR
subgraph Dev["1. Training & Lineage"]
Code["Code Repo<br/>(Git Commit SHA)"] --> Train["Training Run"]
Data["Data Repo<br/>(DVC Version Hash)"] --> Train
Hyper["Hydra Config<br/>(Hyperparameters)"] --> Train
end
subgraph Registry["2. Model Registry (Hugging Face / MLflow)"]
Train --> Artifacts["Model Artifacts<br/>(Weights, classes.json, Model Card)"]
Artifacts --> Versioning["Version Tracking<br/>(v1.0.0, v1.1.0)"]
Versioning --> Lifecycle["Stage Transitions<br/>(Staging β Production β Archived)"]
end
subgraph Prod["3. Production Serving"]
Lifecycle -->|CI/CD Automated Pull| API["FastAPI Web Service<br/>(Docker Container)"]
end
The 5 Core Pillars of a Model Registry
- Artifact Storage: Securely stores serialized weights (
.keras,.safetensors,.onnx), label mappings (classes.json), and architecture configurations (config.json). - Lineage & Provenance: Links every registered model to its originating Git commit, DVC dataset hash, training duration, and author.
- Stage & Lifecycle Governance: Enforces clear environment boundaries:
Experimental$\to$ Exploratory runs and prototyping.Staging$\to$ Validated against integration tests, awaiting QA approval.Production$\to$ Actively serving live consumer requests.Archived$\to$ Deprecated models preserved for audit trails and zero-downtime rollback.
- Governance & Model Cards: Structured documentation capturing assumptions, performance metrics, data distribution, and ethical considerations.
- Serving Integration: Decouples API services from static file paths, allowing microservices to query for active production tags dynamically.
The 3-Repository System
To follow production-grade MLOps best practices, responsibilities are cleanly separated into three independent repositories:
| Repository | Host Platform | Technology | Primary Responsibility | Key Contents |
|---|---|---|---|---|
| 1. Code Repository | GitHub | Git, Python, Docker | Orchestration, pipelines, API serving, tests | src/, conf/, tests/, Dockerfile, CI/CD workflows |
| 2. Model Registry | Hugging Face Hub | Git LFS, Hugging Face API | Model versioning, weights storage, model cards | flower_model.keras, classes.json, config.json, README.md |
| 3. Data Repository | GitHub / DVC Remote | DVC, S3 / Cloud Storage | Raw images, preprocessed splits, versioning pointers | data/flower_photos/, .dvc, data download & verification scripts |
4. Directory Structure & Artifact Manifest
Below is the current layout of the models/ directory in this repository:
MLOpsPortfolioExercise/models/
βββ .gitattributes # Git LFS tracking rules for binary weights (*.keras, *.h5, *.tflite)
βββ .gitkeep # Directory preservation anchor
βββ README.md # Official Hugging Face Model Card & technical reference
βββ Running Training Locally.md # Local training, SQLite MLflow & FastAPI guide (excluded from HF)
βββ Running Training in Google Cloud.md # Cloud Run Jobs, Neon Postgres MLflow & GCS guide (excluded from HF)
βββ Dockerfile.train # Cloud Run Job training container (excluded from HF)
βββ Dockerfile.mlflow # Cloud Run MLflow server with psycopg v3 + GCS (excluded from HF)
βββ entrypoint_train.sh # DVC pull + remote MLflow training launcher (excluded from HF)
βββ deploy_mlflow.sh # 1-command Cloud Run MLflow deploy via .env (excluded from HF)
βββ cloudbuild.yaml # Google Cloud Build config for trainer image (excluded from HF)
βββ cloudbuild.mlflow.yaml # Google Cloud Build config for MLflow server image (excluded from HF)
βββ publish_to_huggingface.py # Automated 1-click deployment script to Hugging Face Hub
βββ flower_model.keras # Promoted Champion weights (~13.6 MB, git-ignored / uploaded to HF)
βββ classes.json # Champion target class label array (uploaded to HF)
βββ config.json # Champion architecture, lineage & evaluation metadata (uploaded to HF)
βββ runs/ # Per-run Challenger archives (git-ignored & excluded from HF)
βββ mlflow.db # Local SQLite MLflow tracking DB (git-ignored & excluded from HF)
βββ mlartifacts/ # Local MLflow artifact store (git-ignored & excluded from HF)
Artifact Manifest
| File / Folder | Uploaded to HF? | Description |
|---|---|---|
flower_model.keras |
Yes | Promoted Champion MobileNetV2 weights (~13.6 MB). Auto-downloaded on boot by src/flower_web.py. |
classes.json |
Yes | JSON array of ordered class names: ["daisy", "dandelion", "roses", "sunflowers", "tulips"]. |
config.json |
Yes | Champion architecture specs, Git/DVC lineage, hyperparameters, and validation accuracy. |
README.md |
Yes | Official Hugging Face Model Card with YAML metadata frontmatter. |
publish_to_huggingface.py |
No (ignored) | 1-click upload utility using huggingface_hub (ignore_patterns filters out all infra/local files). |
Dockerfile.* / *.sh / cloudbuild*.yaml |
No (ignored) | Cloud Run & Cloud Build infrastructure files kept organized inside models/. |
Running Training *.md |
No (ignored) | Local and Google Cloud operational runbooks. |
runs/ / mlflow.db / mlartifacts/ |
No (ignored) | Local Challenger run archives and local SQLite MLflow tracking store. |
5. Publishing Guide to Hugging Face Model Hub
Prerequisites: Get Your Hugging Face Token
- Sign up or log in at Hugging Face.
- Navigate to Settings $\to$ Access Tokens: https://huggingface.co/settings/tokens.
- Click Create new token:
- Token Type:
Write(required for artifact uploads). - Token Name:
mlops-model-token.
- Token Type:
- Copy your generated token (format
hf_...).
Publishing Methods
Method A: Automated Python Utility (Recommended)
The repository provides a deployment script models/publish_to_huggingface.py that automatically creates the remote repository (if not already existing), filters development checkpoints, and uploads the required production artifacts:
# 1. Authenticate with Hugging Face CLI
huggingface-cli login
# (Paste your 'hf_...' write token when prompted; select 'n' for git credential helper if unsure)
# 2. Run the deployment script from the project root
python models/publish_to_huggingface.py --repo-id "nina357/flower-classification-model"
To create a private repository, add the --private flag:
python models/publish_to_huggingface.py --repo-id "nina357/flower-classification-model" --private
What happens if you re-run
publish_to_huggingface.py?
- It safely reuses your existing Hugging Face repository (
exist_ok=True) and creates a new Git commit onmainwith only the updated files (README.md, and any newly promotedflower_model.keras,classes.json,config.json).- It is additive β it will not delete existing weights already hosted on Hugging Face if you don't have them locally.
- All local/infra files (
Dockerfile*,*.sh,cloudbuild*.yaml,mlflow.db,mlartifacts/,runs/,Running Training *.md) are automatically filtered out byignore_patterns.
Method B: Hugging Face CLI Direct Upload
# 1. Login
huggingface-cli login
# 2. Upload the models directory directly
huggingface-cli upload nina357/flower-classification-model ./models . --repo-type model
Method C: Git LFS Manual Setup
If you prefer operating through standard Git commands:
# 1. Install Git LFS (macOS example)
brew install git-lfs
git lfs install
# 2. Clone your newly created Hugging Face repository
cd /Users/nooshin/Uni/Data/data6
git clone https://huggingface.co/nina357/flower-classification-model
cd flower-classification-model
# 3. Copy production artifacts
cp /Users/nooshin/Uni/Data/data6/MLOpsPortfolioExercise/models/flower_model.keras .
cp /Users/nooshin/Uni/Data/data6/MLOpsPortfolioExercise/models/classes.json .
cp /Users/nooshin/Uni/Data/data6/MLOpsPortfolioExercise/models/config.json .
cp /Users/nooshin/Uni/Data/data6/MLOpsPortfolioExercise/models/README.md .
cp /Users/nooshin/Uni/Data/data6/MLOpsPortfolioExercise/models/.gitattributes .
# 4. Commit and push
git add .
git commit -m "feat: release initial v1.0.0 flower classification model"
git push origin main
Method D: Browser Drag & Drop
- Go to https://huggingface.co/new.
- Set Model name to
flower-classification-model, choose licensemit, and click Create model. - In the repository page, click Files and versions $\to$ Add file $\to$ Upload files.
- Drag and drop the 5 essential files from
MLOpsPortfolioExercise/models/:flower_model.kerasclasses.jsonconfig.jsonREADME.md.gitattributes
- Click Commit changes to main.
Verification Script
Verify that your published model downloads and instantiates correctly from any workstation:
import json
import tensorflow as tf
from huggingface_hub import hf_hub_download
REPO_ID = "nina357/flower-classification-model"
# Download artifacts
model_path = hf_hub_download(repo_id=REPO_ID, filename="flower_model.keras")
classes_path = hf_hub_download(repo_id=REPO_ID, filename="classes.json")
config_path = hf_hub_download(repo_id=REPO_ID, filename="config.json")
# Instantiate and verify
model = tf.keras.models.load_model(model_path)
with open(classes_path, "r", encoding="utf-8") as f:
class_names = json.load(f)
with open(config_path, "r", encoding="utf-8") as f:
config = json.load(f)
print(f"β
Model successfully verified from Hugging Face Hub!")
print(f" Architecture: {config.get('model_type')} ({model.name})")
print(f" Input Shape: {model.input_shape}")
print(f" Target Classes: {class_names}")
6. Model Improvement Strategies & Roadmap
Baseline vs. Target Performance
The table below contrasts the baseline implementation against architectural and operational enhancements designed for production MLOps:
| Evaluation Aspect | Baseline Implementation (src/flower_model.py) |
Target Optimized Model | Expected Engineering Impact |
|---|---|---|---|
| Input Preprocessing | Raw pixel values $[0, 255]$ without rescaling | Explicit Rescaling(1./127.5, offset=-1.0) |
π +5% to +8% Accuracy (Immediate Fix) |
| Backbone Training | 100% Frozen MobileNetV2 (trainable=False) |
Two-Stage Fine-Tuning (unfreeze top 30β50 layers) | π― +4% to +7% Accuracy |
| Data Augmentation | 5 static offline copies saved to disk | Online Dynamic Augmentation (Flip, Zoom, Jitter) | π‘οΈ Prevents memorization; saves 2.5 GB disk space |
| Backbone Choice | MobileNetV2 (3.5M params, 2018) | EfficientNetV2-B0 or ConvNeXt-Tiny | π +3% to +5% Accuracy at equivalent latency |
| Learning Rate | Constant learning rate ($10^{-3}$) | Cosine Decay Schedule + ReduceLROnPlateau |
π Smoother convergence; avoids local sub-optima |
| Loss & Regularization | Standard Crossentropy, single Dropout(0.2) | Label Smoothing (0.1) + AdamW weight decay | π― Calibrates probabilities on ambiguous petal borders |
| Evaluation Metrics | Top-1 Accuracy only | Per-class F1, Confusion Matrix logged to MLflow | π Identifies subtle misclassifications (roses vs. tulips) |
| Inference Runtime | Uncompressed Keras model (~14 MB) | TFLite FP16 / INT8 Quantization | β‘ 3x faster FastAPI inference; 75% smaller storage |
The 7 Concrete Improvement Pillars
Pillar 1: Input Preprocessing & Rescaling (Critical Fix)
- Problem:
tf.keras.preprocessing.image_dataset_from_directoryoutputs RGB values in $[0, 255]$. However, MobileNetV2 expects normalized inputs in $[-1, 1]$: $$\text{Pixel}_{\text{norm}} = \frac{\text{Pixel}}{127.5} - 1.0$$ Passing raw $[0, 255]$ causes internal activation saturation and distributional mismatch. - Solution: Place
layers.Rescalingas the first layer in the sequential model:
# In src/flower_model.py -> build_model()
model = keras.Sequential(
[
layers.Input(shape=input_shape),
# Normalize pixel range [0, 255] -> [-1, 1] for MobileNetV2
layers.Rescaling(1.0 / 127.5, offset=-1.0, name="mobilenetv2_rescaling"),
base_model,
layers.Dense(dense_units, activation="relu", name="feature_dense"),
layers.Dropout(dropout_rate, name="feature_dropout"),
layers.Dense(num_classes, activation="softmax", name="flower_probabilities"),
],
name="flower_classifier_mobilenetv2",
)
Key MLOps Advantage: Embedding normalization directly inside the Keras computational graph ensures that the serving layer (
src/flower_web.py) automatically preprocesses images without requiring separate client-side scaling logic.
Pillar 2: Two-Stage Fine-Tuning
- Problem: A completely frozen backbone prevents the convolutional kernels from adapting to domain-specific botanical morphology (petal curvature, stamen patterns, sepal structures).
- Solution: Execute two distinct training stages:
- Stage 1 (Warmup): Train only the classification head for 5 epochs with $\eta = 10^{-3}$.
- Stage 2 (Fine-Tuning): Unfreeze the top 30β50 layers of MobileNetV2 and train with a reduced learning rate ($\eta = 10^{-5}$).
flowchart LR
subgraph Stage1["Stage 1: Warmup (5 Epochs)"]
BaseFrozen["MobileNetV2 Backbone<br/>(100% Frozen)"] -.-> Head["Custom Dense Head<br/>(Trainable, lr=1e-3)"]
end
subgraph Stage2["Stage 2: Fine-Tuning (15 Epochs)"]
LowerFrozen["Lower 100 Layers<br/>(Frozen Low-Level Features)"] --> TopUnfrozen["Top 40-50 Layers<br/>(Unfrozen, lr=1e-5)"]
TopUnfrozen --> Head2["Custom Dense Head<br/>(Trainable, lr=1e-5)"]
end
Stage1 --> Stage2
def fine_tune_model(
model: keras.Model,
unfreeze_from_layer: int = 100,
fine_tune_learning_rate: float = 1e-5,
) -> keras.Model:
"""Unfreeze top backbone layers and recompile with a lower learning rate."""
base_model = model.get_layer("mobilenetv2_1.00_180")
base_model.trainable = True
# Keep initial layers frozen
for layer in base_model.layers[:unfreeze_from_layer]:
layer.trainable = False
model.compile(
optimizer=keras.optimizers.Adam(learning_rate=fine_tune_learning_rate),
loss="sparse_categorical_crossentropy",
metrics=["accuracy"],
)
return model
Pillar 3: Dynamic Online Data Augmentation & Color Jitter
- Problem: Generating 5 static offline copies on disk consumes ~2.5 GB and causes the model to memorize the same fixed augmentations across epochs.
- Solution: Implement real-time GPU/data-pipeline transformations using Keras preprocessing layers:
data_augmentation = keras.Sequential(
[
layers.RandomFlip("horizontal"),
layers.RandomRotation(0.2),
layers.RandomZoom(0.2),
layers.RandomTranslation(0.1, 0.1),
layers.RandomBrightness(factor=0.2),
layers.RandomContrast(factor=0.2),
],
name="online_augmentation",
)
- Advanced Strategy (MixUp / CutMix): Linearly blending pairs of images and labels: $$\tilde{x} = \lambda x_i + (1 - \lambda) x_j, \quad \tilde{y} = \lambda y_i + (1 - \lambda) y_j$$ forces the model to focus on subtle floral attributes rather than background context (e.g., grass or soil).
Pillar 4: Modern Backbone Exploration via Hydra
| Backbone | Parameter Count | Top-1 ImageNet | Key Advantage for Floral Datasets |
|---|---|---|---|
| MobileNetV2 (Current Baseline) | 3.5M | 71.8% | Lightweight, fast edge inference |
| EfficientNetV2-B0 | 5.9M | 78.7% | Native normalization, progressive regularization, superior accuracy-to-parameter ratio |
| ConvNeXt-Tiny | 28.6M | 82.1% | Modern 7x7 depthwise convolutions, robust botanical texture capture |
By defining conf/model/efficientnet_v2.yaml:
name: efficientnet_v2_b0
backbone: EfficientNetV2B0
classes: 5
dense_units: 512
dropout_rate: 0.2
trainable_base: false
pooling: avg
Architectures can be swapped from the CLI without code changes:
python src/flower_model.py model=efficientnet_v2
Pillar 5: Learning Rate Scheduling, AdamW & Label Smoothing
- Cosine Decay with Warmup: Prevents gradient shocks during initial epochs and gracefully converges toward narrow minima:
lr_schedule = keras.optimizers.schedules.CosineDecay( initial_learning_rate=1e-3, decay_steps=total_steps, alpha=0.01, ) optimizer = keras.optimizers.AdamW(learning_rate=lr_schedule, weight_decay=1e-4) - Label Smoothing Regularization: Ambiguous flower samples (e.g. unopened rosebuds looking like tulips) create overconfident one-hot labels ($y_{\text{hard}} = [0, 1, 0, 0, 0]$). Smoothing converts targets to calibrated distributions ($y_{\text{smooth}} = [0.025, 0.9, 0.025, 0.025, 0.025]$):
loss = keras.losses.CategoricalCrossentropy(label_smoothing=0.1)
Pillar 6: Per-Class Evaluation & Confusion Matrix in MLflow
Overall accuracy can mask underperformance in specific categories. Logging per-class F1-scores and confusion matrices ensures complete operational transparency:
from sklearn.metrics import classification_report, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns
import mlflow
def log_evaluation_artifacts(model: keras.Model, val_dataset: tf.data.Dataset, class_names: list[str]) -> None:
y_true, y_pred = [], []
for images, labels in val_dataset:
preds = model.predict(images, verbose=0)
y_true.extend(labels.numpy())
y_pred.extend(np.argmax(preds, axis=1))
# Log per-class metrics
report = classification_report(y_true, y_pred, target_names=class_names, output_dict=True)
for class_name, metrics in report.items():
if isinstance(metrics, dict):
mlflow.log_metric(f"{class_name}_f1_score", metrics["f1-score"])
# Render confusion matrix
cm = confusion_matrix(y_true, y_pred)
fig, ax = plt.subplots(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", xticklabels=class_names, yticklabels=class_names, ax=ax)
ax.set_ylabel("True Category")
ax.set_xlabel("Predicted Category")
ax.set_title("Flower Classification Confusion Matrix")
plt.tight_layout()
plt.savefig("confusion_matrix.png")
plt.close()
mlflow.log_artifact("confusion_matrix.png")
Pillar 7: Inference Acceleration (TFLite & Quantization)
- Problem: The raw
.kerasmodel (~13.6 MB) uses 32-bit floating point arithmetic, consuming unnecessary memory and adding latency to web endpoints. - Solution: Quantize the model to TensorFlow Lite FP16 / INT8:
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_types = [tf.float16]
tflite_model = converter.convert()
with open("models/flower_model_fp16.tflite", "wb") as f:
f.write(tflite_model)
- Serving Benefits:
- Model Size: Decreases from 13.6 MB to ~3.7 MB (73% reduction).
- Inference Latency: Drops from
45 ms down to **14 ms per image** on commodity CPUs. - Throughput: Significantly higher request concurrency in the FastAPI service.
Implementation Roadmap & Action Matrix
flowchart TD
subgraph Phase1["Phase 1: Quick Wins (1 Day)"]
P1A["Add Rescaling(1./127.5, offset=-1.0)"]
P1B["Add EarlyStopping (restore_best_weights=True)"]
P1C["Add ReduceLROnPlateau Callback"]
end
subgraph Phase2["Phase 2: High Impact (2-3 Days)"]
P2A["Implement 2-Stage Fine-Tuning"]
P2B["Log Confusion Matrix & Per-Class F1 to MLflow"]
P2C["Migrate to Dynamic Online Keras Augmentation"]
end
subgraph Phase3["Phase 3: Production Scaling (3-5 Days)"]
P3A["Benchmark EfficientNetV2-B0 via Hydra"]
P3B["Run Hyperparameter Sweeps (Dense Units, LR)"]
P3C["Export TFLite FP16 Model for FastAPI Serving"]
end
Phase1 --> Phase2
Phase2 --> Phase3
Action Item Matrix
| Priority | Action Item | Target File | Complexity | Expected Impact |
|---|---|---|---|---|
| P0 | Insert layers.Rescaling(1./127.5, offset=-1.0) |
src/flower_model.py |
Low | Immediate +5% to +8% accuracy boost |
| P0 | Add EarlyStopping & ReduceLROnPlateau callbacks |
src/flower_model.py |
Low | Eliminates overfitting and plateau stagnation |
| P1 | Implement two-stage fine-tuning (warmup + top layers) | src/flower_model.py |
Medium | Adapts convolutional filters to floral features |
| P1 | Replace disk augmentation with dynamic Keras layers | src/flower_data.py |
Medium | Frees 2.5 GB disk space; enables infinite variation |
| P1 | Log Confusion Matrix and classification reports to MLflow | src/flower_model.py |
Low | Provides actionable visibility into class confusion |
| P2 | Add EfficientNetV2 Hydra configuration |
conf/model/ |
Low | Provides modern architectural baseline |
| P2 | Export TFLite FP16 optimized weights | src/flower_model.py |
Low | 3x faster API responses in FastAPI serving |
- Downloads last month
- 99