Upload folder using huggingface_hub

.dockerignore

@@ -0,0 +1,9 @@
+# Ignore datasets and heavy files to keep deployment fast
+dataset/
+__pycache__/
+*.pyc
+.env
+.git
+.vscode
+.gemini
+scripts/testing/mission_dataset_split.zip

.env

@@ -0,0 +1,3 @@
+OLLAMA_URL="http://localhost:11434"
+OLLAMA_API_KEY="87b344ea09c540848abd777349d64466.PeZFbKB2Y03ddFyD4YXW0TpT"
+OLLAMA_MODEL="llava-llama3"

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+venv/images/imagehash.png filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/__pycache__/typing_extensions.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/absl/testing/__pycache__/absltest.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/aiohttp/_http_parser.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/aiohttp/_websocket/reader_c.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,26 @@
+# Use official Python runtime as a parent image
+FROM python:3.11-slim
+
+# Set working directory in the container
+WORKDIR /app
+
+# Install system dependencies (needed for OpenCV/Pillow if required)
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements file first (for caching)
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application code
+COPY . .
+
+# Expose port 7860 for Hugging Face Spaces
+EXPOSE 7860
+
+# Run the application using gunicorn for production
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "app:app"]

anticheat_hashes.json

@@ -0,0 +1 @@
+{"hashes": ["46256446866b53d9", "e0e42531b264e6d6", "e24a3c7a839cef24", "ccdac541d91b9237", "dcdd9c43634f189a", "b3ccd03f4cb11758", "f48b6995d4cf02b1", "525bf524bcb65692", "198964c9cb682cae", "eff64b09e12f8680"]}

app.py

@@ -0,0 +1,116 @@
+import os
+import traceback
+import logging
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+from werkzeug.utils import secure_filename
+from dotenv import load_dotenv
+
+from utils.anticheat import AntiCheatEngine
+from utils.predictor import Predictor
+from utils.verdict import get_verdict
+
+load_dotenv()
+
+# Setup logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Initialize components
+app = Flask(__name__)
+CORS(app, resources={r"/*": {"origins": "*"}}, supports_credentials=True)
+
+ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'webp'}
+app.config['MAX_CONTENT_LENGTH'] = 100 * 1024 * 1024  # Limit upload to 100MB
+
+logger.info("🧠 Loading the MISSION 17 AI Brain (Ollama Vision)...")
+anticheat = AntiCheatEngine()
+predictor = Predictor()
+
+def allowed_file(filename):
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+@app.after_request
+def after_request(response):
+    response.headers.add('Access-Control-Allow-Origin', '*')
+    response.headers.add('Access-Control-Allow-Headers', 'Content-Type,Authorization')
+    response.headers.add('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE,OPTIONS')
+    return response
+
+@app.route('/health', methods=['GET'])
+def health():
+    return jsonify({
+        "status": "ok",
+        "model": predictor.get_model_name(),
+        "anticheat_hashes": anticheat.count()
+    }), 200
+
+@app.route('/reset-anti-cheat', methods=['POST', 'GET'])
+def reset_anti_cheat():
+    count = anticheat.clear()
+    logger.info("🛡️ Anti-cheat hash database cleared!")
+    return jsonify({"message": "Anti-cheat hash database cleared!", "count": count}), 200
+
+@app.route('/predict', methods=['POST'])
+def predict():
+    try:
+        # 🔒 CHECK 1: File Presence
+        if 'file' not in request.files:
+            return jsonify({'error': 'No file uploaded'}), 400
+        
+        file = request.files['file']
+
+        # 🔒 CHECK 2: Empty File Detection (Bug Fix)
+        file.seek(0, os.SEEK_END)
+        if file.tell() == 0:
+            return jsonify({"error": "Processing failed: Empty file"}), 400
+        file.seek(0)
+
+        # 🔒 CHECK 3: Empty Filename
+        if file.filename == '':
+            return jsonify({'error': 'No selected file'}), 400
+
+        # 🔒 CHECK 4: File Type Validation
+        if not allowed_file(file.filename):
+            return jsonify({'error': 'Invalid file type. Only JPG/PNG allowed.'}), 400
+
+        # Read file bytes ONCE and reuse them
+        file_bytes = file.read()
+        
+        # 🎯 MODULE 11: Calculate Hash and Check for Cheaters
+        if anticheat.is_duplicate(file_bytes):
+            logger.warning("🚨 ANTI-CHEAT: Duplicate image detected!")
+            return jsonify({
+                "status": "REJECTED",
+                "error": "Duplicate image detected. You cannot farm points!",
+                "prediction": "Anti-Cheat: Duplicate"
+            }), 400
+            
+        # 🤖 AI Vision Prediction via Ollama
+        logger.info("🤖 Sending image to Ollama Vision...")
+        ai_result = predictor.predict(file_bytes)
+        
+        category = ai_result.get('category', 'Non_SDG_Invalid')
+        confidence = ai_result.get('confidence', 0)
+        reason = ai_result.get('reason', '')
+        
+        # ⚖️ Get formatted verdict based on AI output
+        verdict_response = get_verdict(category, confidence, threshold=55)
+        verdict_response['reason'] = reason
+        verdict_response['model'] = predictor.get_model_name()
+
+        # Only register hash if the image was VERIFIED (save memory/prevent false positives on bad images)
+        if verdict_response['is_verified']:
+            anticheat.register(file_bytes)
+            logger.info(f"✅ Unique verified image logged to anticheat.")
+
+        return jsonify(verdict_response)
+
+    except Exception as e:
+        logger.error(f"❌ Processing Error: {str(e)}")
+        traceback.print_exc()
+        return jsonify({'error': "Processing failed", 'detail': str(e)}), 500
+
+if __name__ == '__main__':
+    # Hugging Face requires the app to listen on 0.0.0.0:7860
+    app.run(host='0.0.0.0', port=7860, debug=False)

labels.txt

@@ -0,0 +1,10 @@
+Non_SDG_Invalid
+SDG11_Sustainable_Cities
+SDG12_Recycling
+SDG13_15_Planting
+SDG1_2_Donation
+SDG3_Health_Wellbeing
+SDG4_Quality_Education
+SDG6_14_Cleanup
+SDG7_Clean_Energy
+SDG8_Support_Local

mission_model.h5

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

requirements.txt

@@ -0,0 +1,10 @@
+Flask==2.2.2
+Flask-Cors==3.0.10
+numpy
+Pillow
+imagehash
+gunicorn
+tensorflow
+scikit-learn
+matplotlib
+seaborn

runtime.txt

@@ -0,0 +1 @@
+3.11.9

scripts/data_prep/balance_dataset.py

