Initial commit

.gitattributes

@@ -0,0 +1,6 @@
+*.keras filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.pdf filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,53 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# VS Code
+.vscode/
+
+# Models and large files (depending on your preference, uncomment if you don't want to push models)
+# models/*.h5
+# models/*.keras

README.md

@@ -0,0 +1,86 @@
+![logo_ironhack_blue 7](https://user-images.githubusercontent.com/23629340/40541063-a07a0a8a-601a-11e8-91b5-2f13e4e6b441.png)
+
+# Project I | Deep Learning: Image Classification with CNN
+
+## Task Description
+
+Students will build a Convolutional Neural Network (CNN) model to classify images from a given dataset into predefined categories/classes.
+
+## Datasets (pick one!)
+
+1. The dataset for this task is the CIFAR-10 dataset, which consists of 60,000 32x32 color images in 10 classes, with 6,000 images per class. You can download the dataset from [here](https://www.cs.toronto.edu/~kriz/cifar.html).
+2. The second dataset contains about 28,000 medium quality animal images belonging to 10 categories: dog, cat, horse, spyder, butterfly, chicken, sheep, cow, squirrel, elephant. The link is [here](https://www.kaggle.com/datasets/alessiocorrado99/animals10/data).
+
+## Assessment Components
+
+1. **Data Preprocessing**
+   - Data loading and preprocessing (e.g., normalization, resizing, augmentation).
+   - Create visualizations of some images, and labels.
+
+2. **Model Architecture**
+   - Design a CNN architecture suitable for image classification.
+   - Include convolutional layers, pooling layers, and fully connected layers.
+
+3. **Model Training**
+   - Train the CNN model using appropriate optimization techniques (e.g., stochastic gradient descent, Adam).
+   - Utilize techniques such as early stopping to prevent overfitting.
+
+4. **Model Evaluation**
+   - Evaluate the trained model on a separate validation set.
+   - Compute and report metrics such as accuracy, precision, recall, and F1-score.
+   - Visualize the confusion matrix to understand model performance across different classes.
+
+5. **Transfer Learning**
+    - Evaluate the accuracy of your model on a pre-trained models like ImagNet, VGG16, Inception... (pick one an justify your choice)
+        - You may find this [link](https://www.tensorflow.org/tutorials/images/transfer_learning_with_hub) helpful.
+        - [This](https://pytorch.org/tutorials/beginner/transfer_learning_tutorial.html) is the Pytorch version.
+    - Perform transfer learning with your chosen pre-trained models i.e., you will probably try a few and choose the best one.
+
+5. **Code Quality**
+   - Well-structured and commented code.
+   - Proper documentation of functions and processes.
+   - Efficient use of libraries and resources.
+
+6. **Report**
+   - Write a concise report detailing the approach taken, including:
+     - Description of the chosen CNN architecture.
+     - Explanation of preprocessing steps.
+     - Details of the training process (e.g., learning rate, batch size, number of epochs).
+     - Results and analysis of models performance.
+     - What is your best model. Why?
+     - Insights gained from the experimentation process.
+   - Include visualizations and diagrams where necessary.
+   
+ 7. **Model deployment**
+     - Pick the best model 
+     - Build an app using Flask - Can you host somewhere other than your laptop? **+5 Bonus points if you use [Tensorflow Serving](https://www.tensorflow.org/tfx/guide/serving)**
+     - User should be able to upload one or multiples images get predictions including probabilities for each prediction
+    
+
+## Evaluation Criteria
+
+- Accuracy of the trained models on the validation set. **30 points**
+- Clarity and completeness of the report. **20 points**
+- Quality of code implementation. **5 points**
+- Proper handling of data preprocessing and models training. **30 points**
+- Demonstration of understanding key concepts of deep learning. **5 points**
+- Model deployment. **10 points**
+
+ <span style="color:red; weight: bold">**Passing Score is 70 points**</span>.
+
+## Submission Details
+
+- Deadline for submission: end of the week or as communicated by your teaching team.
+- Submit the following:
+  1. Python code files (`*.py`, `ipynb`) containing the model implementation and training process.
+  2. A data folder with 5-10 images to test the deployed model/app if hosted somewhere else other than your laptop (strongly recommended! Not a must have)
+  2. A PDF report documenting the approach, results, and analysis.
+  3. Any additional files necessary for reproducing the results (e.g., requirements.txt, README.md).
+  4. PPT presentation
+
+## Additional Notes
+
+- Students are encourage to experiment with different architectures, hyper-parameters, and optimization techniques.
+- Provide guidance and resources for troubleshooting common issues during model training and evaluation.
+- Students will discuss their approaches and findings in class during assessment evaluation sessions.
+

REPORT.md

@@ -0,0 +1,253 @@
+# 📊 Project Report: CIFAR-10 Image Classification with CNN
+
+**Author:** Sebastian Lopez  
+**Date:** February 2026  
+**Environment:** Python 3.10 | TensorFlow 2.18.1 | Keras 3.6.0  
+**Dataset:** CIFAR-10 (60,000 images, 10 classes, 32×32 RGB)
+
+---
+
+## 1. Introduction
+
+This project builds and evaluates two deep learning models for classifying images from the CIFAR-10 dataset into 10 categories: airplane, automobile, bird, cat, deer, dog, frog, horse, ship, and truck.
+
+**Models developed:**
+1. **Custom CNN** — A purpose-built convolutional neural network
+2. **MobileNetV2 Transfer Learning** — Leveraging pretrained ImageNet features
+
+---
+
+## 2. Data Preprocessing
+
+### 2.1 Normalization
+All pixel values were scaled from [0, 255] to [0.0, 1.0] by dividing by 255. This ensures consistent gradient magnitudes during backpropagation.
+
+### 2.2 Label Encoding
+Integer labels (0–9) were one-hot encoded into 10-dimensional binary vectors using `keras.utils.to_categorical()`.
+
+### 2.3 Data Augmentation (Custom CNN only)
+Applied real-time augmentation during training to reduce overfitting:
+
+| Augmentation       | Range       |
+|:-------------------|:------------|
+| Rotation           | ±15°        |
+| Width/Height shift | ±10%        |
+| Horizontal flip    | Random      |
+| Zoom               | ±10%        |
+
+### 2.4 Dataset Split
+- **Training:** 45,000 images (90% of train set)
+- **Validation:** 5,000 images (10% of train set)
+- **Test:** 10,000 images (held-out)
+
+---
+
+## 3. Model Architectures
+
+### 3.1 Custom CNN
+
+A 3-block convolutional network designed specifically for 32×32 CIFAR-10 images:
+
+```
+Block 1: Conv2D(32) × 2 → BatchNorm → MaxPool(2×2) → Dropout(0.25)
+Block 2: Conv2D(64) × 2 → BatchNorm → MaxPool(2×2) → Dropout(0.25)
+Block 3: Conv2D(128) × 2 → BatchNorm → MaxPool(2×2) → Dropout(0.25)
+Head:    Flatten → Dense(256) → BatchNorm → Dropout(0.5) → Dense(10, softmax)
+```
+
+**Design rationale:**
+- Progressive filter increase captures increasingly complex features
+- BatchNormalization stabilizes training
+- Dropout at every block provides strong regularization
+- `padding='same'` preserves spatial dimensions within blocks
+
+### 3.2 MobileNetV2 Transfer Learning
+
+```
+Input(32×32×3) → UpSampling2D(3×) → MobileNetV2(frozen, ImageNet weights)
+→ GlobalAveragePooling2D → Dense(256) → Dropout(0.5) → Dense(10, softmax)
+```
+
+**Why MobileNetV2?**
+- **Efficient**: ~3.4M parameters — lightweight enough for CPU training
+- **Proven**: Excellent ImageNet accuracy despite small size
+- **Practical**: Faster to train than VGG16 (~138M params) or ResNet50 (~25M params)
+- **Upscaling**: 32×32 images are upscaled to 96×96 via UpSampling2D to meet MobileNetV2's minimum input requirements
+
+**Fine-tuning strategy:**
+1. Phase 1: Train only the classification head (base frozen, lr=0.001)
+2. Phase 2: Unfreeze top 20 layers of MobileNetV2, retrain with lr=0.0001
+
+---
+
+## 4. Training Configuration
+
+| Parameter         | Custom CNN | Transfer Learning |
+|:------------------|:-----------|:------------------|
+| Optimizer         | Adam       | Adam              |
+| Initial LR        | 0.001      | 0.001 → 0.0001   |
+| Batch size        | 64         | 64                |
+| Max epochs        | 100        | 50 + 30           |
+| Early stopping    | patience=10| patience=10/8     |
+| Data augmentation | Yes        | No (Phase 1)      |
+| LR reduction      | ×0.5 on plateau | ×0.5 on plateau |
+
+---
+
+## 5. Results
+
+### 5.1 Metrics Summary
+
+| Metric     | Custom CNN | MobileNetV2 TL |
+|:-----------|:-----------|:---------------|
+| Accuracy   | 0.8530 (85.30%) | 0.8340 (83.40%) |
+| Precision  | 0.8556          | 0.8353          |
+| Recall     | 0.8530          | 0.8340          |
+| F1-Score   | 0.8512          | 0.8339          |
+
+> **Note:** Run both training scripts to populate these results. The JSON outputs in `outputs/` contain the exact numbers.
+
+### 5.2 Training Curves
+- `outputs/custom_cnn_history.png` — Custom CNN accuracy and loss curves
+- `outputs/transfer_learning_history.png` — Transfer learning curves
+
+### 5.3 Confusion Matrices
+- `outputs/custom_cnn_cm.png` — Custom CNN confusion matrix
+- `outputs/transfer_learning_cm.png` — Transfer learning confusion matrix
+- `outputs/model_comparison.png` — Side-by-side metrics comparison
+
+### 5.4 Per-Class Confusion Analysis
+
+Both confusion matrices reveal systematic error patterns driven by visual similarity at 32×32 resolution:
+
+| Confusion Pair | Custom CNN Errors | MobileNetV2 Errors | Explanation |
+|:---------------|:-----------------:|:-------------------:|:------------|
+| **cat ↔ dog** | 198 | 256 | Both are furry, four-legged animals that share similar color palettes and body proportions at low resolution |
+| **bird ↔ frog** | 87 | 32 | Small subjects against green/natural backgrounds; at 32×32, both reduce to small colored blobs |
+| **automobile ↔ truck** | 82 | 107 | Both are wheeled vehicles with similar boxy shapes; the main discriminator (size) is lost at low resolution |
+| **airplane ↔ ship** | 49 | 85 | Both frequently appear against blue backgrounds (sky vs. water), confusing color-based features |
+
+**Key observation:** The cat class is the hardest to classify for both models (~65% accuracy), while frog, truck, and ship consistently achieve >90% accuracy. This suggests the model relies heavily on distinctive color patterns (green for frog, blue/gray for ship) rather than fine-grained shape features.
+
+See `outputs/misclassified_examples.png` for a visual sample of misclassifications.
+
+---
+
+## 6. Best Model Selection
+
+### 🏆 Winner: Custom CNN (85.3% accuracy)
+
+Lets see...
+
+## 7. Model Deployment
+
+The best model is deployed via a **Flask web application**:
+
+- **URL:** `http://localhost:5001`
+- **Port note:** Port 5001 is used instead of Flask's default 5000 because macOS Monterey (12+) reserves port 5000 for the AirPlay Receiver service
+- **Features:**
+  - Drag-and-drop or click-to-upload interface
+  - Supports single and multiple image uploads
+  - Displays top-10 predictions with probability bars
+  - API endpoint at `/api/predict` for programmatic access
+- **Preprocessing:** Uploaded images are resized to 32×32, normalized to [0,1]
+
+---
+
+## 8. Key Insights
+
+1. **Data augmentation significantly reduces overfitting** for the custom CNN, allowing it to train longer before early stopping triggers
+2. **Transfer learning with frozen base layers** converges faster but doesn't always outperform custom architectures — especially when the source domain (ImageNet, 224×224) differs significantly from the target (CIFAR-10, 32×32)
+3. **Fine-tuning** the top layers of MobileNetV2 with a reduced learning rate provides an additional accuracy boost but cannot fully overcome the resolution mismatch
+4. **Confusion matrix analysis** reveals that visually similar classes (cat/dog, automobile/truck) are the most commonly confused pairs — see Section 5.4
+5. **Batch normalization** between convolutional layers stabilizes training and allows higher learning rates
+
+## 9. Bias & Limitations
+
+### 9.1 Dataset Representation Bias (Geographic/Cultural)
+
+CIFAR-10 was collected from internet sources, predominantly Western/English-language websites. This introduces geographic bias in how each class is represented:
+
+| Class | Bias Example |
+|:------|:-------------|
+| **Automobile** | Mostly American/European car designs — the model may struggle with tuk-tuks, rickshaws, or vehicle types common in Asia and Africa |
+| **Truck** | Predominantly modern pickup and delivery trucks — would it recognize flatbed trucks from rural areas? |
+| **Ship** | Mostly large vessels in open water — canoes, kayaks, or fishing boats from other cultures are underrepresented |
+| **Horse** | Photographed primarily in Western contexts (ranches, paddocks) — horses in different cultural settings may confuse the model |
+| **Bird** | Heavily weighted toward North American bird species — tropical or exotic birds are underrepresented |
+
+### 9.2 Why This Matters
+
+1. **No geographic diversity audit**: The model learned to classify "an automobile as seen by English-speaking internet users in North America" — not a universal definition
+2. **Background/context bias**: Objects were photographed in typical contexts (planes in blue sky, ships in water). An airplane on a tarmac or a ship in dry dock would likely be harder to classify
+3. **Color/lighting bias**: Most photos were taken in daylight. Night images or unusual lighting conditions may significantly degrade performance
+4. **Resolution bias**: All images are compressed to 32×32, which means the model relies heavily on **color patterns and rough shapes** rather than fine details — this is itself a form of information loss bias
+
+### 9.3 Other Limitations
+
+- **Artificial class balance**: CIFAR-10 is perfectly balanced (6,000 per class), which is unrealistic — real-world data is almost never balanced
+- **Open-set recognition**: The model has no concept of "none of the above" — uploading an image of a banana will still produce a confident prediction for one of the 10 classes
+- **Temporal bias**: CIFAR-10 images are from a specific time period. Modern cars, ships, and trucks look different than those from when the dataset was compiled
+- **No cross-validation**: Results are based on a single train/validation/test split, which could introduce variance
+
+---
+
+## 10. Folder Structure
+
+```
+project-1-deep-learning-image-classification-with-cnn/
+├── README.md                           ← Project brief
+├── requirements.txt                    ← Dependencies (pinned versions)
+├── Dockerfile                          ← Docker container config
+├── .gitignore                          ← Git ignore rules
+├── Report/                             ← Documentation & presentation
+│   ├── REPORT.md                       ← This report
+│   ├── CIFAR10_Image_Classification_CNN.ipynb       ← Full notebook
+│   └── CIFAR10_Image_Classification_CNN_Presentation.ipynb  ← Slide deck
+├── src/                                ← Source modules
+│   ├── data_loader.py
+│   ├── model_builder.py
+│   ├── train.py
+│   └── evaluate.py
+├── notebooks/                          ← Executable pipeline scripts
+│   ├── 01_data_exploration.py
+│   ├── 02_custom_cnn.py
+│   ├── 03_transfer_learning_cpu.py     ← CPU-optimized (pre-resize with cv2)
+│   ├── 03_transfer_learning_gpu.py     ← GPU version (UpSampling2D in graph)
+│   ├── 04_model_comparison.py          ← Compare both models
+│   ├── 05_deploy.py                    ← Launch Flask app (port 5001)
+│   └── 06_misclassifications.py        ← Generate misclassification examples
+├── app/                                ← Flask web application
+│   ├── app.py
+│   ├── templates/index.html
+│   └── static/style.css
+├── models/                             ← Saved trained models (.keras)
+├── outputs/                            ← Plots, metrics, reports
+├── test_images/                        ← Sample images for testing the app
+└── Other documentation/                ← Learning guides & extra docs
+```
+
+---
+
+## 10. How to Run
+
+```bash
+# 1. Install dependencies
+conda activate ironhack.nn
+
+# 2. Explore the data
+python notebooks/01_data_exploration.py
+
+# 3. Train the custom CNN
+python notebooks/02_custom_cnn.py
+
+# 4. Train with transfer learning (CPU version — pre-resizes images with cv2)
+python notebooks/03_transfer_learning_cpu.py
+
+# 5. Compare both models
+python notebooks/04_model_comparison.py
+
+# 6. Launch the Flask app (port 5001 — macOS reserves 5000 for AirPlay)
+python notebooks/05_deploy.py
+# → Open http://localhost:5001
+```

app/app.py

@@ -0,0 +1,218 @@
+"""
+Flask Web Application for CIFAR-10 Image Classification.
+
+This app allows users to upload one or multiple images and receive
+predictions with class probabilities from the best trained model.
+
+Usage:
+    conda run -n ironhack.nn python app/app.py
+
+Then navigate to http://localhost:5001 in your browser.
+(Port 5001 is used because macOS Monterey+ reserves 5000 for AirPlay.)
+"""
+
+import os
+import sys
+import json
+import numpy as np
+from flask import Flask, request, render_template, jsonify
+from PIL import Image
+import io
+
+# Add project root to path so we can import our modules
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from src.data_loader import CLASS_NAMES
+
+# TensorFlow / Keras imports
+from keras.api.models import load_model
+from keras.api.utils import img_to_array
+
+# ── Configuration ───────────────────────────────────────────────
+PROJECT_ROOT = os.path.join(os.path.dirname(__file__), '..')
+
+# Try to load the best model (transfer learning first, then custom CNN)
+TRANSFER_MODEL_PATH = os.path.join(PROJECT_ROOT, 'models', 'transfer_learning.keras')
+CUSTOM_MODEL_PATH = os.path.join(PROJECT_ROOT, 'models', 'custom_cnn.keras')
+
+app = Flask(__name__)
+app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16 MB max upload
+
+# Global models dictionary
+models = {}
+default_model_name = None
+
+
+def load_all_models():
+    """Load both Custom CNN and MobileNetV2 models."""
+    global models, default_model_name
+
+    if os.path.exists(TRANSFER_MODEL_PATH):
+        models['transfer'] = {
+            'model': load_model(TRANSFER_MODEL_PATH),
+            'name': 'MobileNetV2 Transfer Learning'
+        }
+        print(f"✅ Loaded model: {models['transfer']['name']}")
+        default_model_name = 'transfer'
+
+    if os.path.exists(CUSTOM_MODEL_PATH):
+        models['custom'] = {
+            'model': load_model(CUSTOM_MODEL_PATH),
+            'name': 'Custom CNN'
+        }
+        print(f"✅ Loaded model: {models['custom']['name']}")
+        default_model_name = 'custom'
+
+    if not models:
+        print("⚠️  No trained models found! Please run training scripts first.")
+        default_model_name = None
+
+
+def preprocess_image(image_bytes):
+    """
+    Preprocess a single uploaded image for prediction.
+
+    Steps:
+    1. Open and convert to RGB
+    2. Resize to 32x32 (CIFAR-10 input size)
+    3. Normalize pixel values to [0, 1]
+    4. Add batch dimension
+
+    Args:
+        image_bytes: Raw image bytes from upload.
+
+    Returns:
+        numpy array of shape (1, 32, 32, 3), float32, normalized.
+    """
+    img = Image.open(io.BytesIO(image_bytes)).convert('RGB')
+    img = img.resize((32, 32))
+    img_array = img_to_array(img) / 255.0
+    img_array = np.expand_dims(img_array, axis=0)
+    return img_array
+
+
+def get_predictions(img_array, model_choice, top_n=5):
+    """
+    Get top-N class predictions with probabilities.
+
+    Args:
+        img_array: Preprocessed image array (1, 32, 32, 3).
+        model_choice: String key selecting which model to use ('custom' or 'transfer').
+        top_n: Number of top predictions to return.
+
+    Returns:
+        list of dicts: [{'class': str, 'probability': float}, ...]
+    """
+    if not models or model_choice not in models:
+        return [{'class': 'No model loaded', 'probability': 0.0}]
+
+    selected_model = models[model_choice]['model']
+    predictions = selected_model.predict(img_array, verbose=0)[0]
+    top_indices = predictions.argsort()[-top_n:][::-1]
+
+    results = []
+    for idx in top_indices:
+        results.append({
+            'class': CLASS_NAMES[idx],
+            'probability': float(predictions[idx])
+        })
+    return results
+
+
+# ── Routes ──────────────────────────────────────────────────────
+
+@app.route('/')
+def index():
+    """Render the main upload page."""
+    current_model = models.get(default_model_name, {}).get('name', 'Loading...') if default_model_name else 'No model loaded'
+    return render_template('index.html', model_name=current_model)
+
+
+@app.route('/predict', methods=['POST'])
+def predict():
+    """
+    Handle image upload(s) and return predictions.
+
+    Accepts single or multiple files via the 'files' form field.
+    Returns JSON with predictions for each uploaded image.
+    """
+    if 'files' not in request.files:
+        return jsonify({'error': 'No files uploaded'}), 400
+
+    files = request.files.getlist('files')
+    if not files or all(f.filename == '' for f in files):
+        return jsonify({'error': 'No files selected'}), 400
+
+    model_choice = request.form.get('model_choice', default_model_name)
+    all_results = []
+
+    for file in files:
+        if file.filename == '':
+            continue
+
+        try:
+            image_bytes = file.read()
+            img_array = preprocess_image(image_bytes)
+            predictions = get_predictions(img_array, model_choice, top_n=10)
+
+            all_results.append({
+                'filename': file.filename,
+                'predictions': predictions
+            })
+        except Exception as e:
+            all_results.append({
+                'filename': file.filename,
+                'error': str(e)
+            })
+
+    current_model_name = models.get(model_choice, {}).get('name', 'Unknown Model')
+
+    return render_template('index.html',
+                           model_name=current_model_name,
+                           selected_model=model_choice,
+                           results=all_results)
+
+
+@app.route('/api/predict', methods=['POST'])
+def api_predict():
+    """
+    API endpoint: returns JSON predictions (for programmatic access).
+    """
+    if 'files' not in request.files:
+        return jsonify({'error': 'No files uploaded'}), 400
+
+    files = request.files.getlist('files')
+    model_choice = request.form.get('model_choice', default_model_name)
+    current_model_name = models.get(model_choice, {}).get('name', 'Unknown Model')
+    
+    all_results = []
+
+    for file in files:
+        if file.filename == '':
+            continue
+        try:
+            image_bytes = file.read()
+            img_array = preprocess_image(image_bytes)
+            predictions = get_predictions(img_array, model_choice, top_n=10)
+            all_results.append({
+                'filename': file.filename,
+                'predictions': predictions
+            })
+        except Exception as e:
+            all_results.append({
+                'filename': file.filename,
+                'error': str(e)
+            })
+
+    return jsonify({'model': current_model_name, 'results': all_results})
+
+
+# ── Main ────────────────────────────────────────────────────────
+
+if __name__ == '__main__':
+    load_all_models()
+    port = int(os.environ.get('PORT', 5001))
+    print(f"\n 🚀 Starting Flask app at http://localhost:{port}")
+    print(f"   Available Models: {', '.join([m['name'] for m in models.values()])}")
+    print(f"   Classes: {', '.join(CLASS_NAMES)}")
+    app.run(host='0.0.0.0', port=port, debug=True)

app/static/style.css

@@ -0,0 +1,397 @@
+/* ═══════════════════════════════════════════════════════════
+   CIFAR-10 Image Classifier — Flask App Styles
+   Modern, premium design with glassmorphism and gradients
+   ═══════════════════════════════════════════════════════════ */
+
+:root {
+    --primary: #6C5CE7;
+    --primary-light: #A29BFE;
+    --secondary: #B388FF;
+    --accent: #CE93D8;
+    --grape: #7C4DFF;
+    --grape-light: #B47CFF;
+    --grape-glow: rgba(124, 77, 255, 0.25);
+    --bg-dark: #0c0c1d;
+    --bg-card: rgba(255, 255, 255, 0.05);
+    --bg-card-hover: rgba(255, 255, 255, 0.08);
+    --text: #E8E8F0;
+    --text-muted: #9B9BB0;
+    --border: rgba(255, 255, 255, 0.08);
+    --shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
+    --radius: 16px;
+    --radius-sm: 8px;
+    --section-gap: 40px;
+}
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+    background: var(--bg-dark);
+    background-image:
+        radial-gradient(ellipse at 20% 50%, rgba(108, 92, 231, 0.15) 0%, transparent 50%),
+        radial-gradient(ellipse at 80% 20%, rgba(124, 77, 255, 0.10) 0%, transparent 50%),
+        radial-gradient(ellipse at 50% 80%, rgba(179, 136, 255, 0.08) 0%, transparent 50%);
+    color: var(--text);
+    min-height: 100vh;
+    line-height: 1.6;
+}
+
+.container {
+    max-width: 800px;
+    margin: 0 auto;
+    padding: 40px 20px;
+}
+
+/* ─── Header ──────────────────────────────────────────── */
+
+.header {
+    text-align: center;
+    margin-bottom: var(--section-gap);
+}
+
+.logo {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    margin-bottom: var(--section-gap);
+}
+
+.header h1 {
+    font-size: 2rem;
+    font-weight: 700;
+    background: linear-gradient(135deg, var(--primary-light), var(--grape-light));
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+}
+
+.subtitle {
+    color: var(--text-muted);
+    font-size: 0.95rem;
+    margin-bottom: 16px;
+}
+
+.model-badge {
+    display: inline-block;
+    background: linear-gradient(135deg, var(--primary), var(--grape));
+    color: white;
+    padding: 2px 12px;
+    border-radius: 20px;
+    font-size: 0.85rem;
+    font-weight: 600;
+}
+
+.class-tags {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 10px;
+    margin-top: 0;
+}
+
+.tags-row {
+    display: flex;
+    justify-content: center;
+    gap: 8px;
+    flex-wrap: wrap;
+}
+
+.tag {
+    background: rgba(124, 77, 255, 0.08);
+    border: 1px solid rgba(124, 77, 255, 0.2);
+    padding: 4px 12px;
+    border-radius: 20px;
+    font-size: 0.8rem;
+    color: var(--primary-light);
+    transition: all 0.2s ease;
+}
+
+.tag:hover {
+    background: rgba(124, 77, 255, 0.15);
+    color: var(--text);
+    border-color: var(--grape);
+    transform: translateY(-1px);
+    box-shadow: 0 2px 12px var(--grape-glow);
+}
+
+/* ─── Model Selection ────────────────────────────────── */
+
+.model-selection {
+    margin-bottom: var(--section-gap);
+    text-align: center;
+}
+
+.model-label {
+    font-weight: 500;
+    font-size: 13px;
+    color: var(--text-muted);
+    margin-right: 8px;
+}
+
+.model-select {
+    padding: 5px 10px;
+    border-radius: 6px;
+    border: 1px solid var(--grape);
+    background: rgba(124, 77, 255, 0.08);
+    backdrop-filter: blur(10px);
+    color: var(--text);
+    font-family: inherit;
+    font-size: 13px;
+    cursor: pointer;
+    outline: none;
+    transition: all 0.2s ease;
+}
+
+.model-select:hover {
+    border-color: var(--grape-light);
+    box-shadow: 0 0 0 2px var(--grape-glow);
+}
+
+.model-select:focus {
+    border-color: var(--grape-light);
+    box-shadow: 0 0 0 2px var(--grape-glow);
+}
+
+/* ─── Upload Section ──────────────────────────────────── */
+
+.upload-section {
+    margin-bottom: var(--section-gap);
+}
+
+.dropzone {
+    background: var(--bg-card);
+    border: 2px dashed var(--border);
+    border-radius: var(--radius);
+    padding: 35px 20px;
+    text-align: center;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    position: relative;
+}
+
+.dropzone:hover,
+.dropzone.dragover {
+    border-color: var(--grape);
+    background: rgba(124, 77, 255, 0.08);
+    transform: translateY(-2px);
+    box-shadow: 0 8px 24px var(--grape-glow);
+}
+
+.dropzone-icon {
+    font-size: 3rem;
+    display: block;
+    margin-bottom: 12px;
+}
+
+.dropzone-text {
+    font-size: 1.1rem;
+    font-weight: 500;
+    color: var(--text);
+}
+
+.dropzone-subtext {
+    font-size: 0.85rem;
+    color: var(--text-muted);
+    margin-top: 4px;
+}
+
+.file-input {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    opacity: 0;
+    cursor: pointer;
+}
+
+.file-list {
+    margin-top: 12px;
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+}
+
+.file-item {
+    background: var(--bg-card);
+    padding: 8px 16px;
+    border-radius: var(--radius-sm);
+    font-size: 0.85rem;
+    color: var(--text-muted);
+    border: 1px solid var(--border);
+}
+
+.submit-btn {
+    display: block;
+    width: 100%;
+    margin-top: 20px;
+    padding: 16px;
+    font-size: 1.1rem;
+    font-weight: 600;
+    font-family: 'Inter', sans-serif;
+    color: white;
+    background: linear-gradient(135deg, var(--primary), var(--grape));
+    border: none;
+    border-radius: var(--radius-sm);
+    cursor: pointer;
+    transition: all 0.3s ease;
+    box-shadow: 0 4px 16px var(--grape-glow);
+}
+
+.submit-btn:hover:not(:disabled) {
+    transform: translateY(-2px);
+    box-shadow: 0 6px 24px rgba(124, 77, 255, 0.4);
+}
+
+.submit-btn:disabled {
+    opacity: 0.4;
+    cursor: not-allowed;
+}
+
+.btn-icon {
+    margin-right: 6px;
+}
+
+/* ─── Results Section ─────────────────────────────────── */
+
+.results-section {
+    margin-bottom: var(--section-gap);
+}
+
+.results-title {
+    font-size: 1.4rem;
+    font-weight: 600;
+    margin-bottom: 24px;
+    text-align: center;
+}
+
+.result-card {
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 24px;
+    margin-bottom: 20px;
+    backdrop-filter: blur(10px);
+    box-shadow: var(--shadow);
+    transition: transform 0.2s ease;
+}
+
+.result-card:hover {
+    transform: translateY(-2px);
+}
+
+.result-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 16px;
+    padding-bottom: 12px;
+    border-bottom: 1px solid var(--border);
+    flex-wrap: wrap;
+    gap: 8px;
+}
+
+.filename {
+    font-weight: 500;
+    font-size: 0.95rem;
+}
+
+.top-prediction {
+    background: linear-gradient(135deg, rgba(124, 77, 255, 0.15), rgba(179, 136, 255, 0.05));
+    border: 1px solid rgba(124, 77, 255, 0.3);
+    color: var(--grape-light);
+    padding: 4px 14px;
+    border-radius: 20px;
+    font-size: 0.85rem;
+}
+
+.predictions {
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+}
+
+.prediction-row {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+}
+
+.pred-class {
+    width: 100px;
+    font-size: 0.9rem;
+    font-weight: 500;
+    text-align: right;
+    color: var(--text-muted);
+}
+
+.prob-bar-container {
+    flex: 1;
+    height: 24px;
+    background: rgba(255, 255, 255, 0.04);
+    border-radius: 12px;
+    overflow: hidden;
+    position: relative;
+}
+
+.prob-bar {
+    height: 100%;
+    background: linear-gradient(90deg, var(--primary), var(--grape));
+    border-radius: 12px;
+    min-width: 2px;
+    transition: width 0.8s ease;
+}
+
+.pred-prob {
+    width: 60px;
+    font-size: 0.85rem;
+    font-weight: 600;
+    color: var(--primary-light);
+    text-align: right;
+}
+
+.error-msg {
+    color: #ef9a9a;
+    padding: 12px;
+    background: rgba(239, 154, 154, 0.1);
+    border-radius: var(--radius-sm);
+    border: 1px solid rgba(239, 154, 154, 0.2);
+}
+
+/* ─── Footer ──────────────────────────────────────────── */
+
+.footer {
+    text-align: center;
+    padding-top: var(--section-gap);
+    margin-top: var(--section-gap);
+    border-top: 1px solid rgba(124, 77, 255, 0.15);
+    color: var(--text-muted);
+    font-size: 0.85rem;
+}
+
+/* ─── Responsive ──────────────────────────────────────── */
+
+@media (max-width: 600px) {
+    .header h1 {
+        font-size: 1.5rem;
+    }
+
+    .result-header {
+        flex-direction: column;
+        align-items: flex-start;
+    }
+
+    .pred-class {
+        width: 80px;
+        font-size: 0.8rem;
+    }
+
+    .dropzone {
+        padding: 30px 16px;
+    }
+}

app/templates/index.html

@@ -0,0 +1,163 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta name="description"
+        content="CIFAR-10 Image Classification — Upload images to classify them into 10 categories using a deep learning CNN model.">
+    <title>CIFAR-10 Image Classifier</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet">
+</head>
+
+<body>
+    <div class="container">
+        <!-- Header -->
+        <header class="header">
+            <div class="logo">
+                <h1>CIFAR-10 Image Classifier</h1>
+            </div>
+
+            <div class="class-tags">
+                <div class="tags-row tags-row-4">
+                    <span class="tag">✈️ Airplane</span>
+                    <span class="tag">🚗 Automobile</span>
+                    <span class="tag">🚢 Ship</span>
+                    <span class="tag">🚚 Truck</span>
+                </div>
+                <div class="tags-row tags-row-6">
+                    <span class="tag">🐦 Bird</span>
+                    <span class="tag">🐱 Cat</span>
+                    <span class="tag">🦌 Deer</span>
+                    <span class="tag">🐕 Dog</span>
+                    <span class="tag">🐸 Frog</span>
+                    <span class="tag">🐴 Horse</span>
+                </div>
+            </div>
+        </header>
+
+        <!-- Upload Form -->
+        <section class="upload-section">
+            <form action="/predict" method="POST" enctype="multipart/form-data" id="uploadForm">
+                <div class="model-selection">
+                    <label for="modelChoice" class="model-label">🧠 Choose Model:</label>
+                    <select name="model_choice" id="modelChoice" class="model-select">
+                        <option value="custom" {% if selected_model=='custom' %}selected{% endif %}>CNN Model (Custom)
+                        </option>
+                        <option value="transfer" {% if selected_model=='transfer' %}selected{% endif %}>MobileNetV2
+                            (Transfer Learning)</option>
+                    </select>
+                </div>
+
+                <div class="dropzone" id="dropzone">
+                    <div class="dropzone-content">
+                        <span class="dropzone-icon">📸</span>
+                        <p class="dropzone-text">Drag & drop images here</p>
+                        <p class="dropzone-subtext">or click to browse — supports multiple files</p>
+                    </div>
+                    <input type="file" name="files" id="fileInput" multiple accept="image/*" class="file-input">
+                </div>
+
+                <div class="file-list" id="fileList"></div>
+                <button type="submit" class="submit-btn" id="submitBtn" disabled>
+                    <span class="btn-icon">🔍</span> Classify Images
+                </button>
+            </form>
+        </section>
+
+        <!-- Results -->
+        {% if results %}
+        <section class="results-section">
+            <h2 class="results-title">🎯 Classification Results</h2>
+
+            {% for result in results %}
+            <div class="result-card">
+                <div class="result-header">
+                    <span class="filename">📄 {{ result.filename }}</span>
+                    {% if result.predictions %}
+                    <span class="top-prediction">
+                        Best: <strong>{{ result.predictions[0].class | capitalize }}</strong>
+                        ({{ "%.1f" | format(result.predictions[0].probability * 100) }}%)
+                    </span>
+                    {% endif %}
+                </div>
+
+                {% if result.error %}
+                <div class="error-msg">⚠️ Error: {{ result.error }}</div>
+                {% else %}
+                <div class="predictions">
+                    {% for pred in result.predictions %}
+                    <div class="prediction-row">
+                        <span class="pred-class">{{ pred.class | capitalize }}</span>
+                        <div class="prob-bar-container">
+                            <div class="prob-bar" style="width: {{ (pred.probability * 100) | round(1) }}%"></div>
+                        </div>
+                        <span class="pred-prob">{{ "%.1f" | format(pred.probability * 100) }}%</span>
+                    </div>
+                    {% endfor %}
+                </div>
+                {% endif %}
+            </div>
+            {% endfor %}
+        </section>
+        {% endif %}
+
+        <!-- Footer -->
+        <footer class="footer">
+            <p>Ironhack — Deep Learning Project | CNN Image Classification with CIFAR-10</p>
+        </footer>
+    </div>
+
+    <script>
+        // ─── Drag & Drop + File List ────────────────────
+        const dropzone = document.getElementById('dropzone');
+        const fileInput = document.getElementById('fileInput');
+        const fileList = document.getElementById('fileList');
+        const submitBtn = document.getElementById('submitBtn');
+
+        dropzone.addEventListener('click', () => fileInput.click());
+
+        dropzone.addEventListener('dragover', (e) => {
+            e.preventDefault();
+            dropzone.classList.add('dragover');
+        });
+
+        dropzone.addEventListener('dragleave', () => {
+            dropzone.classList.remove('dragover');
+        });
+
+        dropzone.addEventListener('drop', (e) => {
+            e.preventDefault();
+            dropzone.classList.remove('dragover');
+            fileInput.files = e.dataTransfer.files;
+            updateFileList();
+        });
+
+        fileInput.addEventListener('change', updateFileList);
+
+        function updateFileList() {
+            fileList.innerHTML = '';
+            const files = fileInput.files;
+            if (files.length > 0) {
+                submitBtn.disabled = false;
+                for (let f of files) {
+                    const div = document.createElement('div');
+                    div.className = 'file-item';
+                    div.textContent = `📎 ${f.name} (${(f.size / 1024).toFixed(1)} KB)`;
+                    fileList.appendChild(div);
+                }
+            } else {
+                submitBtn.disabled = true;
+            }
+        }
+
+        // ─── Submit loading state ────────────────────────
+        document.getElementById('uploadForm').addEventListener('submit', function () {
+            submitBtn.disabled = true;
+            submitBtn.innerHTML = '<span class="btn-icon">⏳</span> Classifying...';
+        });
+    </script>
+</body>
+
+</html>

models/custom_cnn.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6da05a207a55bbd1ba43269fc7094bb3bb1aa3199c4448bca009a85b78b8a3ad
+size 9902170

models/transfer_learning.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5516031beafea75d838dc61097ee0bd08eef101f2e9c661495f512ab15cac7e5
+size 19458191

notebooks_knowledge&presentation/.In_cloud_transferlearning_gpu_options.md

@@ -0,0 +1,49 @@
+# Transfer Learning: GPU Cloud Options
+
+When performing Transfer Learning (like using MobileNetV2 or VGG16) on the CIFAR-10 dataset, training can be extremely slow on a local CPU (up to 20-25 hours). 
+
+To speed up the process to just minutes, you have several excellent free cloud-based GPU options, as well as a strategy to optimize your local CPU training.
+
+---
+
+## 🥇 Option 1: Google Colab (FREE, easiest, recommended)
+Run your notebook on Google's free T4/V100 GPU in the cloud.
+
+1. Go to [colab.research.google.com](https://colab.research.google.com/)
+2. Upload your `.ipynb` notebook or paste your code.
+3. Set **Runtime → Change runtime type → T4 GPU**
+4. *Result:* What takes 20h on your CPU takes ~8 minutes on a Colab GPU ✅
+5. *Cost:* Free (with limits), or ~$10/month for Colab Pro if you need more compute.
+
+---
+
+## 🥈 Option 2: Kaggle Notebooks (FREE, 30h GPU/week)
+Run notebooks directly on Kaggle with free GPU access.
+
+1. Go to [kaggle.com/code](https://www.kaggle.com/code)
+2. CIFAR-10 is even available as a built-in Kaggle dataset, making data loading instant.
+3. Very similar interface to Colab, with zero setup required.
+4. *Result:* Free T4 GPU, 30 hours/week allowance.
+5. *Cost:* Free.
+
+---
+
+## 🥉 Option 3: Fix the Script to Run Reasonably Fast on Your CPU
+If you must run locally, you can optimize the CPU performance by resizing the data *before* training and reducing epochs.
+
+| Configuration | Estimated Time on Your Local CPU |
+|---|---|
+| Current script (as-is) | 20–25 hours ❌ |
+| After optimization (pre-resize + fewer epochs) | ~30–60 minutes ✅ |
+
+*Note: The optimized CPU approach is included in the Presentation Notebook.*
+
+---
+
+## 🏅 Option 4: Lightning.ai (Free Cloud GPU)
+Lightning Studios provides free GPU compute in a full notebook/IDE environment.
+
+1. Go to [lightning.ai](https://lightning.ai/)
+2. Spin up a free Studio.
+3. Offers a more generous free tier and advanced environment compared to standard Colab.
+4. *Cost:* Free tier available.

notebooks_knowledge&presentation/EXTRA Transfer Learning II.ipynb

@@ -0,0 +1,1049 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "hRTa3Ee15WsJ"
+   },
+   "source": [
+    "# Transfer learning and fine-tuning"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "dQHMcypT3vDT"
+   },
+   "source": [
+    "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
+    "  <td>\n",
+    "    <a target=\"_blank\" href=\"https://www.tensorflow.org/tutorials/images/transfer_learning\"><img src=\"https://www.tensorflow.org/images/tf_logo_32px.png\" />View on TensorFlow.org</a>\n",
+    "  </td>\n",
+    "  <td>\n",
+    "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/docs/blob/master/site/en/tutorials/images/transfer_learning.ipynb?force_kitty_mode=1&force_corgi_mode=1\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n",
+    "  </td>\n",
+    "  <td>\n",
+    "    <a target=\"_blank\" href=\"https://github.com/tensorflow/docs/blob/master/site/en/tutorials/images/transfer_learning.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View source on GitHub</a>\n",
+    "  </td>\n",
+    "  <td>\n",
+    "    <a href=\"https://storage.googleapis.com/tensorflow_docs/docs/site/en/tutorials/images/transfer_learning.ipynb\"><img src=\"https://www.tensorflow.org/images/download_logo_32px.png\" />Download notebook</a>\n",
+    "  </td>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "2X4KyhORdSeO"
+   },
+   "source": [
+    "In this tutorial, you will learn how to classify images of cats and dogs by using transfer learning from a pre-trained network.\n",
+    "\n",
+    "A pre-trained model is a saved network that was previously trained on a large dataset, typically on a large-scale image-classification task. You either use the pretrained model as is or use transfer learning to customize this model to a given task.\n",
+    "\n",
+    "The intuition behind transfer learning for image classification is that if a model is trained on a large and general enough dataset, this model will effectively serve as a generic model of the visual world. You can then take advantage of these learned feature maps without having to start from scratch by training a large model on a large dataset.\n",
+    "\n",
+    "In this notebook, you will try two ways to customize a pretrained model:\n",
+    "\n",
+    "1. Feature Extraction: Use the representations learned by a previous network to extract meaningful features from new samples. You simply add a new classifier, which will be trained from scratch, on top of the pretrained model so that you can repurpose the feature maps learned previously for the dataset.\n",
+    "\n",
+    " You do not need to (re)train the entire model. The base convolutional network already contains features that are generically useful for classifying pictures. However, the final, classification part of the pretrained model is specific to the original classification task, and subsequently specific to the set of classes on which the model was trained.\n",
+    "\n",
+    "1. Fine-Tuning: Unfreeze a few of the top layers of a frozen model base and jointly train both the newly-added classifier layers and the last layers of the base model. This allows us to \"fine-tune\" the higher-order feature representations in the base model in order to make them more relevant for the specific task.\n",
+    "\n",
+    "You will follow the general machine learning workflow.\n",
+    "\n",
+    "1. Examine and understand the data\n",
+    "1. Build an input pipeline, in this case using Keras ImageDataGenerator\n",
+    "1. Compose the model\n",
+    "   * Load in the pretrained base model (and pretrained weights)\n",
+    "   * Stack the classification layers on top\n",
+    "1. Train the model\n",
+    "1. Evaluate model\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "TqOt6Sv7AsMi"
+   },
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import os\n",
+    "import tensorflow as tf"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "v77rlkCKW0IJ"
+   },
+   "source": [
+    "## Data preprocessing"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "0GoKGm1duzgk"
+   },
+   "source": [
+    "### Data download"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "vHP9qMJxt2oz"
+   },
+   "source": [
+    "In this tutorial, you will use a dataset containing several thousand images of cats and dogs. Download and extract a zip file containing the images, then create a `tf.data.Dataset` for training and validation using the `tf.keras.utils.image_dataset_from_directory` utility. You can learn more about loading images in this [tutorial](https://www.tensorflow.org/tutorials/load_data/images)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ro4oYaEmxe4r"
+   },
+   "outputs": [],
+   "source": [
+    "_URL = 'https://storage.googleapis.com/mledu-datasets/cats_and_dogs_filtered.zip'\n",
+    "path_to_zip = tf.keras.utils.get_file('cats_and_dogs.zip', origin=_URL, extract=True)\n",
+    "PATH = os.path.join(os.path.dirname(path_to_zip), 'cats_and_dogs_filtered')\n",
+    "\n",
+    "train_dir = os.path.join(PATH, 'train')\n",
+    "validation_dir = os.path.join(PATH, 'validation')\n",
+    "\n",
+    "BATCH_SIZE = 32\n",
+    "IMG_SIZE = (160, 160)\n",
+    "\n",
+    "train_dataset = tf.keras.utils.image_dataset_from_directory(train_dir,\n",
+    "                                                            shuffle=True,\n",
+    "                                                            batch_size=BATCH_SIZE,\n",
+    "                                                            image_size=IMG_SIZE)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "cAvtLwi7_J__"
+   },
+   "outputs": [],
+   "source": [
+    "validation_dataset = tf.keras.utils.image_dataset_from_directory(validation_dir,\n",
+    "                                                                 shuffle=True,\n",
+    "                                                                 batch_size=BATCH_SIZE,\n",
+    "                                                                 image_size=IMG_SIZE)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "yO1Q2JaW5sIy"
+   },
+   "source": [
+    "Show the first nine images and labels from the training set:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "K5BeQyKThC_Y"
+   },
+   "outputs": [],
+   "source": [
+    "class_names = train_dataset.class_names\n",
+    "\n",
+    "plt.figure(figsize=(10, 10))\n",
+    "for images, labels in train_dataset.take(1):\n",
+    "  for i in range(9):\n",
+    "    ax = plt.subplot(3, 3, i + 1)\n",
+    "    plt.imshow(images[i].numpy().astype(\"uint8\"))\n",
+    "    plt.title(class_names[labels[i]])\n",
+    "    plt.axis(\"off\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "EZqCX_mpV3Mx"
+   },
+   "source": [
+    "As the original dataset doesn't contain a test set, you will create one. To do so, determine how many batches of data are available in the validation set using `tf.data.experimental.cardinality`, then move 20% of them to a test set."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "uFFIYrTFV9RO"
+   },
+   "outputs": [],
+   "source": [
+    "val_batches = tf.data.experimental.cardinality(validation_dataset)\n",
+    "test_dataset = validation_dataset.take(val_batches // 5)\n",
+    "validation_dataset = validation_dataset.skip(val_batches // 5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Q9pFlFWgBKgH"
+   },
+   "outputs": [],
+   "source": [
+    "print('Number of validation batches: %d' % tf.data.experimental.cardinality(validation_dataset))\n",
+    "print('Number of test batches: %d' % tf.data.experimental.cardinality(test_dataset))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "MakSrdd--RKg"
+   },
+   "source": [
+    "### Configure the dataset for performance"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "22XWC7yjkZu4"
+   },
+   "source": [
+    "Use buffered prefetching to load images from disk without having I/O become blocking. To learn more about this method see the [data performance](https://www.tensorflow.org/guide/data_performance) guide."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "p3UUPdm86LNC"
+   },
+   "outputs": [],
+   "source": [
+    "AUTOTUNE = tf.data.AUTOTUNE\n",
+    "\n",
+    "train_dataset = train_dataset.prefetch(buffer_size=AUTOTUNE)\n",
+    "validation_dataset = validation_dataset.prefetch(buffer_size=AUTOTUNE)\n",
+    "test_dataset = test_dataset.prefetch(buffer_size=AUTOTUNE)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "MYfcVwYLiR98"
+   },
+   "source": [
+    "### Use data augmentation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "bDWc5Oad1daX"
+   },
+   "source": [
+    "When you don't have a large image dataset, it's a good practice to artificially introduce sample diversity by applying random, yet realistic, transformations to the training images, such as rotation and horizontal flipping. This helps expose the model to different aspects of the training data and reduce [overfitting](https://www.tensorflow.org/tutorials/keras/overfit_and_underfit). You can learn more about data augmentation in this [tutorial](https://www.tensorflow.org/tutorials/images/data_augmentation)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "3P99QiMGit1A"
+   },
+   "outputs": [],
+   "source": [
+    "data_augmentation = tf.keras.Sequential([\n",
+    "  tf.keras.layers.RandomFlip('horizontal'),\n",
+    "  tf.keras.layers.RandomRotation(0.2),\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "s9SlcbhrarOO"
+   },
+   "source": [
+    "Note: These layers are active only during training, when you call `Model.fit`. They are inactive when the model is used in inference mode in `Model.evaluate`, `Model.predict`, or `Model.call`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "9mD3rE2Lm7-d"
+   },
+   "source": [
+    "Let's repeatedly apply these layers to the same image and see the result."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "aQullOUHkm67"
+   },
+   "outputs": [],
+   "source": [
+    "for image, _ in train_dataset.take(1):\n",
+    "  plt.figure(figsize=(10, 10))\n",
+    "  first_image = image[0]\n",
+    "  for i in range(9):\n",
+    "    ax = plt.subplot(3, 3, i + 1)\n",
+    "    augmented_image = data_augmentation(tf.expand_dims(first_image, 0))\n",
+    "    plt.imshow(augmented_image[0] / 255)\n",
+    "    plt.axis('off')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "bAywKtuVn8uK"
+   },
+   "source": [
+    "### Rescale pixel values\n",
+    "\n",
+    "In a moment, you will download `tf.keras.applications.MobileNetV2` for use as your base model. This model expects pixel values in `[-1, 1]`, but at this point, the pixel values in your images are in `[0, 255]`. To rescale them, use the preprocessing method included with the model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "cO0HM9JAQUFq"
+   },
+   "outputs": [],
+   "source": [
+    "preprocess_input = tf.keras.applications.mobilenet_v2.preprocess_input"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "xnr81qRMzcs5"
+   },
+   "source": [
+    "Note: Alternatively, you could rescale pixel values from `[0, 255]` to `[-1, 1]` using `tf.keras.layers.Rescaling`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "R2NyJn4KQMux"
+   },
+   "outputs": [],
+   "source": [
+    "rescale = tf.keras.layers.Rescaling(1./127.5, offset=-1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Wz7qgImhTxw4"
+   },
+   "source": [
+    "Note: If using other `tf.keras.applications`, be sure to check the API doc to determine if they expect pixels in `[-1, 1]` or `[0, 1]`, or use the included `preprocess_input` function."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "OkH-kazQecHB"
+   },
+   "source": [
+    "## Create the base model from the pre-trained convnets\n",
+    "You will create the base model from the **MobileNet V2** model developed at Google. This is pre-trained on the ImageNet dataset, a large dataset consisting of 1.4M images and 1000 classes. ImageNet is a research training dataset with a wide variety of categories like `jackfruit` and `syringe`. This base of knowledge will help us classify cats and dogs from our specific dataset.\n",
+    "\n",
+    "First, you need to pick which layer of MobileNet V2 you will use for feature extraction. The very last classification layer (on \"top\", as most diagrams of machine learning models go from bottom to top) is not very useful. Instead, you will follow the common practice to depend on the very last layer before the flatten operation. This layer is called the \"bottleneck layer\". The bottleneck layer features retain more generality as compared to the final/top layer.\n",
+    "\n",
+    "First, instantiate a MobileNet V2 model pre-loaded with weights trained on ImageNet. By specifying the **include_top=False** argument, you load a network that doesn't include the classification layers at the top, which is ideal for feature extraction."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "19IQ2gqneqmS"
+   },
+   "outputs": [],
+   "source": [
+    "# Create the base model from the pre-trained model MobileNet V2\n",
+    "IMG_SHAPE = IMG_SIZE + (3,)\n",
+    "base_model = tf.keras.applications.MobileNetV2(input_shape=IMG_SHAPE,\n",
+    "                                               include_top=False,\n",
+    "                                               weights='imagenet')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "AqcsxoJIEVXZ"
+   },
+   "source": [
+    "This feature extractor converts each `160x160x3` image into a `5x5x1280` block of features. Let's see what it does to an example batch of images:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Y-2LJL0EEUcx"
+   },
+   "outputs": [],
+   "source": [
+    "image_batch, label_batch = next(iter(train_dataset))\n",
+    "feature_batch = base_model(image_batch)\n",
+    "print(feature_batch.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "rlx56nQtfe8Y"
+   },
+   "source": [
+    "## Feature extraction\n",
+    "In this step, you will freeze the convolutional base created from the previous step and to use as a feature extractor. Additionally, you add a classifier on top of it and train the top-level classifier."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "CnMLieHBCwil"
+   },
+   "source": [
+    "### Freeze the convolutional base"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "7fL6upiN3ekS"
+   },
+   "source": [
+    "It is important to freeze the convolutional base before you compile and train the model. Freezing (by setting layer.trainable = False) prevents the weights in a given layer from being updated during training. MobileNet V2 has many layers, so setting the entire model's `trainable` flag to False will freeze all of them."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "OTCJH4bphOeo"
+   },
+   "outputs": [],
+   "source": [
+    "base_model.trainable = False"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "jsNHwpm7BeVM"
+   },
+   "source": [
+    "### Important note about BatchNormalization layers\n",
+    "\n",
+    "Many models contain `tf.keras.layers.BatchNormalization` layers. This layer is a special case and precautions should be taken in the context of fine-tuning, as shown later in this tutorial.\n",
+    "\n",
+    "When you set `layer.trainable = False`, the `BatchNormalization` layer will run in inference mode, and will not update its mean and variance statistics.\n",
+    "\n",
+    "When you unfreeze a model that contains BatchNormalization layers in order to do fine-tuning, you should keep the BatchNormalization layers in inference mode by passing `training = False` when calling the base model. Otherwise, the updates applied to the non-trainable weights will destroy what the model has learned.\n",
+    "\n",
+    "For more details, see the [Transfer learning guide](https://www.tensorflow.org/guide/keras/transfer_learning)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "KpbzSmPkDa-N"
+   },
+   "outputs": [],
+   "source": [
+    "# Let's take a look at the base model architecture\n",
+    "base_model.summary()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "wdMRM8YModbk"
+   },
+   "source": [
+    "### Add a classification head"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "QBc31c4tMOdH"
+   },
+   "source": [
+    "To generate predictions from the block of features, average over the spatial `5x5` spatial locations, using a `tf.keras.layers.GlobalAveragePooling2D` layer to convert the features to  a single 1280-element vector per image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "dLnpMF5KOALm"
+   },
+   "outputs": [],
+   "source": [
+    "global_average_layer = tf.keras.layers.GlobalAveragePooling2D()\n",
+    "feature_batch_average = global_average_layer(feature_batch)\n",
+    "print(feature_batch_average.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "O1p0OJBR6dOT"
+   },
+   "source": [
+    "Apply a `tf.keras.layers.Dense` layer to convert these features into a single prediction per image. You don't need an activation function here because this prediction will be treated as a `logit`, or a raw prediction value. Positive numbers predict class 1, negative numbers predict class 0."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Wv4afXKj6cVa"
+   },
+   "outputs": [],
+   "source": [
+    "prediction_layer = tf.keras.layers.Dense(1, activation='sigmoid')\n",
+    "prediction_batch = prediction_layer(feature_batch_average)\n",
+    "print(prediction_batch.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "HXvz-ZkTa9b3"
+   },
+   "source": [
+    "Build a model by chaining together the data augmentation, rescaling, `base_model` and feature extractor layers using the [Keras Functional API](https://www.tensorflow.org/guide/keras/functional). As previously mentioned, use `training=False` as our model contains a `BatchNormalization` layer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "DgzQX6Veb2WT"
+   },
+   "outputs": [],
+   "source": [
+    "inputs = tf.keras.Input(shape=(160, 160, 3))\n",
+    "x = data_augmentation(inputs)\n",
+    "x = preprocess_input(x)\n",
+    "x = base_model(x, training=False)\n",
+    "x = global_average_layer(x)\n",
+    "x = tf.keras.layers.Dropout(0.2)(x)\n",
+    "outputs = prediction_layer(x)\n",
+    "model = tf.keras.Model(inputs, outputs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "I8ARiyMFsgbH"
+   },
+   "outputs": [],
+   "source": [
+    "model.summary()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "lxOcmVr0ydFZ"
+   },
+   "source": [
+    "The 8+ million parameters in MobileNet are frozen, but there are 1.2 thousand _trainable_ parameters in the Dense layer. These are divided between two `tf.Variable` objects, the weights and biases."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "krvBumovycVA"
+   },
+   "outputs": [],
+   "source": [
+    "len(model.trainable_variables)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "jeGk93R2ahav"
+   },
+   "outputs": [],
+   "source": [
+    "tf.keras.utils.plot_model(model, show_shapes=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "g0ylJXE_kRLi"
+   },
+   "source": [
+    "### Compile the model\n",
+    "\n",
+    "Compile the model before training it. Since there are two classes and a sigmoid oputput, use the `BinaryAccuracy`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "RpR8HdyMhukJ"
+   },
+   "outputs": [],
+   "source": [
+    "base_learning_rate = 0.0001\n",
+    "model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=base_learning_rate),\n",
+    "              loss=tf.keras.losses.BinaryCrossentropy(),\n",
+    "              metrics=[tf.keras.metrics.BinaryAccuracy(threshold=0.5, name='accuracy')])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "RxvgOYTDSWTx"
+   },
+   "source": [
+    "### Train the model\n",
+    "\n",
+    "After training for 10 epochs, you should see ~96% accuracy on the validation set.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Om4O3EESkab1"
+   },
+   "outputs": [],
+   "source": [
+    "initial_epochs = 10\n",
+    "\n",
+    "loss0, accuracy0 = model.evaluate(validation_dataset)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "8cYT1c48CuSd"
+   },
+   "outputs": [],
+   "source": [
+    "print(\"initial loss: {:.2f}\".format(loss0))\n",
+    "print(\"initial accuracy: {:.2f}\".format(accuracy0))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "JsaRFlZ9B6WK"
+   },
+   "outputs": [],
+   "source": [
+    "history = model.fit(train_dataset,\n",
+    "                    epochs=initial_epochs,\n",
+    "                    validation_data=validation_dataset)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Hd94CKImf8vi"
+   },
+   "source": [
+    "### Learning curves\n",
+    "\n",
+    "Let's take a look at the learning curves of the training and validation accuracy/loss when using the MobileNetV2 base model as a fixed feature extractor."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "53OTCh3jnbwV"
+   },
+   "outputs": [],
+   "source": [
+    "acc = history.history['accuracy']\n",
+    "val_acc = history.history['val_accuracy']\n",
+    "\n",
+    "loss = history.history['loss']\n",
+    "val_loss = history.history['val_loss']\n",
+    "\n",
+    "plt.figure(figsize=(8, 8))\n",
+    "plt.subplot(2, 1, 1)\n",
+    "plt.plot(acc, label='Training Accuracy')\n",
+    "plt.plot(val_acc, label='Validation Accuracy')\n",
+    "plt.legend(loc='lower right')\n",
+    "plt.ylabel('Accuracy')\n",
+    "plt.ylim([min(plt.ylim()),1])\n",
+    "plt.title('Training and Validation Accuracy')\n",
+    "\n",
+    "plt.subplot(2, 1, 2)\n",
+    "plt.plot(loss, label='Training Loss')\n",
+    "plt.plot(val_loss, label='Validation Loss')\n",
+    "plt.legend(loc='upper right')\n",
+    "plt.ylabel('Cross Entropy')\n",
+    "plt.ylim([0,1.0])\n",
+    "plt.title('Training and Validation Loss')\n",
+    "plt.xlabel('epoch')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "foWMyyUHbc1j"
+   },
+   "source": [
+    "Note: If you are wondering why the validation metrics are clearly better than the training metrics, the main factor is because layers like `tf.keras.layers.BatchNormalization` and `tf.keras.layers.Dropout` affect accuracy during training. They are turned off when calculating validation loss.\n",
+    "\n",
+    "To a lesser extent, it is also because training metrics report the average for an epoch, while validation metrics are evaluated after the epoch, so validation metrics see a model that has trained slightly longer."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "CqwV-CRdS6Nv"
+   },
+   "source": [
+    "## Fine tuning\n",
+    "In the feature extraction experiment, you were only training a few layers on top of an MobileNetV2 base model. The weights of the pre-trained network were **not** updated during training.\n",
+    "\n",
+    "One way to increase performance even further is to train (or \"fine-tune\") the weights of the top layers of the pre-trained model alongside the training of the classifier you added. The training process will force the weights to be tuned from generic feature maps to features associated specifically with the dataset.\n",
+    "\n",
+    "Note: This should only be attempted after you have trained the top-level classifier with the pre-trained model set to non-trainable. If you add a randomly initialized classifier on top of a pre-trained model and attempt to train all layers jointly, the magnitude of the gradient updates will be too large (due to the random weights from the classifier) and your pre-trained model will forget what it has learned.\n",
+    "\n",
+    "Also, you should try to fine-tune a small number of top layers rather than the whole MobileNet model. In most convolutional networks, the higher up a layer is, the more specialized it is. The first few layers learn very simple and generic features that generalize to almost all types of images. As you go higher up, the features are increasingly more specific to the dataset on which the model was trained. The goal of fine-tuning is to adapt these specialized features to work with the new dataset, rather than overwrite the generic learning."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "CPXnzUK0QonF"
+   },
+   "source": [
+    "### Un-freeze the top layers of the model\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "rfxv_ifotQak"
+   },
+   "source": [
+    "All you need to do is unfreeze the `base_model` and set the bottom layers to be un-trainable. Then, you should recompile the model (necessary for these changes to take effect), and resume training."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "4nzcagVitLQm"
+   },
+   "outputs": [],
+   "source": [
+    "base_model.trainable = True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "-4HgVAacRs5v"
+   },
+   "outputs": [],
+   "source": [
+    "# Let's take a look to see how many layers are in the base model\n",
+    "print(\"Number of layers in the base model: \", len(base_model.layers))\n",
+    "\n",
+    "# Fine-tune from this layer onwards\n",
+    "fine_tune_at = 100\n",
+    "\n",
+    "# Freeze all the layers before the `fine_tune_at` layer\n",
+    "for layer in base_model.layers[:fine_tune_at]:\n",
+    "  layer.trainable = False"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "4Uk1dgsxT0IS"
+   },
+   "source": [
+    "### Compile the model\n",
+    "\n",
+    "As you are training a much larger model and want to readapt the pretrained weights, it is important to use a lower learning rate at this stage. Otherwise, your model could overfit very quickly."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "NtUnaz0WUDva"
+   },
+   "outputs": [],
+   "source": [
+    "model.compile(loss=tf.keras.losses.BinaryCrossentropy(),\n",
+    "              optimizer = tf.keras.optimizers.RMSprop(learning_rate=base_learning_rate/10),\n",
+    "              metrics=[tf.keras.metrics.BinaryAccuracy(threshold=0.5, name='accuracy')])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "WwBWy7J2kZvA"
+   },
+   "outputs": [],
+   "source": [
+    "model.summary()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "bNXelbMQtonr"
+   },
+   "outputs": [],
+   "source": [
+    "len(model.trainable_variables)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "4G5O4jd6TuAG"
+   },
+   "source": [
+    "### Continue training the model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "0foWUN-yDLo_"
+   },
+   "source": [
+    "If you trained to convergence earlier, this step will improve your accuracy by a few percentage points."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ECQLkAsFTlun"
+   },
+   "outputs": [],
+   "source": [
+    "fine_tune_epochs = 10\n",
+    "total_epochs =  initial_epochs + fine_tune_epochs\n",
+    "\n",
+    "history_fine = model.fit(train_dataset,\n",
+    "                         epochs=total_epochs,\n",
+    "                         initial_epoch=len(history.epoch),\n",
+    "                         validation_data=validation_dataset)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "TfXEmsxQf6eP"
+   },
+   "source": [
+    "Let's take a look at the learning curves of the training and validation accuracy/loss when fine-tuning the last few layers of the MobileNetV2 base model and training the classifier on top of it. The validation loss is much higher than the training loss, so you may get some overfitting.\n",
+    "\n",
+    "You may also get some overfitting as the new training set is relatively small and similar to the original MobileNetV2 datasets.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "DNtfNZKlInGT"
+   },
+   "source": [
+    "After fine tuning the model nearly reaches 98% accuracy on the validation set."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "PpA8PlpQKygw"
+   },
+   "outputs": [],
+   "source": [
+    "acc += history_fine.history['accuracy']\n",
+    "val_acc += history_fine.history['val_accuracy']\n",
+    "\n",
+    "loss += history_fine.history['loss']\n",
+    "val_loss += history_fine.history['val_loss']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "chW103JUItdk"
+   },
+   "outputs": [],
+   "source": [
+    "plt.figure(figsize=(8, 8))\n",
+    "plt.subplot(2, 1, 1)\n",
+    "plt.plot(acc, label='Training Accuracy')\n",
+    "plt.plot(val_acc, label='Validation Accuracy')\n",
+    "plt.ylim([0.8, 1])\n",
+    "plt.plot([initial_epochs-1,initial_epochs-1],\n",
+    "          plt.ylim(), label='Start Fine Tuning')\n",
+    "plt.legend(loc='lower right')\n",
+    "plt.title('Training and Validation Accuracy')\n",
+    "\n",
+    "plt.subplot(2, 1, 2)\n",
+    "plt.plot(loss, label='Training Loss')\n",
+    "plt.plot(val_loss, label='Validation Loss')\n",
+    "plt.ylim([0, 1.0])\n",
+    "plt.plot([initial_epochs-1,initial_epochs-1],\n",
+    "         plt.ylim(), label='Start Fine Tuning')\n",
+    "plt.legend(loc='upper right')\n",
+    "plt.title('Training and Validation Loss')\n",
+    "plt.xlabel('epoch')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "R6cWgjgfrsn5"
+   },
+   "source": [
+    "### Evaluation and prediction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "PSXH7PRMxOi5"
+   },
+   "source": [
+    "Finally you can verify the performance of the model on new data using test set."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "2KyNhagHwfar"
+   },
+   "outputs": [],
+   "source": [
+    "loss, accuracy = model.evaluate(test_dataset)\n",
+    "print('Test accuracy :', accuracy)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "8UjS5ukZfOcR"
+   },
+   "source": [
+    "And now you are all set to use this model to predict if your pet is a cat or dog."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "RUNoQNgtfNgt"
+   },
+   "outputs": [],
+   "source": [
+    "# Retrieve a batch of images from the test set\n",
+    "image_batch, label_batch = test_dataset.as_numpy_iterator().next()\n",
+    "predictions = model.predict_on_batch(image_batch).flatten()\n",
+    "\n",
+    "# Apply a sigmoid since our model returns logits\n",
+    "predictions = tf.nn.sigmoid(predictions)\n",
+    "predictions = tf.where(predictions < 0.5, 0, 1)\n",
+    "\n",
+    "print('Predictions:\\n', predictions.numpy())\n",
+    "print('Labels:\\n', label_batch)\n",
+    "\n",
+    "plt.figure(figsize=(10, 10))\n",
+    "for i in range(9):\n",
+    "  ax = plt.subplot(3, 3, i + 1)\n",
+    "  plt.imshow(image_batch[i].astype(\"uint8\"))\n",
+    "  plt.title(class_names[predictions[i]])\n",
+    "  plt.axis(\"off\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "_TZTwG7nhm0C"
+   },
+   "source": [
+    "## Summary\n",
+    "\n",
+    "* **Using a pre-trained model for feature extraction**:  When working with a small dataset, it is a common practice to take advantage of features learned by a model trained on a larger dataset in the same domain. This is done by instantiating the pre-trained model and adding a fully-connected classifier on top. The pre-trained model is \"frozen\" and only the weights of the classifier get updated during training.\n",
+    "In this case, the convolutional base extracted all the features associated with each image and you just trained a classifier that determines the image class given that set of extracted features.\n",
+    "\n",
+    "* **Fine-tuning a pre-trained model**: To further improve performance, one might want to repurpose the top-level layers of the pre-trained models to the new dataset via fine-tuning.\n",
+    "In this case, you tuned your weights such that your model learned high-level features specific to the dataset. This technique is usually recommended when the training dataset is large and very similar to the original dataset that the pre-trained model was trained on.\n",
+    "\n",
+    "To learn more, visit the [Transfer learning guide](https://www.tensorflow.org/guide/keras/transfer_learning).\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "name": "transfer_learning.ipynb",
+   "toc_visible": true
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

notebooks_knowledge&presentation/alternative_models_reference.md

@@ -0,0 +1,43 @@
+# Alternative Transfer Learning Models Reference
+
+This document outlines the various pre-trained models considered for the CIFAR-10 image classification project, their key characteristics, and the reasons why they were NOT chosen over MobileNetV2.
+
+---
+
+## Models Presented in the Presentation (Slides 4 & 4.1)
+
+### MobileNetV2 (Chosen Model - Slide 4)
+*   **Characteristics:** Remarkably efficient (~3.4M parameters). Uses inverted residual blocks.
+*   **Why it WAS chosen:** It strikes the perfect balance between high-accuracy feature extraction and computational efficiency. It trains quickly on standard hardware without requiring massive resources.
+
+### VGG16 (Slide 4.1)
+*   **Characteristics:** Massive size (~138M parameters). Classical deep CNN architecture with uniform simple convolutional layers.
+*   **Why Not?** It is very slow to train on standard hardware and highly prone to overfitting on small 32x32 images like CIFAR-10.
+
+### ResNet50 (Slide 4.1)
+*   **Characteristics:** Powerful architecture (~25M parameters) that utilizes skip connections (residual blocks) to train very deep networks without vanishing gradients.
+*   **Why Not?** Its complexity is often overkill for CIFAR-10, leading to unnecessarily long training times without proportional accuracy gains for such small images.
+
+### InceptionV3 (Slide 4.1)
+*   **Characteristics:** Uses "Inception modules" capable of looking at the same image with different receptive fields (filter sizes) simultaneously. (~24M parameters)
+*   **Why Not?** Demands high computational resources and typically requires much larger input resolutions (default is 299x299) to be fully effective. Highly upscaling 32x32 to 299x299 is very resource-intensive.
+
+---
+
+## Other Notable Alternatives
+
+### EfficientNet (e.g., EfficientNetB0)
+*   **Characteristics:** Modern, highly optimized models that scale up the network's depth, width, and resolution evenly. (B0 has ~5.3M parameters)
+*   **Why Not?** While a very valid alternative, MobileNetV2 is slightly older but exceptionally well-documented for beginners, and tends to train slightly faster on basic setups.
+
+### DenseNet (e.g., DenseNet121)
+*   **Characteristics:** Connects each layer to every other layer in a feed-forward fashion, creating strong feature reuse. (~8M parameters)
+*   **Why Not?** They are heavier in memory usage and take much longer to train per epoch compared to MobileNetV2, despite often achieving higher accuracy.
+
+### Xception
+*   **Characteristics:** An extension of the Inception architecture that uses depthwise separable convolutions (similar to MobileNet). (~22M parameters)
+*   **Why Not?** It is quite large and heavily optimized for the massive ImageNet dataset. Using it for 32x32 pixel images is often inefficient.
+
+### NASNetMobile
+*   **Characteristics:** An architecture discovered by an AI (Neural Architecture Search) designed specifically for mobile and resource-constrained devices.
+*   **Why Not?** While an excellent alternative, MobileNet design (inverted residual blocks) is much simpler and more intuitive to explain in a presentation and learning environment.

notebooks_knowledge&presentation/app_documentation_simple.md

@@ -0,0 +1,46 @@
+# How Our Magic Picture Guesser Works! 🪄🖼️
+
+Hello! Welcome to our Magic Picture Guesser! This is a simple story about how your computer learns to look at a picture and tell you what it is.
+
+## Step 1: The Magic Brain (The Model) 🧠
+
+Before the computer can guess pictures, it has to go to school!
+
+We have a special file called a **Model**. Think of the Model as a big, smart brain that has looked at thousands of pictures of dogs, cats, airplanes, and cars. 
+
+Because it studied so hard, it remembers what they look like! We keep this brain in a safe place inside our project.
+
+## Step 2: The Doorway (The App) 🚪
+
+To let you talk to the brain, we built a Doorway. In computer words, we built an **App** using a tool called Flask. 
+
+When you start the App, it opens a special website just for you on your computer. It looks super cool with colors and a big box where you can drop pictures.
+
+## Step 3: Dropping a Picture 📸
+
+When you open the website, you can drag a picture of a car or a dog into the big box. 
+
+But wait! The magic brain is very picky. It only likes looking at pictures that are small square shapes (like a tiny 32x32 puzzle piece). 
+
+## Step 4: The Shrinking Machine 🔬
+
+Before the brain looks at it, our App uses a **Shrinking Machine** to resize your picture so it fits perfectly in the brain's tiny window. If your picture was huge, we just squish it down so the brain can read it.
+
+## Step 5: The Magic Guess ✨
+
+Once the picture is small enough, the App hands it to the Magic Brain. 
+
+The Brain looks at the colors and shapes and says: 
+**"Aha! I am 99% sure this is an Automobile (a car)!"**
+
+And then, the App shows you the answer on the screen!
+
+---
+
+**Summary:**
+1. You drag a picture.
+2. We shrink it.
+3. The brain looks at it.
+4. It tells you what it sees! 
+
+It's just like showing a picture-book to a very smart friend!

notebooks_knowledge&presentation/fast_deployment_guide.md

@@ -0,0 +1,65 @@
+# Fast and Cheap Deployment Guide (Render.com)
+
+This guide explains how to deploy your Flask application for free using [Render.com](https://render.com/), which is currently one of the easiest and most cost-effective ways to host a Python web app. 
+
+Later, you can move this to a VPS (Virtual Private Server) like DigitalOcean or AWS EC2, but Render is the perfect starting point to quickly fulfill the "+5 Bonus points" requirement.
+
+## Prerequisites
+
+1. Your project must be pushed to a **GitHub repository**.
+2. You need an account on [Render.com](https://render.com/) (you can sign up with GitHub).
+
+## Step-by-Step Instructions
+
+### Step 1: Update `requirements.txt`
+Render needs a production web server to run your Flask app. We will use `gunicorn`.
+Open your `requirements.txt` file and add this line at the very bottom:
+```text
+gunicorn==21.2.0
+```
+
+### Step 2: Push to GitHub
+Make sure all your latest changes, particularly the updated `requirements.txt` and your downloaded best model (in the `models/` folder), are committed and pushed to your GitHub repository.
+
+```bash
+git add requirements.txt models/best_model.h5
+git commit -m "Prepare for Render deployment"
+git push origin main
+```
+*(Note: If your model file is larger than 100MB, you might need to use Git LFS or upload it differently, but MobileNetV2 should be small enough).*
+
+### Step 3: Create a Web Service on Render
+1. Log into your Render dashboard.
+2. Click on **New +** and select **Web Service**.
+3. Connect your GitHub account and select your project repository.
+
+### Step 4: Configure the Web Service
+Fill out the deployment form with the following details:
+- **Name:** Choose a name for your app (e.g., `cifar10-classifier-sebastian`).
+- **Region:** Choose the region closest to you (e.g., Frankfurt/EU).
+- **Branch:** `main` (or whichever branch your code is on).
+- **Runtime:** `Python 3`.
+- **Build Command:** 
+  ```bash
+  pip install -r requirements.txt
+  ```
+- **Start Command:** 
+  ```bash
+  gunicorn app.app:app
+  ```
+  *(Explanation: The first `app` is your `app` folder, the second `app` is the `app.py` script, and the third `:app` is the Flask instance named `app` inside that script).*
+
+### Step 5: Choose Instance Type & Deploy
+- Select the **Free** instance type ($0/month).
+- Click **Create Web Service**.
+
+### Step 6: Wait for Build
+Render will now install your dependencies and launch your app. The console output will show you the progress. Once it says "Live", your app is running!
+
+You can access your live app using the URL Render provides at the top of the dashboard (e.g., `https://cifar10-classifier-sebastian.onrender.com`).
+
+---
+**Why this is the best first step:**
+- It is 100% free.
+- It automatically redeploys if you push new code to GitHub.
+- It handles SSL certificates (`https://`) out of the box.

notebooks_knowledge&presentation/jupyter notebooks/2. CIFAR10_Image_Classification_CNN_Presentation 09.52.53.ipynb

@@ -0,0 +1,690 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Guided Lab: Image Classification using CNN (CIFAR-10)\n",
+    "\n",
+    "At the end of this tutorial, you will get familiarized with:\n",
+    "\n",
+    "*   Creating deep networks using Keras\n",
+    "*   Steps necessary in training a neural network\n",
+    "*   Prediction and performance analysis using neural networks\n",
+    "*   Using Transfer Learning for complex images"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# **Environment set up**\n",
+    "**Keras** is a Python library that provides, in a simple way, the creation of a wide range of Deep Learning models using as backend other libraries such as TensorFlow. \n",
+    "\n",
+    "Keras is used since its learning curve is very smooth compared to others, and at the moment it is one of the popular middleware to implement neural networks."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2026-02-28 16:43:51.698653: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
+      "To enable the following instructions: SSE4.1 SSE4.2 AVX AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3.6.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "from tensorflow import keras\n",
+    "import tensorflow as tf\n",
+    "print(keras.__version__)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# **Understanding Data: CIFAR-10 Dataset**\n",
+    "The CIFAR-10 dataset consists of 60,000 32x32 color images in 10 classes, with 6,000 images per class. \n",
+    "\n",
+    "In Keras, the CIFAR-10 dataset is preloaded in the form of four Numpy arrays. `x_train` and `y_train` contain the training set, while `x_test` and `y_test` contain the test data. The images are encoded as Numpy arrays and their corresponding labels ranging from 0 to 9."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training data shape: (50000, 32, 32, 3)\n",
+      "Testing data shape: (10000, 32, 32, 3)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from keras.datasets import cifar10\n",
+    "(x_train, y_train), (x_test, y_test) = cifar10.load_data()\n",
+    "\n",
+    "print('Training data shape:', x_train.shape)\n",
+    "print('Testing data shape:', x_test.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Visualizing the Data\n",
+    "\n",
+    "A plot of the first nine images in the dataset is created showing the natural image nature of the images to be classified.\n",
+    "\n",
+    "**Let us create a 3*3 subplot to visualize the first 9 images of the dataset.**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 500x500 with 9 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', \n",
+    "               'dog', 'frog', 'horse', 'ship', 'truck']\n",
+    "\n",
+    "plt.figure(figsize=(5, 5))\n",
+    "for i in range(9):\n",
+    "    plt.subplot(3, 3, i + 1)\n",
+    "    plt.xticks([])\n",
+    "    plt.yticks([])\n",
+    "    plt.grid(False)\n",
+    "    plt.imshow(x_train[i])\n",
+    "    plt.title(class_names[y_train[i][0]])\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Data normalization\n",
+    "\n",
+    "The pixel values for each image in the dataset are unsigned integers in the range between 0 and 255.\n",
+    "\n",
+    "**Let us normalize the pixel values of the RGB images, e.g. rescale them to the range [0, 1].**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_train = x_train.astype('float32') / 255.0\n",
+    "x_test = x_test.astype('float32') / 255.0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Preparing labels\n",
+    "\n",
+    "The labels for each input data indicate which object represents the image.\n",
+    "\n",
+    "In this case, we will represent this label with a vector of 10 positions. This is known as **one-hot encoding.**\n",
+    "\n",
+    "**Let us convert the labels into the equivalent one-hot encoded form.**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training labels shape: (50000, 10)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from keras.utils import to_categorical\n",
+    "\n",
+    "y_train = to_categorical(y_train, num_classes=10)\n",
+    "y_test = to_categorical(y_test, num_classes=10)\n",
+    "\n",
+    "print('Training labels shape:', y_train.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# **Defining Model (Custom CNN)**\n",
+    "\n",
+    "The Sequential class of the Keras library is a wrapper for the sequential neural network model.\n",
+    "\n",
+    "**Define the following model:**\n",
+    "\n",
+    "**For the convolutional front-end, start with convolutional layers with a small filter size (3,3) followed by max pooling layers.**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/miniconda3/envs/ironhack.nn/lib/python3.10/site-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
+      "  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from keras.models import Sequential\n",
+    "from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout\n",
+    "\n",
+    "model = Sequential()\n",
+    "model.add(Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)))\n",
+    "model.add(MaxPooling2D((2, 2)))\n",
+    "\n",
+    "model.add(Conv2D(64, (3, 3), activation='relu', padding='same'))\n",
+    "model.add(MaxPooling2D((2, 2)))\n",
+    "\n",
+    "model.add(Flatten())\n",
+    "model.add(Dense(128, activation='relu'))\n",
+    "model.add(Dropout(0.5))\n",
+    "model.add(Dense(10, activation='softmax'))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Let us check the architecture using summary().**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential\"</span>\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[1mModel: \"sequential\"\u001b[0m\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃<span style=\"font-weight: bold\"> Layer (type)                    </span>┃<span style=\"font-weight: bold\"> Output Shape           </span>┃<span style=\"font-weight: bold\">       Param # </span>┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv2d (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)                 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)     │           <span style=\"color: #00af00; text-decoration-color: #00af00\">896</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>)    │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)     │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)     │        <span style=\"color: #00af00; text-decoration-color: #00af00\">18,496</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>)  │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)       │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Flatten</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">4096</span>)           │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                   │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>)            │       <span style=\"color: #00af00; text-decoration-color: #00af00\">524,416</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>)            │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">10</span>)             │         <span style=\"color: #00af00; text-decoration-color: #00af00\">1,290</span> │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃\u001b[1m \u001b[0m\u001b[1mLayer (type)                   \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape          \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      Param #\u001b[0m\u001b[1m \u001b[0m┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m)                 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m)     │           \u001b[38;5;34m896\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m)    │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m32\u001b[0m)     │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m64\u001b[0m)     │        \u001b[38;5;34m18,496\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_1 (\u001b[38;5;33mMaxPooling2D\u001b[0m)  │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m64\u001b[0m)       │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (\u001b[38;5;33mFlatten\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4096\u001b[0m)           │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (\u001b[38;5;33mDense\u001b[0m)                   │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m)            │       \u001b[38;5;34m524,416\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout (\u001b[38;5;33mDropout\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m)            │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼──────────��─────────────┼───────────────┤\n",
+       "│ dense_1 (\u001b[38;5;33mDense\u001b[0m)                 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m)             │         \u001b[38;5;34m1,290\u001b[0m │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">545,098</span> (2.08 MB)\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m545,098\u001b[0m (2.08 MB)\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">545,098</span> (2.08 MB)\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m545,098\u001b[0m (2.08 MB)\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "model.summary()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Compile the model.**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Train the model for 10 epochs with a batch size of 64.**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "history = model.fit(x_train, y_train, batch_size=64, epochs=10, validation_split=0.2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Plot the loss function and the accuracy curves.**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure(figsize=(10, 4))\n",
+    "\n",
+    "plt.subplot(1, 2, 1)\n",
+    "plt.plot(history.history['accuracy'], label='Train Accuracy')\n",
+    "plt.plot(history.history['val_accuracy'], label='Val Accuracy')\n",
+    "plt.title('Accuracy')\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.subplot(1, 2, 2)\n",
+    "plt.plot(history.history['loss'], label='Train Loss')\n",
+    "plt.plot(history.history['val_loss'], label='Val Loss')\n",
+    "plt.title('Loss')\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# **Model evaluation**\n",
+    "\n",
+    "## Accuracy\n",
+    "\n",
+    "After training the model, the network has to be evaluated with new test data. This can be achieved by using the `evaluate()` method.\n",
+    "\n",
+    "**Let us print the test accuracy of the network.**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_loss, test_acc = model.evaluate(x_test, y_test)\n",
+    "print('Test loss:', test_loss)\n",
+    "print('Test accuracy:', test_acc)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "# **Defining Model (Transfer Learning)**\n",
+    "\n",
+    "We can use a pre-trained model like MobileNetV2 to extract features. However, running this on a local CPU can be very slow. \n",
+    "\n",
+    "To solve this for local CPUs, we **resize the images once before training**, instead of resizing them on-the-fly inside the model during every epoch.\n",
+    "\n",
+    "## CPU Optimization: Pre-resizing the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from tensorflow.keras.applications.mobilenet_v2 import preprocess_input\n",
+    "\n",
+    "print('Resizing data for MobileNetV2... This takes a minute but saves HOURS later!')\n",
+    "\n",
+    "# MobileNetV2 expects values in [-1, 1], not [0, 1]. \n",
+    "# We also need to resize to at least 96x96 for MobileNetV2.\n",
+    "\n",
+    "# Note: We only use a subset of the training data (e.g., 20% = 10k images) \n",
+    "# to keep RAM usage and computation time reasonable on a standard CPU.\n",
+    "SUBSET_SIZE = 10000\n",
+    "\n",
+    "x_subset = x_train[:SUBSET_SIZE] * 255.0  # Scale back to 0-255 first\n",
+    "y_subset = y_train[:SUBSET_SIZE]\n",
+    "\n",
+    "x_train_resized = tf.image.resize(x_subset, (96, 96))\n",
+    "x_train_preprocessed = preprocess_input(x_train_resized)\n",
+    "\n",
+    "x_test_resized = tf.image.resize(x_test[:2000] * 255.0, (96, 96))\n",
+    "x_test_preprocessed = preprocess_input(x_test_resized)\n",
+    "\n",
+    "print('Resized training data shape:', x_train_preprocessed.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Building the Transfer Learning Model\n",
+    "We load MobileNetV2 without its top layer, and add our own dense layer for CIFAR-10 classification."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from tensorflow.keras.applications import MobileNetV2\n",
+    "from tensorflow.keras.layers import GlobalAveragePooling2D\n",
+    "\n",
+    "base_model = MobileNetV2(input_shape=(96, 96, 3), include_top=False, weights='imagenet')\n",
+    "base_model.trainable = False  # Freeze the base model!\n",
+    "\n",
+    "tl_model = Sequential([\n",
+    "    base_model,\n",
+    "    GlobalAveragePooling2D(),\n",
+    "    Dense(10, activation='softmax')\n",
+    "])\n",
+    "\n",
+    "tl_model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n",
+    "tl_model.summary()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Training the Transfer Learning Model (CPU Optimized)\n",
+    "Because we pre-resized the images and froze the base model, this should run reasonably fast (1-2 minutes per epoch on CPU)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print('Training Transfer Learning model on CPU...')\n",
+    "tl_history = tl_model.fit(\n",
+    "    x_train_preprocessed, \n",
+    "    y_subset, \n",
+    "    epochs=5, \n",
+    "    batch_size=64, \n",
+    "    validation_split=0.2\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## \"\"\" Optional \"\"\" - Cloud GPU Pipeline Code\n",
+    "If you decide to run this in **Google Colab** (Option 1), you can use the much simpler, fully-integrated code below, since the GPU is fast enough to handle the resizing on-the-fly during training."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\"\"\"\n",
+    "# OPTIONAL: Run this ONLY if you are using Google Colab or Kaggle (GPU enabled)\n",
+    "from tensorflow.keras.layers import Resizing, Input\n",
+    "from tensorflow.keras.applications.mobilenet_v2 import MobileNetV2, preprocess_input\n",
+    "from tensorflow.keras.models import Model\n",
+    "\n",
+    "# Reload original raw data (0-255)\n",
+    "(x_train_raw, y_train_raw), (x_test_raw, y_test_raw) = cifar10.load_data()\n",
+    "y_train_cat = to_categorical(y_train_raw, 10)\n",
+    "y_test_cat = to_categorical(y_test_raw, 10)\n",
+    "\n",
+    "base_model = MobileNetV2(input_shape=(96, 96, 3), include_top=False, weights='imagenet')\n",
+    "base_model.trainable = False\n",
+    "\n",
+    "# Build pipeline that resizes ON THE FLY (fast on GPU, slow on CPU)\n",
+    "inputs = Input(shape=(32, 32, 3))\n",
+    "x = Resizing(96, 96)(inputs)\n",
+    "x = preprocess_input(x)\n",
+    "x = base_model(x)\n",
+    "x = GlobalAveragePooling2D()(x)\n",
+    "outputs = Dense(10, activation='softmax')(x)\n",
+    "\n",
+    "gpu_model = Model(inputs, outputs)\n",
+    "gpu_model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n",
+    "\n",
+    "# Train on ALL data (50k images) - this will be very fast on a GPU!\n",
+    "gpu_history = gpu_model.fit(x_train_raw, y_train_cat, epochs=5, batch_size=128, validation_split=0.2)\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "# **Misclassification Analysis**\n",
+    "\n",
+    "Even our best model (Custom CNN, 85.3% accuracy) makes confident mistakes. Here are 5 examples where the model was **highly confident but wrong**:\n",
+    "\n",
+    "| True Label | Predicted | Confidence | Why the model failed |\n",
+    "|:-----------|:----------|:-----------|:---------------------|\n",
+    "| **Cat** | Dog | 99.5% | Both are furry, four-legged animals with similar color palettes at 32×32 |\n",
+    "| **Dog** | Cat | 95.2% | Same confusion pair in reverse — shows this is a systematic weakness |\n",
+    "| **Bird** | Frog | 100.0% | Small subject against green/natural background at low resolution |\n",
+    "| **Automobile** | Truck | 99.7% | Both are wheeled vehicles with boxy shapes — size (the key discriminator) is lost at 32×32 |\n",
+    "| **Airplane** | Ship | 99.8% | Both appear against blue backgrounds (sky vs. water) |\n",
+    "\n",
+    "**Key insight:** The model relies heavily on **color patterns and rough shapes** rather than fine-grained details, because 32×32 resolution simply does not preserve enough information."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from PIL import Image\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Display the pre-generated misclassification examples\n",
+    "img = Image.open(\"../outputs/misclassified_examples.png\")\n",
+    "plt.figure(figsize=(20, 5))\n",
+    "plt.imshow(img)\n",
+    "plt.axis(\"off\")\n",
+    "plt.title(\"Misclassification Examples - Custom CNN\", fontsize=16, fontweight=\"bold\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "# **Dataset Bias: What The Model Does Not Know**\n",
+    "\n",
+    "CIFAR-10 was collected from internet images, predominantly from **Western/English-language sources**. This means our model learned a geographically and culturally *narrow* view of each class:\n",
+    "\n",
+    "| Class | What the model learned | What it probably has not seen |\n",
+    "|:------|:----------------------|:----------------------------|\n",
+    "| **Automobile** | American/European car designs | Tuk-tuks, rickshaws, vehicles common in Asia/Africa |\n",
+    "| **Truck** | Modern pickup & delivery trucks | Flatbed trucks from rural areas, different regions |\n",
+    "| **Ship** | Large vessels in open water | Canoes, kayaks, fishing boats from other cultures |\n",
+    "| **Horse** | Western contexts (ranches, paddocks) | Horses in different cultural settings or landscapes |\n",
+    "| **Bird** | North American bird species | Tropical birds, exotic species from other continents |\n",
+    "\n",
+    "> **The model classifies an automobile as seen by English-speaking internet users, not a universal automobile.**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "# **Why This Matters**\n",
+    "\n",
+    "### 4 Types of Bias in Our Model\n",
+    "\n",
+    "1. **Geographic diversity was never audited**\n",
+    "   - The training data was never checked for regional representation\n",
+    "   - The model has a Western-centric worldview in every class\n",
+    "\n",
+    "2. **Background/context bias**\n",
+    "   - Objects appear in typical contexts (planes in blue sky, ships in water)\n",
+    "   - An airplane on a tarmac or a ship in dry dock would likely be harder to classify\n",
+    "\n",
+    "3. **Color/lighting bias**\n",
+    "   - Nearly all training images are in daylight\n",
+    "   - Night images or unusual lighting would degrade performance\n",
+    "\n",
+    "4. **Resolution bias**\n",
+    "   - Everything is 32x32 pixels: the model uses color patterns and rough shapes, not details\n",
+    "   - This is itself a form of **information loss bias**\n",
+    "\n",
+    "### Other Limitations\n",
+    "- **No none of the above**: Upload a banana and the model will still confidently say it is a frog\n",
+    "- **Perfect class balance** (6,000/class) is unrealistic, real-world data is imbalanced\n",
+    "- **Temporal bias**: Cars, trucks, and ships from the dataset era look different from today"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "ironhack.nn",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.18"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

notebooks_knowledge&presentation/terminal_commands.md

@@ -0,0 +1,76 @@
+# Important Terminal Commands
+
+This document contains a summary of the most important terminal commands for the CIFAR-10 Image Classification project, organized by workflow.
+
+## 1. Environment Setup
+
+```bash
+# Create and activate conda environment
+conda create -n ironhack.nn python=3.10
+conda activate ironhack.nn
+
+# Install dependencies
+pip install -r requirements.txt
+```
+
+## 2. Training the Model
+
+```bash
+# Run the training notebook (or script)
+jupyter notebook notebooks/
+
+# Or run training scripts directly
+python src/train.py          # if you have a training script
+```
+
+## 3. Running the Flask Web App
+
+```bash
+# Activate environment first
+conda activate ironhack.nn
+
+# Start the Flask server
+python app/app.py
+# or with a custom port:
+python app/app.py (or flask run --port 5001)
+```
+
+## 4. Docker (Containerized Deployment)
+
+```bash
+# Build the Docker image
+docker build -t cifar10-classifier .
+
+# Run the container
+docker run -p 5001:5001 cifar10-classifier
+```
+
+## 5. Git (Version Control)
+
+```bash
+# Check status of changes
+git status
+
+# Stage and commit changes
+git add .
+git commit -m "your message here"
+
+# Push to remote
+git push origin main
+```
+
+## 6. Useful Utility Commands
+
+```bash
+# Check installed packages
+pip list
+
+# Check Python version
+python --version
+
+# Check GPU availability (if using TensorFlow)
+python -c "import tensorflow as tf; print(tf.config.list_physical_devices('GPU'))"
+
+# Check model file sizes
+ls -lh models/
+```

outputs/custom_cnn_metrics.json

@@ -0,0 +1,8 @@
+{
+  "model": "Custom CNN",
+  "loss": 0.44597572088241577,
+  "accuracy": 0.8529999852180481,
+  "precision": 0.855587007688615,
+  "recall": 0.853,
+  "f1_score": 0.8512058258364695
+}

outputs/transfer_learning_metrics.json

@@ -0,0 +1,8 @@
+{
+  "model": "MobileNetV2 Transfer Learning",
+  "loss": 0.5526939630508423,
+  "accuracy": 0.8339999914169312,
+  "precision": 0.8353133287095834,
+  "recall": 0.834,
+  "f1_score": 0.8339057892820989
+}

requirements.txt

@@ -0,0 +1,10 @@
+tensorflow==2.18.1
+keras==3.6.0
+numpy==2.0.1
+pandas==2.3.1
+matplotlib==3.10.0
+seaborn==0.13.2
+scikit-learn==1.7.1
+Pillow==11.3.0
+flask==3.1.3
+opencv-python-headless==4.13.0.92

src/__init__.py

@@ -0,0 +1 @@
+# CNN Image Classification Project - Source Package

src/data_loader.py

@@ -0,0 +1,113 @@
+"""
+Data Loading and Preprocessing Module for CIFAR-10 Image Classification.
+
+This module handles:
+- Loading the CIFAR-10 dataset from Keras
+- Normalizing pixel values to [0, 1]
+- One-hot encoding labels
+- Data augmentation via ImageDataGenerator
+"""
+
+import numpy as np
+from tensorflow import keras
+from keras.api.datasets import cifar10
+from keras.api.utils import to_categorical
+from keras.src.legacy.preprocessing.image import ImageDataGenerator
+
+
+# CIFAR-10 class names (in order of label index 0-9)
+CLASS_NAMES = [
+    'airplane', 'automobile', 'bird', 'cat', 'deer',
+    'dog', 'frog', 'horse', 'ship', 'truck'
+]
+
+NUM_CLASSES = 10
+IMG_SHAPE = (32, 32, 3)
+
+
+def load_cifar10_data():
+    """
+    Load the CIFAR-10 dataset and return raw train/test splits.
+
+    Returns:
+        tuple: (x_train, y_train), (x_test, y_test)
+            - x: uint8 images of shape (N, 32, 32, 3)
+            - y: integer labels of shape (N, 1)
+    """
+    (x_train, y_train), (x_test, y_test) = cifar10.load_data()
+    return (x_train, y_train), (x_test, y_test)
+
+
+def preprocess_data(x_train, y_train, x_test, y_test):
+    """
+    Normalize images and one-hot encode labels.
+
+    Args:
+        x_train: Training images (uint8).
+        y_train: Training labels (int).
+        x_test: Test images (uint8).
+        y_test: Test labels (int).
+
+    Returns:
+        tuple: (x_train, y_train, x_test, y_test)
+            - x: float32 images normalized to [0, 1]
+            - y: one-hot encoded labels of shape (N, 10)
+    """
+    # Normalize pixel values to [0, 1]
+    x_train = x_train.astype('float32') / 255.0
+    x_test = x_test.astype('float32') / 255.0
+
+    # One-hot encode labels
+    y_train = to_categorical(y_train, NUM_CLASSES)
+    y_test = to_categorical(y_test, NUM_CLASSES)
+
+    return x_train, y_train, x_test, y_test
+
+
+def create_data_augmentation_generator():
+    """
+    Create an ImageDataGenerator with augmentation transformations.
+
+    Augmentations applied:
+    - Random rotation up to 15 degrees
+    - Random width/height shift up to 10%
+    - Random horizontal flip
+    - Random zoom up to 10%
+
+    Returns:
+        ImageDataGenerator: configured generator for training data augmentation.
+    """
+    datagen = ImageDataGenerator(
+        rotation_range=15,
+        width_shift_range=0.1,
+        height_shift_range=0.1,
+        horizontal_flip=True,
+        zoom_range=0.1,
+        fill_mode='nearest'
+    )
+    return datagen
+
+
+def get_prepared_data():
+    """
+    Full pipeline: load CIFAR-10, preprocess, and return ready-to-use data.
+
+    Returns:
+        dict with keys:
+            'x_train', 'y_train', 'x_test', 'y_test': processed arrays
+            'datagen': ImageDataGenerator for augmented training
+    """
+    (x_train, y_train), (x_test, y_test) = load_cifar10_data()
+    x_train, y_train, x_test, y_test = preprocess_data(
+        x_train, y_train, x_test, y_test
+    )
+    datagen = create_data_augmentation_generator()
+    datagen.fit(x_train)
+
+    return {
+        'x_train': x_train,
+        'y_train': y_train,
+        'x_test': x_test,
+        'y_test': y_test,
+        'datagen': datagen
+    }

src/evaluate.py

@@ -0,0 +1,156 @@
+"""
+Evaluation Module for CIFAR-10 Image Classification.
+
+Provides functions to:
+- Evaluate model accuracy on test data
+- Generate classification reports (precision, recall, F1)
+- Plot and save confusion matrices
+- Plot training history curves
+"""
+
+import os
+import numpy as np
+import matplotlib
+matplotlib.use('Agg')  # Non-interactive backend for saving plots
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.metrics import (
+    classification_report, confusion_matrix,
+    accuracy_score, precision_score, recall_score, f1_score
+)
+
+from .data_loader import CLASS_NAMES
+
+
+def evaluate_model(model, x_test, y_test):
+    """
+    Evaluate a trained model on the test set.
+
+    Args:
+        model: Trained Keras model.
+        x_test: Test images (normalized).
+        y_test: Test labels (one-hot encoded).
+
+    Returns:
+        dict: Dictionary with loss, accuracy, precision, recall, f1,
+              y_true (int labels), y_pred (int predictions),
+              and the full classification_report string.
+    """
+    # Get test loss and accuracy
+    loss, accuracy = model.evaluate(x_test, y_test, verbose=0)
+
+    # Get predictions
+    y_pred_proba = model.predict(x_test, verbose=0)
+    y_pred = np.argmax(y_pred_proba, axis=1)
+    y_true = np.argmax(y_test, axis=1)
+
+    # Compute metrics
+    precision = precision_score(y_true, y_pred, average='weighted')
+    recall = recall_score(y_true, y_pred, average='weighted')
+    f1 = f1_score(y_true, y_pred, average='weighted')
+
+    report = classification_report(y_true, y_pred, target_names=CLASS_NAMES)
+
+    return {
+        'loss': loss,
+        'accuracy': accuracy,
+        'precision': precision,
+        'recall': recall,
+        'f1_score': f1,
+        'y_true': y_true,
+        'y_pred': y_pred,
+        'classification_report': report
+    }
+
+
+def plot_confusion_matrix(y_true, y_pred, class_names=CLASS_NAMES,
+                          save_path=None, title='Confusion Matrix'):
+    """
+    Plot and optionally save a confusion matrix heatmap.
+
+    Args:
+        y_true: True integer labels.
+        y_pred: Predicted integer labels.
+        class_names: List of class name strings.
+        save_path: Optional file path to save the plot.
+        title: Plot title.
+    """
+    cm = confusion_matrix(y_true, y_pred)
+
+    fig, ax = plt.subplots(figsize=(10, 8))
+    sns.heatmap(
+        cm, annot=True, fmt='d', cmap='Blues',
+        xticklabels=class_names, yticklabels=class_names,
+        ax=ax
+    )
+    ax.set_xlabel('Predicted Label', fontsize=12)
+    ax.set_ylabel('True Label', fontsize=12)
+    ax.set_title(title, fontsize=14)
+    plt.tight_layout()
+
+    if save_path:
+        os.makedirs(os.path.dirname(save_path), exist_ok=True)
+        plt.savefig(save_path, dpi=150, bbox_inches='tight')
+        print(f"Confusion matrix saved to: {save_path}")
+
+    plt.close(fig)
+
+
+def plot_training_history(history, save_path=None, title_prefix=''):
+    """
+    Plot training and validation accuracy/loss curves.
+
+    Args:
+        history: Keras History object from model.fit().
+        save_path: Optional file path to save the plot.
+        title_prefix: Optional prefix for plot titles (e.g., 'Custom CNN').
+    """
+    fig, axes = plt.subplots(1, 2, figsize=(14, 5))
+
+    # Accuracy plot
+    axes[0].plot(history.history['accuracy'], label='Train Accuracy', linewidth=2)
+    axes[0].plot(history.history['val_accuracy'], label='Validation Accuracy', linewidth=2)
+    axes[0].set_title(f'{title_prefix} Accuracy', fontsize=14)
+    axes[0].set_xlabel('Epoch')
+    axes[0].set_ylabel('Accuracy')
+    axes[0].legend()
+    axes[0].grid(True, alpha=0.3)
+
+    # Loss plot
+    axes[1].plot(history.history['loss'], label='Train Loss', linewidth=2)
+    axes[1].plot(history.history['val_loss'], label='Validation Loss', linewidth=2)
+    axes[1].set_title(f'{title_prefix} Loss', fontsize=14)
+    axes[1].set_xlabel('Epoch')
+    axes[1].set_ylabel('Loss')
+    axes[1].legend()
+    axes[1].grid(True, alpha=0.3)
+
+    plt.tight_layout()
+
+    if save_path:
+        os.makedirs(os.path.dirname(save_path), exist_ok=True)
+        plt.savefig(save_path, dpi=150, bbox_inches='tight')
+        print(f"Training history saved to: {save_path}")
+
+    plt.close(fig)
+
+
+def print_evaluation_summary(metrics, model_name='Model'):
+    """
+    Print a formatted evaluation summary.
+
+    Args:
+        metrics: Dictionary returned by evaluate_model().
+        model_name: Name of the model for display.
+    """
+    print(f"\n{'='*60}")
+    print(f"  {model_name} — Evaluation Results")
+    print(f"{'='*60}")
+    print(f"  Test Loss:      {metrics['loss']:.4f}")
+    print(f"  Test Accuracy:  {metrics['accuracy']:.4f}  ({metrics['accuracy']*100:.2f}%)")
+    print(f"  Precision:      {metrics['precision']:.4f}")
+    print(f"  Recall:         {metrics['recall']:.4f}")
+    print(f"  F1-Score:       {metrics['f1_score']:.4f}")
+    print(f"{'='*60}")
+    print(f"\nClassification Report:\n")
+    print(metrics['classification_report'])

src/model_builder.py

@@ -0,0 +1,153 @@
+"""
+Model Architecture Builder for CIFAR-10 Image Classification.
+
+This module defines:
+- A custom CNN architecture designed for 32x32 CIFAR-10 images
+- A transfer learning model using MobileNetV2 pretrained on ImageNet
+"""
+
+from keras.api.models import Sequential, Model
+from keras.api.layers import (
+    Conv2D, MaxPooling2D, Dense, Dropout, Flatten,
+    BatchNormalization, GlobalAveragePooling2D, Input,
+    UpSampling2D
+)
+from keras.api.applications import MobileNetV2
+
+from .data_loader import NUM_CLASSES, IMG_SHAPE
+
+
+def build_custom_cnn(input_shape=IMG_SHAPE, num_classes=NUM_CLASSES):
+    """
+    Build a custom CNN architecture for CIFAR-10 classification.
+
+    Architecture:
+        Block 1: Conv2D(32) -> BatchNorm -> Conv2D(32) -> BatchNorm -> MaxPool -> Dropout(0.25)
+        Block 2: Conv2D(64) -> BatchNorm -> Conv2D(64) -> BatchNorm -> MaxPool -> Dropout(0.25)
+        Block 3: Conv2D(128) -> BatchNorm -> Conv2D(128) -> BatchNorm -> MaxPool -> Dropout(0.25)
+        Dense: Flatten -> Dense(256) -> BatchNorm -> Dropout(0.5) -> Dense(10, softmax)
+
+    Args:
+        input_shape (tuple): Shape of input images (H, W, C). Default: (32, 32, 3)
+        num_classes (int): Number of output classes. Default: 10
+
+    Returns:
+        keras.Model: Compiled CNN model
+    """
+    model = Sequential([
+        # --- Block 1 ---
+        Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=input_shape),
+        BatchNormalization(),
+        Conv2D(32, (3, 3), activation='relu', padding='same'),
+        BatchNormalization(),
+        MaxPooling2D(pool_size=(2, 2)),
+        Dropout(0.25),
+
+        # --- Block 2 ---
+        Conv2D(64, (3, 3), activation='relu', padding='same'),
+        BatchNormalization(),
+        Conv2D(64, (3, 3), activation='relu', padding='same'),
+        BatchNormalization(),
+        MaxPooling2D(pool_size=(2, 2)),
+        Dropout(0.25),
+
+        # --- Block 3 ---
+        Conv2D(128, (3, 3), activation='relu', padding='same'),
+        BatchNormalization(),
+        Conv2D(128, (3, 3), activation='relu', padding='same'),
+        BatchNormalization(),
+        MaxPooling2D(pool_size=(2, 2)),
+        Dropout(0.25),
+
+        # --- Classifier ---
+        Flatten(),
+        Dense(256, activation='relu'),
+        BatchNormalization(),
+        Dropout(0.5),
+        Dense(num_classes, activation='softmax')
+    ])
+
+    return model
+
+
+def build_transfer_learning_model(input_shape=IMG_SHAPE, num_classes=NUM_CLASSES,
+                                   upscale=True):
+    """
+    Build a transfer learning model using MobileNetV2.
+
+    MobileNetV2 is chosen because:
+    - Lightweight and efficient (good for training on CPU/limited GPU)
+    - Strong feature extraction from ImageNet pretraining
+    - Keras docs: https://keras.io/api/applications/mobilenet/#mobilenetv2-function
+    - Requires minimum 96×96×3 input for efficient performance
+
+    Architecture (GPU / upscale=True):
+        Input(32,32,3) -> UpSampling2D(3x) -> MobileNetV2(frozen) ->
+        GlobalAveragePooling2D -> Dense(256) -> Dropout(0.5) -> Dense(10, softmax)
+
+    Architecture (CPU / upscale=False):
+        Input(96,96,3) [pre-resized with cv2] -> MobileNetV2(frozen) ->
+        GlobalAveragePooling2D -> Dense(256) -> Dropout(0.5) -> Dense(10, softmax)
+
+    Args:
+        input_shape (tuple): Shape of input images.
+                             GPU: (32, 32, 3) — UpSampling2D handles resize.
+                             CPU: (96, 96, 3) — images pre-resized with cv2.
+        num_classes (int):  Number of output classes. Default: 10
+        upscale (bool):     If True, adds UpSampling2D(3,3) inside the model
+                            (GPU version, 03_transfer_learning_gpu.py).
+                            If False, skips it — images must already be 96×96
+                            (CPU version, 03_transfer_learning_cpu.py).
+
+    Returns:
+        tuple: (keras.Model, base_model) — full model and MobileNetV2 base
+    """
+    # Input layer
+    inputs = Input(shape=input_shape)
+
+    if upscale:
+        # GPU version: upscale 32×32 → 96×96 inside the graph (runs each batch)
+        x = UpSampling2D(size=(3, 3))(inputs)
+        mobilenet_input_shape = (96, 96, 3)
+    else:
+        # CPU version: images already 96×96 (pre-resized with cv2 before training)
+        # This eliminates per-batch upscaling — the main CPU bottleneck
+        x = inputs
+        mobilenet_input_shape = input_shape
+
+    # Load MobileNetV2 pretrained on ImageNet, without top classification layers
+    # Minimum efficient input: 96×96×3 (see Keras docs link above)
+    base_model = MobileNetV2(
+        input_shape=mobilenet_input_shape,
+        include_top=False,
+        weights='imagenet'
+    )
+    # Freeze all base model layers (we only train the new head)
+    base_model.trainable = False
+
+    x = base_model(x, training=False)
+
+    # Custom classification head
+    x = GlobalAveragePooling2D()(x)
+    x = Dense(256, activation='relu')(x)
+    x = Dropout(0.5)(x)
+    outputs = Dense(num_classes, activation='softmax')(x)
+
+    model = Model(inputs=inputs, outputs=outputs)
+
+    return model, base_model
+
+
+def get_model_summary(model):
+    """
+    Get a string summary of the model architecture.
+
+    Args:
+        model: Keras model
+
+    Returns:
+        str: Model summary string
+    """
+    summary_lines = []
+    model.summary(print_fn=lambda x: summary_lines.append(x))
+    return '\n'.join(summary_lines)

src/train.py

@@ -0,0 +1,147 @@
+"""
+Training Pipeline for CIFAR-10 Image Classification.
+
+This module provides functions to compile and train Keras models
+with appropriate callbacks for preventing overfitting.
+"""
+
+import os
+from keras.api.optimizers import Adam
+from keras.api.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
+
+
+# Default training configuration
+DEFAULT_CONFIG = {
+    'learning_rate': 0.001,
+    'batch_size': 64,
+    'epochs': 100,          # max epochs (early stopping will cut short)
+    'early_stopping_patience': 10,
+    'reduce_lr_patience': 5,
+    'reduce_lr_factor': 0.5,
+    'min_lr': 1e-6,
+}
+
+
+def compile_model(model, learning_rate=DEFAULT_CONFIG['learning_rate']):
+    """
+    Compile a Keras model with Adam optimizer and categorical crossentropy loss.
+
+    Args:
+        model: Keras model to compile.
+        learning_rate (float): Initial learning rate for Adam optimizer.
+
+    Returns:
+        Compiled Keras model.
+    """
+    model.compile(
+        optimizer=Adam(learning_rate=learning_rate),
+        loss='categorical_crossentropy',
+        metrics=['accuracy']
+    )
+    return model
+
+
+def get_callbacks(model_save_path, patience=DEFAULT_CONFIG['early_stopping_patience']):
+    """
+    Create a list of training callbacks for robust training.
+
+    Callbacks:
+    - EarlyStopping: Stops training if val_loss doesn't improve for `patience` epochs.
+                     Restores the best weights.
+    - ModelCheckpoint: Saves the best model based on val_loss.
+    - ReduceLROnPlateau: Reduces learning rate by half if val_loss plateaus for 5 epochs.
+
+    Args:
+        model_save_path (str): File path to save the best model.
+        patience (int): Number of epochs to wait before early stopping.
+
+    Returns:
+        list: List of Keras callback instances.
+    """
+    # Ensure the directory exists
+    os.makedirs(os.path.dirname(model_save_path), exist_ok=True)
+
+    callbacks = [
+        EarlyStopping(
+            monitor='val_loss',
+            patience=patience,
+            restore_best_weights=True,
+            verbose=1
+        ),
+        ModelCheckpoint(
+            filepath=model_save_path,
+            monitor='val_loss',
+            save_best_only=True,
+            verbose=1
+        ),
+        ReduceLROnPlateau(
+            monitor='val_loss',
+            factor=DEFAULT_CONFIG['reduce_lr_factor'],
+            patience=DEFAULT_CONFIG['reduce_lr_patience'],
+            min_lr=DEFAULT_CONFIG['min_lr'],
+            verbose=1
+        )
+    ]
+    return callbacks
+
+
+def train_model(model, x_train, y_train, datagen=None,
+                validation_split=0.1, x_val=None, y_val=None,
+                batch_size=DEFAULT_CONFIG['batch_size'],
+                epochs=DEFAULT_CONFIG['epochs'],
+                callbacks=None):
+    """
+    Train a Keras model with optional data augmentation.
+
+    If `datagen` is provided, training uses the augmentation generator.
+    Otherwise, trains directly on the raw data.
+
+    Args:
+        model: Compiled Keras model.
+        x_train: Training images array.
+        y_train: Training labels array (one-hot).
+        datagen: Optional ImageDataGenerator for data augmentation.
+        validation_split: Fraction of training data for validation (used if x_val is None).
+        x_val: Optional separate validation images.
+        y_val: Optional separate validation labels.
+        batch_size (int): Training batch size.
+        epochs (int): Maximum number of training epochs.
+        callbacks (list): List of Keras callbacks.
+
+    Returns:
+        keras.callbacks.History: Training history object.
+    """
+    # Determine validation data
+    if x_val is not None and y_val is not None:
+        validation_data = (x_val, y_val)
+    else:
+        # Split training data for validation
+        split_idx = int(len(x_train) * (1 - validation_split))
+        x_val = x_train[split_idx:]
+        y_val = y_train[split_idx:]
+        x_train = x_train[:split_idx]
+        y_train = y_train[:split_idx]
+        validation_data = (x_val, y_val)
+
+    if datagen is not None:
+        # Train with data augmentation
+        history = model.fit(
+            datagen.flow(x_train, y_train, batch_size=batch_size),
+            epochs=epochs,
+            validation_data=validation_data,
+            callbacks=callbacks or [],
+            steps_per_epoch=len(x_train) // batch_size,
+            verbose=1
+        )
+    else:
+        # Train without augmentation
+        history = model.fit(
+            x_train, y_train,
+            batch_size=batch_size,
+            epochs=epochs,
+            validation_data=validation_data,
+            callbacks=callbacks or [],
+            verbose=1
+        )
+
+    return history