@@ -0,0 +1,85 @@
+import os
+import shutil
+import random
+
+# 👇 CONFIGURATION
+CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
+DATASET_DIR = os.path.join(CURRENT_DIR, '..', '..', '..', 'dataset', 'mission_dataset')
+
+# Target: balance ALL classes to this count
+# Set to None to auto-detect the median (safe default)
+TARGET_COUNT = 500
+
+
+def count_classes(dataset_dir):
+    counts = {}
+    for class_name in os.listdir(dataset_dir):
+        class_path = os.path.join(dataset_dir, class_name)
+        if os.path.isdir(class_path):
+            images = [
+                f for f in os.listdir(class_path)
+                if f.lower().endswith(('.jpg', '.jpeg', '.png', '.webp'))
+            ]
+            counts[class_name] = len(images)
+    return counts
+
+
+def balance_dataset():
+    print(f"⚖️  Balancing ALL classes in: {DATASET_DIR}\n")
+
+    if not os.path.exists(DATASET_DIR):
+        print("❌ Error: Dataset folder not found.")
+        return
+
+    counts = count_classes(DATASET_DIR)
+
+    if not counts:
+        print("❌ No class folders found.")
+        return
+
+    # Determine target
+    target = TARGET_COUNT
+    if target is None:
+        sorted_counts = sorted(counts.values())
+        target = sorted_counts[len(sorted_counts) // 2]  # median
+        print(f"📊 Auto-detected target (median): {target} images per class\n")
+    else:
+        print(f"📊 Target: {target} images per class\n")
+
+    print(f"{'Class':<35} {'Before':>8} {'After':>8} {'Action'}")
+    print("-" * 65)
+
+    for class_name, count in sorted(counts.items()):
+        class_path = os.path.join(DATASET_DIR, class_name)
+        images = [
+            f for f in os.listdir(class_path)
+            if f.lower().endswith(('.jpg', '.jpeg', '.png', '.webp'))
+        ]
+
+        if count > target:
+            # Trim to target — shuffle first to keep a random selection
+            random.shuffle(images)
+            excess = images[target:]
+            for img in excess:
+                os.remove(os.path.join(class_path, img))
+            after = target
+            action = f"✂️  Trimmed -{len(excess)}"
+
+        elif count < target:
+            # Class is under-represented — warn user to add more images
+            after = count
+            action = f"⚠️  Under-represented (need +{target - count} more images)"
+
+        else:
+            after = count
+            action = "✅ OK"
+
+        print(f"{class_name:<35} {count:>8} {after:>8}   {action}")
+
+    print("\n✨ Balancing complete! Now run train_ai.py to retrain the model.")
+    print("   💡 TIP: For under-represented classes, collect more real photos")
+    print("           or use Google Images to download additional training data.")
+
+
+if __name__ == "__main__":
+    balance_dataset()

scripts/data_prep/collect_data.py

@@ -0,0 +1,221 @@
+from bing_image_downloader import downloader
+import os
+import shutil
+import math
+
+# 👇 CONFIGURATION
+BASE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '..', '..', 'dataset', 'mission_dataset')
+
+# Target images per class — everything will be brought up to this number
+TARGET = 500
+
+# ─────────────────────────────────────────────────────────────────────────────
+# CLASS DEFINITIONS
+# Each class has:
+#   "current": how many images it already has
+#   "terms":   list of 5 search terms to download from
+#
+# limit_per_term = ceil((TARGET - current) / len(terms))
+# Classes already at TARGET are automatically skipped.
+# ─────────────────────────────────────────────────────────────────────────────
+CLASSES = {
+
+    # 🍱 SDG 1/2: Donation — WEAKEST CLASS (150 → 500, needs +350, 70/term)
+    "SDG1_2_Donation": {
+        "current": 150,
+        "terms": [
+            "people donating food to community",
+            "clothes donation box charity",
+            "feeding program volunteers serving food",
+            "grocery donation drive event",
+            "charity relief goods distribution"
+        ]
+    },
+
+    # 🏖️ SDG 6/14: Cleanup — WEAKEST CLASS (150 → 500, needs +350, 70/term)
+    "SDG6_14_Cleanup": {
+        "current": 150,
+        "terms": [
+            "beach cleanup volunteers collecting trash",
+            "river cleanup community activity",
+            "coastal cleanup garbage bags collected",
+            "people picking up litter shoreline",
+            "estero creek waterway cleanup"
+        ]
+    },
+
+    # 📚 SDG 4: Education (253 → 500, needs +247, 50/term)
+    "SDG4_Quality_Education": {
+        "current": 253,
+        "terms": [
+            "student reading open book",
+            "teacher writing on whiteboard classroom",
+            "group study session library",
+            "hand writing notes in notebook",
+            "child using educational tablet learning"
+        ]
+    },
+
+    # 🏃 SDG 3: Health (262 → 500, needs +238, 48/term)
+    "SDG3_Health_Wellbeing": {
+        "current": 262,
+        "terms": [
+            "people jogging in park",
+            "group yoga session outdoors",
+            "eating fresh fruit salad bowl",
+            "drinking glass of water healthy",
+            "washing hands with soap hygiene"
+        ]
+    },
+
+    # 🛍️ SDG 8: Support Local (267 → 500, needs +233, 47/term)
+    "SDG8_Support_Local": {
+        "current": 267,
+        "terms": [
+            "buying from street food vendor",
+            "shopping at local farmers market",
+            "artisan crafting handmade goods",
+            "small bakery local shop front",
+            "supporting small business community"
+        ]
+    },
+
+    # 🌱 SDG 13/15: Planting (270 → 500, needs +230, 46/term)
+    "SDG13_15_Planting": {
+        "current": 270,
+        "terms": [
+            "person planting tree sapling",
+            "community tree planting activity",
+            "garden seedling transplanting soil",
+            "plant growing hands holding soil",
+            "reforestation volunteers planting trees"
+        ]
+    },
+
+    # 🏙️ SDG 11: Sustainable Cities (275 → 500, needs +225, 45/term)
+    "SDG11_Sustainable_Cities": {
+        "current": 275,
+        "terms": [
+            "riding bicycle on city road",
+            "passengers inside public city bus",
+            "waiting at train station platform",
+            "walking on pedestrian crossing street",
+            "segregated bike lane urban city"
+        ]
+    },
+
+    # ⚡ SDG 7: Clean Energy (277 → 500, needs +223, 45/term)
+    "SDG7_Clean_Energy": {
+        "current": 277,
+        "terms": [
+            "solar panels on house roof",
+            "hand turning off light switch",
+            "electric vehicle charging station",
+            "wind turbine farm landscape",
+            "modern led light bulb energy saving"
+        ]
+    },
+
+    # 🚫 Non-SDG Invalid (430 → 500, needs +70, 14/term)
+    "Non_SDG_Invalid": {
+        "current": 430,
+        "terms": [
+            "random indoor selfie photo",
+            "luxury sports car fast",
+            "video game screenshot gaming",
+            "cat sleeping on sofa",
+            "abstract digital art wallpaper"
+        ]
+    },
+
+    # ♻️ SDG 12: Recycling — ALREADY AT TARGET (500), will be skipped
+    "SDG12_Recycling": {
+        "current": 500,
+        "terms": []
+    },
+}
+
+# ─────────────────────────────────────────────────────────────────────────────
+
+print(f"🚀 Smart Data Collection — Target: {TARGET} images per class")
+print(f"   Dataset path: {BASE_DIR}\n")
+
+if not os.path.exists(BASE_DIR):
+    print(f"❌ ERROR: Could not find '{BASE_DIR}'. Check your folder structure.")
+    exit()
+
+total_added = 0
+
+for category, info in CLASSES.items():
+    current   = info["current"]
+    terms     = info["terms"]
+    needed    = TARGET - current
+
+    # Skip classes already at or above target
+    if needed <= 0:
+        print(f"⏭️  [{category}] already at {current}/{TARGET} — SKIPPED\n")
+        continue
+
+    limit_per_term = math.ceil(needed / len(terms))
+    target_dir = os.path.join(BASE_DIR, category)
+    os.makedirs(target_dir, exist_ok=True)
+
+    print(f"📂 [{category}]")
+    print(f"   {current} → {TARGET}  |  need +{needed}  |  {limit_per_term} images/term")
+
+    category_added = 0
+
+    for term in terms:
+        print(f"   🔍 '{term}' ({limit_per_term} images)...")
+        try:
+            downloader.download(
+                term,
+                limit=limit_per_term,
+                output_dir="temp_downloads",
+                adult_filter_off=True,
+                force_replace=False,
+                timeout=10,
+                verbose=False
+            )
+
+            source_folder = os.path.join("temp_downloads", term)
+            if os.path.exists(source_folder):
+                files = os.listdir(source_folder)
+                moved = 0
+                for file in files:
+                    old_path = os.path.join(source_folder, file)
+                    if not os.path.isfile(old_path):
+                        continue
+                    clean_term = term.replace(" ", "_")
+                    new_filename = f"{clean_term}_{file}"
+                    new_path = os.path.join(target_dir, new_filename)
+                    if os.path.exists(new_path):
+                        continue  # Skip duplicates
+                    try:
+                        shutil.move(old_path, new_path)
+                        moved += 1
+                    except Exception:
+                        pass
+                print(f"      ✅ +{moved} images")
+                category_added += moved
+
+        except Exception as e:
+            print(f"   ⚠️  Skipped '{term}': {e}")
+
+        # Clean up temp after each term
+        if os.path.exists("temp_downloads"):
+            try:
+                shutil.rmtree("temp_downloads")
+            except Exception:
+                pass
+
+    new_total = current + category_added
+    print(f"   📊 Result: {current} → {new_total} images (+{category_added})\n")
+    total_added += category_added
+
+print("=" * 55)
+print(f"✨ Done! Total new images added: {total_added}")
+print(f"   All classes should now be near {TARGET} images each.")
+print("\n   Next steps:")
+print("   1. python train_ai.py        ← retrain the model")
+print("   2. python evaluate_model.py  ← check accuracy")

scripts/data_prep/count_dataset.py

@@ -0,0 +1,43 @@
+import os
+
+def count_images():
+    # Define the path to the dataset
+    # Based on your other scripts, it is in ../dataset/mission_dataset
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+    dataset_dir = os.path.join(base_dir, '..', '..', '..', 'dataset', 'mission_dataset')
+
+    print(f"📊 Checking dataset at: {os.path.abspath(dataset_dir)}\n")
+
+    if not os.path.exists(dataset_dir):
+        print(f"❌ Error: Folder not found. Have you run 'organize_dataset.py'?")
+        return
+
+    total_images = 0
+    
+    # Get all subfolders (classes)
+    try:
+        classes = [d for d in os.listdir(dataset_dir) if os.path.isdir(os.path.join(dataset_dir, d))]
+        classes.sort()
+    except Exception as e:
+        print(f"❌ Error reading directory: {e}")
+        return
+
+    print(f"{'CLASS NAME':<35} | {'COUNT':<10} | {'STATUS'}")
+    print("-" * 50)
+
+    for class_name in classes:
+        class_path = os.path.join(dataset_dir, class_name)
+        # Count files that look like images
+        images = [f for f in os.listdir(class_path) if f.lower().endswith(('.png', '.jpg', '.jpeg', '.webp', '.bmp'))]
+        count = len(images)
+        
+        status = "✅ Ready" if count >= 100 else "⚠️ Low Data" if count > 0 else "❌ Empty"
+        
+        print(f"{class_name:<35} | {count:<10} | {status}")
+        total_images += count
+
+    print("-" * 50)
+    print(f"✅ TOTAL IMAGES: {total_images}")
+
+if __name__ == "__main__":
+    count_images()

scripts/data_prep/fix_dataset.py

@@ -0,0 +1,28 @@
+import os
+import shutil
+
+# Define paths
+import os
+base_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '..', '..', 'dataset', 'garbage_classification')
+old_planting = os.path.join(base_dir, "planting")
+new_planting = os.path.join(base_dir, "SDG13_15_Planting")
+
+# Create new folder if it doesn't exist
+if not os.path.exists(new_planting):
+    os.makedirs(new_planting)
+
+# Move files from Old -> New
+if os.path.exists(old_planting):
+    print(f"🔄 Moving files from '{old_planting}' to '{new_planting}'...")
+    files = os.listdir(old_planting)
+    for file in files:
+        old_path = os.path.join(old_planting, file)
+        new_path = os.path.join(new_planting, f"old_{file}") # Rename to avoid conflicts
+        shutil.move(old_path, new_path)
+    
+    # Delete the empty old folder
+    os.rmdir(old_planting)
+    print("✅ Successfully merged folders!")
+    print("🗑️  Deleted old 'planting' folder.")
+else:
+    print("⚠️  Old 'planting' folder not found. Already merged?")

scripts/data_prep/organize_dataset.py

@@ -0,0 +1,91 @@
+import os
+import shutil
+
+# 👇 CONFIGURATION
+# Current script directory
+CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
+# The main project dataset folder (../dataset)
+BASE_DIR = os.path.join(CURRENT_DIR, '..', '..', '..', 'dataset')
+
+# 1. The "Correct" Destination
+FINAL_DEST = os.path.join(BASE_DIR, "mission_dataset")
+
+# 2. The "Old" Kaggle Dataset
+OLD_GARBAGE_DIR = os.path.join(BASE_DIR, "garbage_classification")
+
+# 3. The "Misplaced" Downloads (if any) inside mission17-ai/dataset
+MISPLACED_DIR = os.path.join(CURRENT_DIR, '..', '..', "dataset", "mission_dataset")
+
+# Map OLD folders to NEW SDG destinations
+# We are putting ALL waste items into SDG12 (Responsible Consumption & Production)
+MOVES = {
+    "SDG12_Recycling": [
+        "battery", "brown-glass", "cardboard", 
+        "clothes", "green-glass", "metal", "paper", 
+        "plastic", "shoes", "white-glass"
+    ],
+    "Non_SDG_Invalid": [
+        "trash", "biological"
+    ]
+}
+
+def organize_files():
+    print(f"📦 Organizing dataset...")
+    
+    # Ensure destination exists
+    if not os.path.exists(FINAL_DEST):
+        os.makedirs(FINAL_DEST)
+        print(f"   ✅ Created '{FINAL_DEST}'")
+
+    # --- STEP 1: Merge Kaggle Data ---
+    if os.path.exists(OLD_GARBAGE_DIR):
+        print(f"   🔄 Merging 'garbage_classification'...")
+        for dest_folder, source_folders in MOVES.items():
+            dest_path = os.path.join(FINAL_DEST, dest_folder)
+            if not os.path.exists(dest_path): os.makedirs(dest_path)
+
+            for folder in source_folders:
+                src_path = os.path.join(OLD_GARBAGE_DIR, folder)
+                if os.path.exists(src_path):
+                    # Move files
+                    for file in os.listdir(src_path):
+                        try:
+                            shutil.move(os.path.join(src_path, file), os.path.join(dest_path, f"{folder}_{file}"))
+                        except Exception: pass
+                    # Remove empty folder
+                    try:
+                        os.rmdir(src_path)
+                    except: pass
+        
+        # Try to remove root garbage dir
+        try: os.rmdir(OLD_GARBAGE_DIR)
+        except: pass
+        print("   ✅ Kaggle data merged.")
+
+    # --- STEP 2: Fix Misplaced Downloads ---
+    if os.path.exists(MISPLACED_DIR):
+        print(f"   ⚠️ Found misplaced images in '{MISPLACED_DIR}'. Moving them...")
+        for category in os.listdir(MISPLACED_DIR):
+            src = os.path.join(MISPLACED_DIR, category)
+            dest = os.path.join(FINAL_DEST, category)
+            
+            if os.path.isdir(src):
+                if not os.path.exists(dest): os.makedirs(dest)
+                for file in os.listdir(src):
+                    try:
+                        shutil.move(os.path.join(src, file), os.path.join(dest, file))
+                    except: pass
+                try: os.rmdir(src)
+                except: pass
+        
+        # Cleanup parent 'dataset' in mission17-ai if empty
+        try: 
+            os.rmdir(MISPLACED_DIR)
+            os.rmdir(os.path.join(CURRENT_DIR, '..', '..', "dataset"))
+        except: pass
+        print("   ✅ Misplaced images moved to correct folder.")
+
+    print(f"\n✨ SUCCESS! Dataset is ready at: {FINAL_DEST}")
+
+if __name__ == "__main__":
+    organize_files()

scripts/testing/split_dataset.py

@@ -0,0 +1,73 @@
+import os
+import shutil
+import random
+from pathlib import Path
+
+# --- CONFIGURATION ---
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATASET_DIR = os.path.join(BASE_DIR, '..', '..', '..', 'dataset', 'mission_dataset')
+OUTPUT_DIR = os.path.join(BASE_DIR, '..', '..', '..', 'dataset', 'mission_dataset_split')
+
+# Split ratios
+TRAIN_RATIO = 0.80
+TEST_RATIO = 0.20
+
+def split_dataset():
+    """
+    Randomly splits the dataset into train/ and test/ folders.
+    This prevents 'Data Leakage' so your evaluate_model.py tests on truly unseen images.
+    """
+    print(f"🚀 Splitting dataset: {DATASET_DIR}")
+    print(f"   Outputting to: {OUTPUT_DIR}")
+
+    if not os.path.exists(DATASET_DIR):
+        print(f"❌ ERROR: Dataset not found at {DATASET_DIR}")
+        return
+
+    # Create output directories
+    train_dir = os.path.join(OUTPUT_DIR, 'train')
+    test_dir = os.path.join(OUTPUT_DIR, 'test')
+
+    os.makedirs(train_dir, exist_ok=True)
+    os.makedirs(test_dir, exist_ok=True)
+
+    classes = [d for d in os.listdir(DATASET_DIR) if os.path.isdir(os.path.join(DATASET_DIR, d))]
+
+    total_moved = 0
+
+    for class_name in classes:
+        class_path = os.path.join(DATASET_DIR, class_name)
+        images = [f for f in os.listdir(class_path) if f.lower().endswith(('.png', '.jpg', '.jpeg', '.webp'))]
+        
+        # Shuffle images randomly
+        random.shuffle(images)
+        
+        # Calculate split index
+        split_idx = int(len(images) * TRAIN_RATIO)
+        
+        train_images = images[:split_idx]
+        test_images = images[split_idx:]
+        
+        # Create class folders in train/ and test/
+        os.makedirs(os.path.join(train_dir, class_name), exist_ok=True)
+        os.makedirs(os.path.join(test_dir, class_name), exist_ok=True)
+
+        print(f"📁 [{class_name}] Total: {len(images)} -> Train: {len(train_images)}, Test: {len(test_images)}")
+
+        # Copy files
+        for img in train_images:
+            shutil.copy2(os.path.join(class_path, img), os.path.join(train_dir, class_name, img))
+            total_moved += 1
+            
+        for img in test_images:
+            shutil.copy2(os.path.join(class_path, img), os.path.join(test_dir, class_name, img))
+            total_moved += 1
+
+    print("=" * 50)
+    print(f"✅ Dataset split complete! {total_moved} images processed.")
+    print("   Next steps:")
+    print("   1. Check the new folder 'mission_dataset_split'")
+    print("   2. Run train_ai_v2.py (which now points to this new folder)")
+
+if __name__ == '__main__':
+    split_dataset()

scripts/testing/test_duplicate.py

@@ -0,0 +1,16 @@
+import requests
+
+url = "http://localhost:5000/predict"
+file_path = "debug_bias_mitigation.jpg"
+
+print("--- First Upload ---")
+with open(file_path, "rb") as f:
+    r = requests.post(url, files={"file": f})
+    print(f"Status: {r.status_code}")
+    print(f"Response: {r.text}")
+
+print("\n--- Second Upload ---")
+with open(file_path, "rb") as f:
+    r = requests.post(url, files={"file": f})
+    print(f"Status: {r.status_code}")
+    print(f"Response: {r.text}")

scripts/testing/test_predictor.py

@@ -0,0 +1,27 @@
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+from utils.predictor import Predictor
+
+
+def test_ollama():
+    print("Testing Ollama Predictor...")
+    p = Predictor()
+    print(f"Model configured: {p.get_model_name()}")
+    
+    # We will just see if we can reach the API
+    # Since we need an image, let's create a dummy 1x1 black pixel image
+    import io
+    from PIL import Image
+    
+    img = Image.new('RGB', (10, 10), color = 'black')
+    img_byte_arr = io.BytesIO()
+    img.save(img_byte_arr, format='PNG')
+    img_bytes = img_byte_arr.getvalue()
+    
+    print("Sending dummy image to Ollama...")
+    res = p.predict(img_bytes)
+    print("Response:", res)
+
+if __name__ == "__main__":
+    test_ollama()

scripts/testing/test_upload.html

@@ -0,0 +1,61 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Mission 17 AI Scanner</title>
+    <style>
+        body { font-family: 'Segoe UI', sans-serif; text-align: center; padding: 50px; background-color: #f4f4f9; }
+        .card { background: white; padding: 40px; border-radius: 15px; box-shadow: 0 4px 15px rgba(0,0,0,0.1); display: inline-block; max-width: 400px; }
+        button { background: #007bff; color: white; border: none; padding: 12px 24px; border-radius: 5px; cursor: pointer; font-size: 16px; margin-top: 15px; }
+        button:hover { background: #0056b3; }
+        #result { margin-top: 25px; font-weight: bold; }
+        .verified { color: #28a745; background: #e6fffa; padding: 15px; border-radius: 8px; border: 1px solid #28a745; }
+        .rejected { color: #dc3545; background: #fff5f5; padding: 15px; border-radius: 8px; border: 1px solid #dc3545; }
+    </style>
+</head>
+<body>
+    <div class="card">
+        <h2>🤖 Mission 17 AI Scanner</h2>
+        <p>Upload a photo to verify your mission!</p>
+        
+        <input type="file" id="fileInput" accept="image/*">
+        <br>
+        <button onclick="scanImage()">🔍 Scan Mission</button>
+
+        <div id="result"></div>
+    </div>
+
+    <script>
+        async function scanImage() {
+            const fileInput = document.getElementById('fileInput');
+            const resultDiv = document.getElementById('result');
+            
+            if (!fileInput.files[0]) {
+                alert("Please select an image first!");
+                return;
+            }
+
+            resultDiv.innerHTML = "⏳ Scanning...";
+            
+            const formData = new FormData();
+            formData.append("file", fileInput.files[0]);
+
+            try {
+                const response = await fetch("http://127.0.0.1:5000/predict", { method: "POST", body: formData });
+                const data = await response.json();
+                
+                const colorClass = data.verdict === "VERIFIED" ? "verified" : "rejected";
+                resultDiv.innerHTML = `
+                    <div class="${colorClass}">
+                        <h3>${data.message}</h3>
+                        <p><strong>📷 Type:</strong> ${data.source_check}</p>
+                        <p><strong>🎯 Accuracy:</strong> ${data.confidence}</p>
+                        <p><strong>🌍 SDG:</strong> ${data.sdg}</p>
+                    </div>`;
+            } catch (error) {
+                resultDiv.innerHTML = "❌ Error connecting to server. Is app.py running?";
+            }
+        }
+    </script>
+</body>
+</html>

scripts/training/download_pangasinan.py

@@ -0,0 +1,46 @@
+import json
+import os
+from datasets import load_dataset
+
+print("Downloading dataset leklek02/pangasinan...")
+ds = load_dataset("leklek02/pangasinan", split="train")
+
+print(f"Total rows downloaded: {len(ds)}")
+
+# 1. Create Few-Shot Examples (Top 100 to keep the prompt size reasonable)
+examples = []
+for i in range(min(100, len(ds))):
+    row = ds[i]
+    user_text = str(row['instruction'])
+    if row.get('input') and str(row['input']).strip():
+        user_text += "\n" + str(row['input'])
+    
+    examples.append({
+        "User": user_text,
+        "Bot": str(row['output'])
+    })
+
+backend_path = r"c:\Users\Kurt Perez\mission17\mission17-backend\utils\pangasinan_examples.json"
+os.makedirs(os.path.dirname(backend_path), exist_ok=True)
+with open(backend_path, "w", encoding="utf-8") as f:
+    json.dump(examples, f, indent=2, ensure_ascii=False)
+print(f"Saved 100 examples to {backend_path} for immediate use in Chatbot.")
+
+# 2. Create Gemini Tuning JSONL (All rows for future Fine-Tuning)
+tuning_path = r"c:\Users\Kurt Perez\mission17\dataset\gemini_pangasinan_tuning.jsonl"
+os.makedirs(os.path.dirname(tuning_path), exist_ok=True)
+with open(tuning_path, "w", encoding="utf-8") as f:
+    for row in ds:
+        user_text = str(row['instruction'])
+        if row.get('input') and str(row['input']).strip():
+            user_text += "\n" + str(row['input'])
+            
+        jsonl_obj = {
+            "contents": [
+                {"role": "user", "parts": [{"text": user_text}]},
+                {"role": "model", "parts": [{"text": str(row['output'])}]}
+            ]
+        }
+        f.write(json.dumps(jsonl_obj, ensure_ascii=False) + "\n")
+        
+print(f"Saved full tuning dataset to {tuning_path} (Upload this to Google AI Studio to fine-tune Gemini!)")

scripts/training/evaluate_model.py

@@ -0,0 +1,57 @@
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+from tensorflow.keras.applications.efficientnet import preprocess_input
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix
+import matplotlib.pyplot as plt
+import seaborn as sns
+import os
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+print("⏳ Loading AI Model...")
+# 👇 Ensure this is your correct model name!
+model = tf.keras.models.load_model(os.path.join(BASE_DIR, '..', '..', 'mission_model.h5')) 
+
+print("📁 Loading Test Dataset...")
+# 👇 Pointing to the new TEST split folder
+test_dir = os.path.join(BASE_DIR, '..', '..', '..', 'dataset', 'mission_dataset_split', 'test')
+
+test_datagen = ImageDataGenerator(preprocessing_function=preprocess_input)
+test_generator = test_datagen.flow_from_directory(
+    test_dir,
+    target_size=(224, 224), 
+    batch_size=32,
+    class_mode='categorical',
+    shuffle=False
+)
+
+print("🤖 Running Predictions (This may take a minute)...")
+Y_pred = model.predict(test_generator)
+y_pred_classes = np.argmax(Y_pred, axis=1) # 👈 FIXED: Grabs the top prediction per image
+y_true = test_generator.classes
+
+print("\n" + "="*50)
+print("🏆 CAPSTONE AI PERFORMANCE METRICS 🏆")
+print("="*50)
+
+# 👈 FIXED: Added average='weighted' to handle all 10 classes correctly
+accuracy = accuracy_score(y_true, y_pred_classes)
+precision = precision_score(y_true, y_pred_classes, average='weighted', zero_division=0)
+recall = recall_score(y_true, y_pred_classes, average='weighted', zero_division=0)
+f1 = f1_score(y_true, y_pred_classes, average='weighted', zero_division=0)
+
+print(f"✅ Accuracy:  {accuracy * 100:.2f}%")
+print(f"🎯 Precision: {precision * 100:.2f}%")
+print(f"🔍 Recall:    {recall * 100:.2f}%")
+print(f"⚖️ F1-Score:  {f1 * 100:.2f}%")
+print("="*50)
+
+# Make the confusion matrix chart larger to fit 10 classes
+cm = confusion_matrix(y_true, y_pred_classes)
+plt.figure(figsize=(10, 8))
+sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
+plt.title('AI Confusion Matrix (10 Classes)')
+plt.ylabel('Actual Image Class')
+plt.xlabel('AI Prediction')
+plt.savefig(os.path.join(BASE_DIR, '..', '..', 'outputs', 'confusion_matrix.png'))
+print("\n📊 Saved 'confusion_matrix.png' to your outputs folder. Put this in your presentation!")

scripts/training/train_ai.py

@@ -0,0 +1,209 @@
+import os
+import tensorflow as tf
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+from tensorflow.keras.applications import EfficientNetB0
+from tensorflow.keras.applications.efficientnet import preprocess_input
+from tensorflow.keras.layers import Dense, GlobalAveragePooling2D, Dropout, BatchNormalization
+from tensorflow.keras.models import Model
+from tensorflow.keras.optimizers import Adam
+from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint
+
+# --- CONFIGURATION ---
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATASET_DIR = os.path.join(BASE_DIR, '..', '..', '..', 'dataset', 'mission_dataset')
+MODEL_SAVE_PATH = os.path.join(BASE_DIR, '..', '..', 'mission_model.h5')
+LABELS_SAVE_PATH = os.path.join(BASE_DIR, '..', '..', 'labels.txt')
+
+# Hyperparameters
+IMG_SIZE = (224, 224)
+BATCH_SIZE = 32
+EPOCHS_INITIAL = 25      # Phase 1: Train top layers only
+EPOCHS_FINETUNE = 15     # Phase 2: Fine-tune top base layers
+LR_INITIAL = 1e-3        # Higher LR for initial training
+LR_FINETUNE = 1e-5       # Much lower LR for fine-tuning (prevents forgetting)
+FINETUNE_FROM_LAYER = 150  # Unfreeze EfficientNetB0 from this layer onwards
+
+def build_generators():
+    """Create training and validation data generators with strong augmentation."""
+    print("📸 Preparing Image Generators with Strong Augmentation...")
+
+    # 🔥 EfficientNetB0 has its own internal preprocessing — do NOT use rescale=1./255!
+    # Using preprocess_input correctly scales raw 0-255 pixel values for EfficientNet.
+    train_datagen = ImageDataGenerator(
+        preprocessing_function=preprocess_input,  # ✅ EfficientNetB0-compatible
+        rotation_range=30,
+        width_shift_range=0.2,
+        height_shift_range=0.2,
+        horizontal_flip=True,
+        brightness_range=[0.7, 1.3],
+        zoom_range=0.2,
+        shear_range=0.1,
+        channel_shift_range=20.0,
+        fill_mode='nearest',
+        validation_split=0.2
+    )
+
+    # Validation: only preprocess_input, NO augmentation
+    val_datagen = ImageDataGenerator(
+        preprocessing_function=preprocess_input,  # ✅ Must match training
+        validation_split=0.2
+    )
+
+    train_generator = train_datagen.flow_from_directory(
+        DATASET_DIR,
+        target_size=IMG_SIZE,
+        batch_size=BATCH_SIZE,
+        class_mode='categorical',
+        subset='training',
+        shuffle=True
+    )
+
+    validation_generator = val_datagen.flow_from_directory(
+        DATASET_DIR,
+        target_size=IMG_SIZE,
+        batch_size=BATCH_SIZE,
+        class_mode='categorical',
+        subset='validation',
+        shuffle=False
+    )
+
+    return train_generator, validation_generator
+
+
+def build_model(num_classes):
+    """
+    Build model using EfficientNetB0 (more accurate than MobileNetV2).
+    Phase 1 starts with all base layers FROZEN — only top layers train first.
+    """
+    print("🧠 Building Model (EfficientNetB0 — upgraded from MobileNetV2)...")
+
+    base_model = EfficientNetB0(
+        weights='imagenet',
+        include_top=False,
+        input_shape=IMG_SIZE + (3,)
+    )
+    base_model.trainable = False  # Freeze all base layers for Phase 1
+
+    x = base_model.output
+    x = GlobalAveragePooling2D()(x)
+    x = BatchNormalization()(x)          # ✨ NEW — stabilizes training
+    x = Dropout(0.3)(x)                  # was 0.2 — slightly stronger regularization
+    x = Dense(256, activation='relu')(x) # ✨ NEW — extra dense layer for richer features
+    x = Dropout(0.2)(x)
+    predictions = Dense(num_classes, activation='softmax')(x)
+
+    model = Model(inputs=base_model.input, outputs=predictions)
+    return model, base_model
+
+
+def get_callbacks(phase_name):
+    """Smart callbacks: stop early if no improvement, reduce LR on plateau."""
+    return [
+        EarlyStopping(
+            monitor='val_accuracy',
+            patience=5,              # Stop if no improvement for 5 epochs
+            restore_best_weights=True,
+            verbose=1
+        ),
+        ReduceLROnPlateau(
+            monitor='val_loss',
+            factor=0.5,              # Halve LR if stuck
+            patience=3,
+            min_lr=1e-7,
+            verbose=1
+        ),
+        ModelCheckpoint(
+            filepath=MODEL_SAVE_PATH,
+            monitor='val_accuracy',
+            save_best_only=True,     # Always keep the best checkpoint
+            verbose=1
+        )
+    ]
+
+
+def train_brain():
+    print("🚀 Initializing Mission 17 AI Training (Enhanced)...")
+
+    # 1. CHECK DATASET
+    if not os.path.exists(DATASET_DIR):
+        print(f"❌ ERROR: Dataset not found at {DATASET_DIR}")
+        return
+
+    # 2. BUILD GENERATORS
+    try:
+        train_generator, validation_generator = build_generators()
+    except Exception as e:
+        print(f"❌ Error loading data: {e}")
+        return
+
+    if train_generator.samples == 0:
+        print("❌ No images found! Check your dataset structure.")
+        return
+
+    # 3. SAVE LABELS
+    class_names = list(train_generator.class_indices.keys())
+    print(f"🏷️  Classes Detected: {class_names}")
+    with open(LABELS_SAVE_PATH, 'w') as f:
+        for name in class_names:
+            f.write(name + '\n')
+    print(f"✅ Labels saved to {LABELS_SAVE_PATH}")
+
+    num_classes = len(class_names)
+
+    # 4. BUILD MODEL
+    model, base_model = build_model(num_classes)
+
+    # ════════════════════════════════════════════
+    # PHASE 1: Train top layers only (fast)
+    # ════════════════════════════════════════════
+    print("\n" + "="*50)
+    print("🏋️  PHASE 1: Training Top Layers (Base Frozen)")
+    print("="*50)
+
+    model.compile(
+        optimizer=Adam(learning_rate=LR_INITIAL),
+        loss='categorical_crossentropy',
+        metrics=['accuracy']
+    )
+
+    model.fit(
+        train_generator,
+        epochs=EPOCHS_INITIAL,
+        validation_data=validation_generator,
+        callbacks=get_callbacks('phase1')
+    )
+
+    # ════════════════════════════════════════════
+    # PHASE 2: Fine-tune top layers of base model
+    # ════════════════════════════════════════════
+    print("\n" + "="*50)
+    print("🔬 PHASE 2: Fine-Tuning Top Base Layers")
+    print(f"   Unfreezing EfficientNetB0 from layer {FINETUNE_FROM_LAYER}+")
+    print("="*50)
+
+    base_model.trainable = True
+
+    # Only unfreeze layers AFTER FINETUNE_FROM_LAYER — keep earlier layers frozen
+    for layer in base_model.layers[:FINETUNE_FROM_LAYER]:
+        layer.trainable = False
+
+    # CRITICAL: Recompile with much lower LR to avoid destroying pre-trained weights
+    model.compile(
+        optimizer=Adam(learning_rate=LR_FINETUNE),
+        loss='categorical_crossentropy',
+        metrics=['accuracy']
+    )
+
+    model.fit(
+        train_generator,
+        epochs=EPOCHS_FINETUNE,
+        validation_data=validation_generator,
+        callbacks=get_callbacks('phase2')
+    )
+
+    print(f"\n✅ Training complete! Best model saved to {MODEL_SAVE_PATH}")
+    print("   Run evaluate_model.py to check accuracy metrics & confusion matrix.")
+
+
+if __name__ == '__main__':
+    train_brain()

scripts/training/train_ai_v2.py

@@ -0,0 +1,170 @@
+import os
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+from tensorflow.keras.applications import EfficientNetB0
+from tensorflow.keras.applications.efficientnet import preprocess_input
+from tensorflow.keras.layers import Dense, GlobalAveragePooling2D, Dropout, BatchNormalization
+from tensorflow.keras.models import Model
+from tensorflow.keras.optimizers import Adam
+from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint
+from sklearn.utils.class_weight import compute_class_weight
+
+# --- CONFIGURATION ---
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+# IMPORTANT: Pointing to the new split dataset folder
+DATASET_DIR = os.path.join(BASE_DIR, '..', '..', '..', 'dataset', 'mission_dataset_split', 'train')
+MODEL_SAVE_PATH = os.path.join(BASE_DIR, '..', '..', 'mission_model.h5')
+LABELS_SAVE_PATH = os.path.join(BASE_DIR, '..', '..', 'labels.txt')
+
+IMG_SIZE = (224, 224)
+BATCH_SIZE = 32
+EPOCHS_INITIAL = 20
+EPOCHS_FINETUNE = 15
+LR_INITIAL = 1e-3
+LR_FINETUNE = 1e-5
+
+def build_generators():
+    print("📸 Preparing Image Generators...")
+
+    train_datagen = ImageDataGenerator(
+        preprocessing_function=preprocess_input,
+        rotation_range=30,
+        width_shift_range=0.2,
+        height_shift_range=0.2,
+        horizontal_flip=True,
+        brightness_range=[0.7, 1.3],
+        zoom_range=0.2,
+        validation_split=0.2 # 20% of the train/ folder becomes validation
+    )
+
+    train_generator = train_datagen.flow_from_directory(
+        DATASET_DIR,
+        target_size=IMG_SIZE,
+        batch_size=BATCH_SIZE,
+        class_mode='categorical',
+        subset='training',
+        shuffle=True
+    )
+
+    validation_generator = train_datagen.flow_from_directory(
+        DATASET_DIR,
+        target_size=IMG_SIZE,
+        batch_size=BATCH_SIZE,
+        class_mode='categorical',
+        subset='validation',
+        shuffle=False
+    )
+
+    return train_generator, validation_generator
+
+def get_class_weights(train_generator):
+    """
+    Calculates class weights to handle imbalanced datasets.
+    This stops the AI from being biased toward the majority class.
+    """
+    print("⚖️ Calculating Class Weights for balanced training...")
+    class_indices = train_generator.class_indices
+    classes = train_generator.classes
+
+    weights = compute_class_weight(
+        class_weight='balanced',
+        classes=np.unique(classes),
+        y=classes
+    )
+    class_weights = dict(enumerate(weights))
+    
+    print("   Weights applied:")
+    for cls_name, cls_idx in class_indices.items():
+        print(f"   - {cls_name}: {class_weights[cls_idx]:.2f}")
+        
+    return class_weights
+
+def build_model(num_classes):
+    print("🧠 Building Model (EfficientNetB0)...")
+
+    base_model = EfficientNetB0(
+        weights='imagenet',
+        include_top=False,
+        input_shape=IMG_SIZE + (3,)
+    )
+    base_model.trainable = False 
+
+    x = base_model.output
+    x = GlobalAveragePooling2D()(x)
+    x = BatchNormalization()(x)
+    x = Dropout(0.3)(x)
+    x = Dense(256, activation='relu')(x)
+    x = BatchNormalization()(x)
+    x = Dropout(0.3)(x)
+    predictions = Dense(num_classes, activation='softmax')(x)
+
+    model = Model(inputs=base_model.input, outputs=predictions)
+    return model, base_model
+
+def get_callbacks(phase_name):
+    return [
+        EarlyStopping(monitor='val_accuracy', patience=5, restore_best_weights=True, verbose=1),
+        ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=3, min_lr=1e-7, verbose=1),
+        ModelCheckpoint(filepath=MODEL_SAVE_PATH, monitor='val_accuracy', save_best_only=True, verbose=1)
+    ]
+
+def train_brain():
+    print("🚀 Initializing Mission 17 AI Training v2 (Optimized)...")
+
+    if not os.path.exists(DATASET_DIR):
+        print(f"❌ ERROR: Training Dataset not found at {DATASET_DIR}")
+        print("   Did you run scripts/testing/split_dataset.py first?")
+        return
+
+    train_generator, validation_generator = build_generators()
+
+    # Save Labels
+    class_names = list(train_generator.class_indices.keys())
+    with open(LABELS_SAVE_PATH, 'w') as f:
+        for name in class_names:
+            f.write(name + '\n')
+            
+    num_classes = len(class_names)
+    
+    # Get Class Weights
+    class_weights = get_class_weights(train_generator)
+
+    model, base_model = build_model(num_classes)
+
+    # --- PHASE 1 ---
+    print("\n" + "="*50)
+    print("🏋️  PHASE 1: Training Top Layers (Base Frozen)")
+    print("="*50)
+
+    model.compile(optimizer=Adam(learning_rate=LR_INITIAL), loss='categorical_crossentropy', metrics=['accuracy'])
+    model.fit(
+        train_generator,
+        epochs=EPOCHS_INITIAL,
+        validation_data=validation_generator,
+        class_weight=class_weights, # Apply weights!
+        callbacks=get_callbacks('phase1')
+    )
+
+    # --- PHASE 2 ---
+    print("\n" + "="*50)
+    print("🔬 PHASE 2: Fine-Tuning Top Base Layers")
+    print("="*50)
+
+    base_model.trainable = True
+    for layer in base_model.layers[:150]:
+        layer.trainable = False
+
+    model.compile(optimizer=Adam(learning_rate=LR_FINETUNE), loss='categorical_crossentropy', metrics=['accuracy'])
+    model.fit(
+        train_generator,
+        epochs=EPOCHS_FINETUNE,
+        validation_data=validation_generator,
+        class_weight=class_weights, # Apply weights!
+        callbacks=get_callbacks('phase2')
+    )
+
+    print(f"\n✅ Training complete! Model saved to {MODEL_SAVE_PATH}")
+
+if __name__ == '__main__':
+    train_brain()

utils/__init__.py

@@ -0,0 +1 @@
+"""Utils module for Mission 17 AI."""

utils/anticheat.py

@@ -0,0 +1,98 @@
+import os
+import json
+import io
+import imagehash
+from PIL import Image
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+HASH_FILE = os.path.join(BASE_DIR, 'anticheat_hashes.json')
+
+class AntiCheatEngine:
+    def __init__(self):
+        self.hashes = set()
+        self._load_hashes()
+
+    def _load_hashes(self):
+        if os.path.exists(HASH_FILE):
+            try:
+                with open(HASH_FILE, 'r') as f:
+                    data = json.load(f)
+                    self.hashes = set(data.get("hashes", []))
+            except Exception as e:
+                print(f"⚠️ Could not load anticheat hashes: {e}")
+
+    def _save_hashes(self):
+        try:
+            with open(HASH_FILE, 'w') as f:
+                json.dump({"hashes": list(self.hashes)}, f)
+        except Exception as e:
+            print(f"⚠️ Could not save anticheat hashes: {e}")
+
+    def get_hashes(self, file_bytes):
+        """Calculates pHash and dHash for better duplicate detection."""
+        try:
+            img = Image.open(io.BytesIO(file_bytes)).convert('RGB')
+            p_hash = str(imagehash.phash(img))
+            d_hash = str(imagehash.dhash(img))
+            return p_hash, d_hash
+        except Exception:
+            return None, None
+
+    def is_duplicate(self, file_bytes, similarity_threshold=8):
+        """
+        Checks if the image is a duplicate based on stored hashes.
+        similarity_threshold: the max hamming distance to be considered a duplicate.
+        """
+        p_hash_str, d_hash_str = self.get_hashes(file_bytes)
+        
+        if not p_hash_str or not d_hash_str:
+            return False
+
+        # Check exact matches first for speed
+        if p_hash_str in self.hashes or d_hash_str in self.hashes:
+            return True
+
+        p_hash = imagehash.hex_to_hash(p_hash_str)
+        d_hash = imagehash.hex_to_hash(d_hash_str)
+
+        # Check similarity (hamming distance)
+        for stored_hash_str in self.hashes:
+            try:
+                stored_hash = imagehash.hex_to_hash(stored_hash_str)
+                # Compare both pHash and dHash representation lengths isn't an issue since they are stored as strings
+                # but we should compare apples to apples. Let's simplify and just do exact match on dHash and pHash, 
+                # but also check similarity if we parse them properly.
+                
+                # For safety, let's just do an exact match on string representations for now, 
+                # or a simple distance check if we assume all stored are pHashes.
+                # Since we store both, some might be dHash, some pHash. 
+                # Let's just compare distances safely.
+                distance = p_hash - stored_hash
+                if distance < similarity_threshold:
+                    return True
+                
+                distance = d_hash - stored_hash
+                if distance < similarity_threshold:
+                    return True
+            except Exception:
+                continue
+
+        return False
+
+    def register(self, file_bytes):
+        """Registers a new image hash to prevent future duplicates."""
+        p_hash_str, d_hash_str = self.get_hashes(file_bytes)
+        if p_hash_str:
+            self.hashes.add(p_hash_str)
+        if d_hash_str:
+            self.hashes.add(d_hash_str)
+        self._save_hashes()
+        return p_hash_str
+
+    def clear(self):
+        self.hashes.clear()
+        self._save_hashes()
+        return len(self.hashes)
+
+    def count(self):
+        return len(self.hashes)

utils/predictor.py

@@ -0,0 +1,109 @@
+import os
+import io
+import traceback
+import numpy as np
+from PIL import Image
+from tensorflow.keras.models import load_model
+from tensorflow.keras.applications.efficientnet import preprocess_input
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+MODEL_PATH = os.path.join(BASE_DIR, 'mission_model.h5')
+LABELS_PATH = os.path.join(BASE_DIR, 'labels.txt')
+
+class Predictor:
+    def __init__(self):
+        self.model = None
+        self.class_names = []
+        self._load_model()
+
+    def _load_model(self):
+        print("🧠 Loading TensorFlow CNN Brain...")
+        if not os.path.exists(MODEL_PATH):
+            print(f"❌ ERROR: {MODEL_PATH} not found. You need to train the model!")
+            return
+
+        try:
+            self.model = load_model(MODEL_PATH)
+            print("✅ Model loaded successfully!")
+        except Exception as e:
+            print(f"❌ Failed to load model: {e}")
+
+        # Load Labels
+        try:
+            with open(LABELS_PATH, 'r') as f:
+                self.class_names = [line.strip() for line in f.readlines()]
+            print(f"🏷️  Labels loaded: {self.class_names}")
+        except FileNotFoundError:
+            print("❌ ERROR: labels.txt not found.")
+            self.class_names = []
+
+        # 🔥 WARMUP STEP (Optimization)
+        if self.model:
+            print("🔥 Warming up model for instant first-prediction...")
+            dummy_image = np.zeros((1, 224, 224, 3), dtype=np.float32)
+            self.model.predict(dummy_image, verbose=0)
+            print("⚡ AI is fully optimized and ready!")
+
+    def predict(self, file_bytes):
+        """
+        Runs the image through the custom EfficientNet CNN.
+        """
+        if not self.model or not self.class_names:
+            return {"category": "Non_SDG_Invalid", "confidence": 0, "reason": "Model offline or missing."}
+
+        try:
+            # 1. Read image using PIL (just like in train_ai.py)
+            img = Image.open(io.BytesIO(file_bytes)).convert('RGB')
+
+            # 2. Resize to 224x224 (EfficientNetB0 input size)
+            img = img.resize((224, 224), Image.LANCZOS)
+
+            # 3. Apply EfficientNetB0 preprocess_input
+            img_array = np.array(img, dtype=np.float32)
+            img_array = preprocess_input(img_array)
+            img_array = np.expand_dims(img_array, axis=0)
+
+            # 4. Predict
+            predictions = self.model.predict(img_array)
+            score = predictions[0]
+
+            top_index = np.argmax(score)
+            label = self.class_names[top_index]
+            
+            confidence = int(np.max(score) * 100)
+
+            # Clean up label if it has the SDG prefix (e.g. SDG12_Recycling -> Recycling)
+            # The verdict.py MISSION_MAP expects "Recycling", "Planting", etc.
+            category = label
+            if "_" in label and label.startswith("SDG"):
+                # E.g. "SDG12_Recycling" -> "Recycling"
+                category = label.split("_", 1)[1]
+                # If there are multiple underscores (like SDG13_15_Planting), take the last part
+                if "_" in category:
+                    category = category.rsplit("_", 1)[-1]
+            elif label == "Non_SDG_Invalid":
+                category = "Non_SDG_Invalid"
+                
+            # Quick check for combined strings
+            if "Planting" in label: category = "Planting"
+            if "Cleanup" in label: category = "Cleanup"
+            if "Donation" in label: category = "Donation"
+            if "Cities" in label or "Sustainable" in label: category = "Sustainable_Cities"
+            if "Local" in label: category = "Support_Local"
+            if "Health" in label: category = "Health"
+            if "Energy" in label: category = "Energy"
+            if "Education" in label: category = "Education"
+
+            return {
+                "category": category,
+                "confidence": confidence,
+                "reason": f"Predicted {label} with {confidence}% confidence"
+            }
+
+        except Exception as e:
+            traceback.print_exc()
+            print(f"⚠️ Predictor error: {e}")
+            return {"category": "Non_SDG_Invalid", "confidence": 0, "reason": str(e)}
+
+    def get_model_name(self):
+        return "Custom CNN (mission_model.h5)"

utils/verdict.py

@@ -0,0 +1,42 @@
+# Maps AI prediction to (Verdict, Message, SDG)
+MISSION_MAP = {
+    "Planting":           ("VERIFIED", "✅ Valid Planting Mission (SDG 13/15)", "SDG 13/15"),
+    "Recycling":          ("VERIFIED", "✅ Valid Recycling Mission (SDG 12)",   "SDG 12"),
+    "Cleanup":            ("VERIFIED", "✅ Valid Cleanup Mission (SDG 6/14)",   "SDG 6/14"),
+    "Donation":           ("VERIFIED", "✅ Valid Donation Mission (SDG 1/2)",   "SDG 1/2"),
+    "Health":             ("VERIFIED", "✅ Valid Health & Wellness (SDG 3)",    "SDG 3"),
+    "Education":          ("VERIFIED", "✅ Valid Education Activity (SDG 4)",   "SDG 4"),
+    "Energy":             ("VERIFIED", "✅ Valid Energy Saving Action (SDG 7)", "SDG 7"),
+    "Sustainable_Cities": ("VERIFIED", "✅ Valid Sustainable Commute (SDG 11)", "SDG 11"),
+    "Support_Local":      ("VERIFIED", "✅ Valid Support for Local Biz (SDG 8)", "SDG 8"),
+    "Non_SDG_Invalid":    ("REJECTED", "⚠️ Image does not match any mission.",  "N/A"),
+}
+
+def get_verdict(category, confidence_percent, threshold=55):
+    """
+    Returns the final verdict response dictionary.
+    Requires a confidence of at least `threshold` for a VERIFIED verdict.
+    """
+    verdict, message, sdg = MISSION_MAP.get(category, ("REJECTED", "⚠️ Unknown Image Category.", "N/A"))
+    
+    is_verified = (verdict == "VERIFIED")
+
+    # If it's technically a valid category but confidence is too low
+    if is_verified and confidence_percent < threshold:
+        verdict = "UNCERTAIN"
+        message = f"❓ Unclear Image ({confidence_percent}%). Please take a clearer photo."
+        is_verified = False
+        sdg = "N/A"
+
+    source_check = "📸 Raw Picture" if is_verified else "🤖 AI Generated / Invalid"
+
+    return {
+        'prediction': category,
+        'confidence': f"{confidence_percent}%",
+        'confidence_raw': confidence_percent,
+        'verdict': verdict,
+        'message': message,
+        'is_verified': is_verified,
+        'sdg': sdg,
+        'source_check': source_check
+    }

venv/.gitignore

@@ -0,0 +1,2 @@
+# Created by venv; see https://docs.python.org/3/library/venv.html
+*

venv/Lib/site-packages/__pycache__/typing_extensions.cpython-311.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8579e0349d3763ed1ffe4345807900a184ffc9f6dacf47f1b52f7d8104f1640b
+size 179469

venv/Lib/site-packages/_distutils_hack/__init__.py

@@ -0,0 +1,222 @@
+# don't import any costly modules
+import sys
+import os
+
+
+is_pypy = '__pypy__' in sys.builtin_module_names
+
+
+def warn_distutils_present():
+    if 'distutils' not in sys.modules:
+        return
+    if is_pypy and sys.version_info < (3, 7):
+        # PyPy for 3.6 unconditionally imports distutils, so bypass the warning
+        # https://foss.heptapod.net/pypy/pypy/-/blob/be829135bc0d758997b3566062999ee8b23872b4/lib-python/3/site.py#L250
+        return
+    import warnings
+
+    warnings.warn(
+        "Distutils was imported before Setuptools, but importing Setuptools "
+        "also replaces the `distutils` module in `sys.modules`. This may lead "
+        "to undesirable behaviors or errors. To avoid these issues, avoid "
+        "using distutils directly, ensure that setuptools is installed in the "
+        "traditional way (e.g. not an editable install), and/or make sure "
+        "that setuptools is always imported before distutils."
+    )
+
+
+def clear_distutils():
+    if 'distutils' not in sys.modules:
+        return
+    import warnings
+
+    warnings.warn("Setuptools is replacing distutils.")
+    mods = [
+        name
+        for name in sys.modules
+        if name == "distutils" or name.startswith("distutils.")
+    ]
+    for name in mods:
+        del sys.modules[name]
+
+
+def enabled():
+    """
+    Allow selection of distutils by environment variable.
+    """
+    which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'local')
+    return which == 'local'
+
+
+def ensure_local_distutils():
+    import importlib
+
+    clear_distutils()
+
+    # With the DistutilsMetaFinder in place,
+    # perform an import to cause distutils to be
+    # loaded from setuptools._distutils. Ref #2906.
+    with shim():
+        importlib.import_module('distutils')
+
+    # check that submodules load as expected
+    core = importlib.import_module('distutils.core')
+    assert '_distutils' in core.__file__, core.__file__
+    assert 'setuptools._distutils.log' not in sys.modules
+
+
+def do_override():
+    """
+    Ensure that the local copy of distutils is preferred over stdlib.
+
+    See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401
+    for more motivation.
+    """
+    if enabled():
+        warn_distutils_present()
+        ensure_local_distutils()
+
+
+class _TrivialRe:
+    def __init__(self, *patterns):
+        self._patterns = patterns
+
+    def match(self, string):
+        return all(pat in string for pat in self._patterns)
+
+
+class DistutilsMetaFinder:
+    def find_spec(self, fullname, path, target=None):
+        # optimization: only consider top level modules and those
+        # found in the CPython test suite.
+        if path is not None and not fullname.startswith('test.'):
+            return
+
+        method_name = 'spec_for_{fullname}'.format(**locals())
+        method = getattr(self, method_name, lambda: None)
+        return method()
+
+    def spec_for_distutils(self):
+        if self.is_cpython():
+            return
+
+        import importlib
+        import importlib.abc
+        import importlib.util
+
+        try:
+            mod = importlib.import_module('setuptools._distutils')
+        except Exception:
+            # There are a couple of cases where setuptools._distutils
+            # may not be present:
+            # - An older Setuptools without a local distutils is
+            #   taking precedence. Ref #2957.
+            # - Path manipulation during sitecustomize removes
+            #   setuptools from the path but only after the hook
+            #   has been loaded. Ref #2980.
+            # In either case, fall back to stdlib behavior.
+            return
+
+        class DistutilsLoader(importlib.abc.Loader):
+            def create_module(self, spec):
+                mod.__name__ = 'distutils'
+                return mod
+
+            def exec_module(self, module):
+                pass
+
+        return importlib.util.spec_from_loader(
+            'distutils', DistutilsLoader(), origin=mod.__file__
+        )
+
+    @staticmethod
+    def is_cpython():
+        """
+        Suppress supplying distutils for CPython (build and tests).
+        Ref #2965 and #3007.
+        """
+        return os.path.isfile('pybuilddir.txt')
+
+    def spec_for_pip(self):
+        """
+        Ensure stdlib distutils when running under pip.
+        See pypa/pip#8761 for rationale.
+        """
+        if self.pip_imported_during_build():
+            return
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    @classmethod
+    def pip_imported_during_build(cls):
+        """
+        Detect if pip is being imported in a build script. Ref #2355.
+        """
+        import traceback
+
+        return any(
+            cls.frame_file_is_setup(frame) for frame, line in traceback.walk_stack(None)
+        )
+
+    @staticmethod
+    def frame_file_is_setup(frame):
+        """
+        Return True if the indicated frame suggests a setup.py file.
+        """
+        # some frames may not have __file__ (#2940)
+        return frame.f_globals.get('__file__', '').endswith('setup.py')
+
+    def spec_for_sensitive_tests(self):
+        """
+        Ensure stdlib distutils when running select tests under CPython.
+
+        python/cpython#91169
+        """
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    sensitive_tests = (
+        [
+            'test.test_distutils',
+            'test.test_peg_generator',
+            'test.test_importlib',
+        ]
+        if sys.version_info < (3, 10)
+        else [
+            'test.test_distutils',
+        ]
+    )
+
+
+for name in DistutilsMetaFinder.sensitive_tests:
+    setattr(
+        DistutilsMetaFinder,
+        f'spec_for_{name}',
+        DistutilsMetaFinder.spec_for_sensitive_tests,
+    )
+
+
+DISTUTILS_FINDER = DistutilsMetaFinder()
+
+
+def add_shim():
+    DISTUTILS_FINDER in sys.meta_path or insert_shim()
+
+
+class shim:
+    def __enter__(self):
+        insert_shim()
+
+    def __exit__(self, exc, value, tb):
+        remove_shim()
+
+
+def insert_shim():
+    sys.meta_path.insert(0, DISTUTILS_FINDER)
+
+
+def remove_shim():
+    try:
+        sys.meta_path.remove(DISTUTILS_FINDER)
+    except ValueError:
+        pass

venv/Lib/site-packages/_distutils_hack/override.py

@@ -0,0 +1 @@
+__import__('_distutils_hack').do_override()

venv/Lib/site-packages/_multiprocess/__init__.py

@@ -0,0 +1,8 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2022-2026 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/multiprocess/blob/master/LICENSE
+
+from _multiprocessing import *

venv/Lib/site-packages/_yaml/__init__.py

@@ -0,0 +1,33 @@
+# This is a stub package designed to roughly emulate the _yaml
+# extension module, which previously existed as a standalone module
+# and has been moved into the `yaml` package namespace.
+# It does not perfectly mimic its old counterpart, but should get
+# close enough for anyone who's relying on it even when they shouldn't.
+import yaml
+
+# in some circumstances, the yaml module we imoprted may be from a different version, so we need
+# to tread carefully when poking at it here (it may not have the attributes we expect)
+if not getattr(yaml, '__with_libyaml__', False):
+    from sys import version_info
+
+    exc = ModuleNotFoundError if version_info >= (3, 6) else ImportError
+    raise exc("No module named '_yaml'")
+else:
+    from yaml._yaml import *
+    import warnings
+    warnings.warn(
+        'The _yaml extension module is now located at yaml._yaml'
+        ' and its location is subject to change.  To use the'
+        ' LibYAML-based parser and emitter, import from `yaml`:'
+        ' `from yaml import CLoader as Loader, CDumper as Dumper`.',
+        DeprecationWarning
+    )
+    del warnings
+    # Don't `del yaml` here because yaml is actually an existing
+    # namespace member of _yaml.
+
+__name__ = '_yaml'
+# If the module is top-level (i.e. not a part of any specific package)
+# then the attribute should be set to ''.
+# https://docs.python.org/3.8/library/types.html
+__package__ = ''

venv/Lib/site-packages/absl/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+__version__ = '2.4.0'