feat: Add full implementation and HF Space artifacts

.gitattributes

@@ -0,0 +1,3 @@
+*.keras filter=lfs diff=lfs merge=lfs -text
+*.ipynb filter=lfs diff=lfs merge=lfs -text
+*.docx filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,41 @@
+# --- Local IDE / Claude Code ---
+.claude/
+.vscode/
+.idea/
+
+# --- HTML build artefact (rebuilt by pandoc; not source) ---
+Documents/header_inline.html
+
+# --- Future: data files (see PROJECT_SCOPE.md §5.2 + §6) ---
+data/raw/
+data/processed/
+
+# --- Future: training outputs (weights live on HuggingFace Hub) ---
+checkpoints/
+logs/
+
+# --- Python ---
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+.venv/
+venv/
+env/
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+
+# --- Jupyter ---
+.ipynb_checkpoints/
+
+# --- OS ---
+.DS_Store
+Thumbs.db
+
+# --- Secrets / credentials ---
+.env
+.env.local
+*.pem
+kaggle.json

Documents/Project_Report_Digital_Image_Forgery_Detector.docx

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

Image_Forgery_Detection_Colab_1.ipynb

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

M3_best.keras

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

README.md

@@ -0,0 +1,26 @@
+---
+title: Image Forgery Detector
+emoji: 🛡️
+colorFrom: blue
+colorTo: red
+sdk: streamlit
+sdk_version: 1.35.0
+python_version: 3.11
+app_file: app.py
+pinned: false
+---
+
+# Image Forgery Detector
+
+This application detects tampering in images using a Dual-Branch CNN architecture.
+
+## How it works:
+1. **RGB Branch:** Uses a pretrained ResNet50 to extract semantic features from the original image.
+2. **ELA Branch:** Computes Error Level Analysis (ELA) to detect JPEG compression inconsistencies.
+3. **Fused Model:** Combines features from both branches to make a final prediction.
+
+## Explainability:
+The app uses **Grad-CAM** to visualize which parts of the image the model focused on when making its decision.
+
+## Deployment:
+This app is designed to be deployed on Hugging Face Spaces using Streamlit.

app.py

@@ -0,0 +1,143 @@
+import streamlit as st
+import numpy as np
+import tensorflow as tf
+import cv2
+import io
+from PIL import Image, ImageChops
+from tensorflow.keras import models
+
+# ── Configuration ────────────────────────────────────────────────────────────
+IMG_SIZE   = (224, 224)
+ELA_QUALITY = 90
+ELA_SCALE  = 15
+
+# ── Forensic Utilities ───────────────────────────────────────────────────────
+def compute_ela(original, quality=ELA_QUALITY, scale=ELA_SCALE):
+    original = original.convert('RGB')
+    buf = io.BytesIO()
+    original.save(buf, 'JPEG', quality=quality)
+    buf.seek(0)
+    compressed = Image.open(buf)
+
+    ela_image = ImageChops.difference(original, compressed)
+    ela_image = ImageChops.multiply(
+        ela_image, Image.new('RGB', ela_image.size, (scale, scale, scale))
+    )
+    return ela_image
+
+def get_gradcam(model, input_data):
+    # Dynamically find the last conv layer
+    last_conv_layer_name = None
+    for layer in reversed(model.layers):
+        if 'conv2d' in layer.name:
+            last_conv_layer_name = layer.name
+            break
+    
+    if not last_conv_layer_name:
+        # Fallback to any layer with conv in name
+        for layer in reversed(model.layers):
+            if 'conv' in layer.name:
+                last_conv_layer_name = layer.name
+                break
+
+    grad_model = models.Model(
+        inputs=model.inputs,
+        outputs=[model.get_layer(last_conv_layer_name).output, model.output]
+    )
+
+    with tf.GradientTape() as tape:
+        last_conv_out, preds = grad_model(input_data)
+        class_channel = preds[:, 0]
+
+    grads        = tape.gradient(class_channel, last_conv_out)
+    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
+    heatmap      = last_conv_out[0] @ pooled_grads[..., tf.newaxis]
+
+    max_val = tf.math.reduce_max(heatmap)
+    if max_val == 0:
+        max_val = 1e-10
+    heatmap = tf.squeeze(tf.maximum(heatmap, 0) / max_val).numpy()
+    return heatmap
+
+@st.cache_resource
+def load_trained_model():
+    return models.load_model('M3_best.keras')
+
+# ── Main UI ──────────────────────────────────────────────────────────────────
+st.set_page_config(page_title="Image Forgery Detector", layout="wide")
+
+st.title("🛡️ Image Forgery Detector")
+st.markdown("""
+Detect tampering in images using a Dual-Branch CNN (RGB + ELA).
+Upload an image to see if it's Authentic or Forged.
+""")
+
+uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png", "tif"])
+
+if uploaded_file is not None:
+    image = Image.open(uploaded_file).convert('RGB')
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        st.image(image, caption="Original Image", use_column_width=True)
+    
+    with st.spinner("Analyzing..."):
+        # Load model
+        m3 = load_trained_model()
+        
+        # Prepare inputs
+        rgb_in = np.array(image.resize(IMG_SIZE)).astype(np.float32)[np.newaxis, ...]
+        ela_img = compute_ela(image)
+        ela_in = np.array(ela_img.resize(IMG_SIZE)).astype(np.float32)[np.newaxis, ...]
+        
+        # Handle input mapping
+        try:
+            if hasattr(m3, 'input_names') and m3.input_names:
+                input_data = {name: tensor for name, tensor in zip(m3.input_names, [rgb_in, ela_in])}
+            else:
+                input_data = [rgb_in, ela_in]
+        except:
+            input_data = [rgb_in, ela_in]
+            
+        # Inference
+        pred = m3.predict(input_data, verbose=0)[0][0]
+        label = "FORGED" if pred > 0.5 else "AUTHENTIC"
+        confidence = pred if pred > 0.5 else 1 - pred
+        
+        if 0.45 <= pred <= 0.55:
+            label = "UNCERTAIN"
+            
+    with col2:
+        st.subheader("Prediction Result")
+        color = "red" if label == "FORGED" else "green" if label == "AUTHENTIC" else "orange"
+        st.markdown(f"### Result: <span style='color:{color}'>{label}</span>", unsafe_allow_html=True)
+        st.write(f"**Confidence:** {confidence:.2%}")
+        
+        st.progress(float(confidence))
+
+    st.divider()
+    
+    col3, col4 = st.columns(2)
+    with col3:
+        st.subheader("ELA Artifacts")
+        st.image(ela_img, caption="Error Level Analysis (JPEG inconsistencies)", use_column_width=True)
+        st.info("ELA highlights regions with different compression levels, often indicating tampered areas.")
+        
+    with col4:
+        st.subheader("Grad-CAM Explainability")
+        try:
+            heatmap = get_gradcam(m3, input_data)
+            heatmap_color = cv2.applyColorMap(np.uint8(255 * heatmap), cv2.COLORMAP_JET)
+            heatmap_color = cv2.cvtColor(heatmap_color, cv2.COLOR_BGR2RGB)
+            heatmap_resized = cv2.resize(heatmap_color, (image.size[0], image.size[1]))
+            
+            # Blend
+            img_np = np.array(image)
+            overlay = np.uint8(heatmap_resized * 0.4 + img_np * 0.6)
+            st.image(overlay, caption="Model Focus Regions", use_column_width=True)
+            st.info("The heatmap shows which parts of the image the model focused on to make its decision.")
+        except Exception as e:
+            st.error(f"Could not generate Grad-CAM: {e}")
+
+else:
+    st.info("Please upload an image to start detection.")

packages.txt

@@ -0,0 +1,8 @@
+git
+git-lfs
+ffmpeg
+libsm6
+libxext6
+cmake
+rsync
+libgl1

requirements.txt

@@ -0,0 +1,7 @@
+streamlit
+tensorflow
+opencv-python-headless
+pillow
+numpy
+scikit-learn
+matplotlib

train.py

@@ -0,0 +1,172 @@
+import os
+import re
+import io
+import random
+import numpy as np
+import tensorflow as tf
+import cv2
+from PIL import Image, ImageChops, ImageDraw
+from sklearn.model_selection import train_test_split
+from tensorflow.keras import layers, models, applications
+
+# ── Global configuration ──────────────────────────────────────────────────────
+SEED       = 42
+IMG_SIZE   = (224, 224)
+ELA_QUALITY = 90
+ELA_SCALE  = 15
+BATCH_SIZE = 32
+EPOCHS     = 5
+TARGET_DIR = "./casia_v2"
+
+def set_reproducibility(seed=SEED):
+    tf.random.set_seed(seed)
+    np.random.seed(seed)
+    random.seed(seed)
+    os.environ['PYTHONHASHSEED'] = str(seed)
+
+set_reproducibility()
+
+def generate_robust_dataset(num_samples=120):
+    if os.path.exists(TARGET_DIR):
+        import shutil
+        shutil.rmtree(TARGET_DIR)
+    os.makedirs(TARGET_DIR)
+
+    print(f"Generating {num_samples} synthetic samples...")
+    for i in range(num_samples):
+        img_data = np.random.randint(100, 200, (256, 256, 3), dtype=np.uint8)
+        img = Image.fromarray(img_data)
+
+        is_forged = i >= (num_samples // 2)
+        if not is_forged:
+            filename = f"Au_arc_000{i:02d}.jpg"
+        else:
+            draw = ImageDraw.Draw(img)
+            draw.rectangle([50, 50, 150, 150], fill=(255, 0, 0))
+            filename = f"Tp_s_N_arc_000{i:02d}_00099_001.jpg"
+
+        img.save(os.path.join(TARGET_DIR, filename))
+
+def compute_ela(image_path_or_pil, quality=ELA_QUALITY, scale=ELA_SCALE):
+    if isinstance(image_path_or_pil, str):
+        original = Image.open(image_path_or_pil).convert('RGB')
+    else:
+        original = image_path_or_pil.convert('RGB')
+
+    buf = io.BytesIO()
+    original.save(buf, 'JPEG', quality=quality)
+    buf.seek(0)
+    compressed = Image.open(buf)
+
+    ela_image = ImageChops.difference(original, compressed)
+    ela_image = ImageChops.multiply(
+        ela_image, Image.new('RGB', ela_image.size, (scale, scale, scale))
+    )
+    return ela_image
+
+class CASIAParser:
+    @staticmethod
+    def get_ids(filename):
+        name = os.path.basename(filename)
+        if name.startswith('Au_'):
+            match = re.search(r'Au_[a-z]{3}_(\d+)', name)
+            return [match.group(1)] if match else []
+        elif name.startswith('Tp_'):
+            parts = name.split('_')
+            return [parts[4], parts[5]] if len(parts) >= 6 else []
+        return []
+
+def split_dataset(data_dir, train_ratio=0.8, val_ratio=0.1, test_ratio=0.1):
+    all_images = [
+        os.path.join(data_dir, f)
+        for f in os.listdir(data_dir)
+        if f.lower().endswith(('.jpg', '.jpeg', '.png', '.tif'))
+    ]
+    unique_ids = sorted({i for p in all_images for i in CASIAParser.get_ids(p)})
+    if not unique_ids:
+        unique_ids = [str(i) for i in range(len(all_images))]
+    tr_ids, temp = train_test_split(unique_ids, train_size=train_ratio, random_state=SEED)
+    v_ids, _ = train_test_split(temp, train_size=val_ratio / (val_ratio + test_ratio), random_state=SEED)
+    tr_ids, v_ids = set(tr_ids), set(v_ids)
+    splits = {'train': [], 'val': [], 'test': []}
+    for p in all_images:
+        ids = CASIAParser.get_ids(p)
+        if not ids:
+             splits['train'].append(p) if random.random() < 0.8 else splits['test'].append(p)
+             continue
+        if any(i in tr_ids for i in ids): splits['train'].append(p)
+        elif any(i in v_ids for i in ids): splits['val'].append(p)
+        else: splits['test'].append(p)
+    return splits
+
+def preload_images(paths, img_size=IMG_SIZE):
+    rgb_list, ela_list, label_list = [], [], []
+    for p in paths:
+        pil_img = Image.open(p).convert('RGB')
+        rgb_list.append(np.array(pil_img.resize(img_size), dtype=np.float32))
+        ela_list.append(np.array(compute_ela(pil_img).resize(img_size), dtype=np.float32))
+        label_list.append(1 if os.path.basename(p).startswith('Tp_') else 0)
+    return np.array(rgb_list), np.array(ela_list), np.array(label_list)
+
+def make_dataset(rgb_arr, ela_arr, labels, batch_size=BATCH_SIZE, shuffle=False, repeat=True):
+    ds = tf.data.Dataset.from_tensor_slices(((rgb_arr, ela_arr), labels))
+    if shuffle:
+        ds = ds.shuffle(buffer_size=len(labels), seed=SEED, reshuffle_each_iteration=True)
+    ds = ds.batch(batch_size, drop_remainder=False)
+    if repeat:
+        ds = ds.repeat()
+    return ds.prefetch(tf.data.AUTOTUNE)
+
+def get_rgb_branch():
+    base = applications.ResNet50(
+        include_top=False, weights='imagenet', input_shape=(*IMG_SIZE, 3)
+    )
+    base.trainable = False
+    inputs = layers.Input(shape=(*IMG_SIZE, 3))
+    x = applications.resnet50.preprocess_input(inputs)
+    x = base(x, training=False)
+    return inputs, layers.GlobalAveragePooling2D()(x)
+
+def get_ela_branch():
+    inputs = layers.Input(shape=(*IMG_SIZE, 3))
+    x = layers.Rescaling(1. / 255)(inputs)
+    for filters in [32, 64, 128]:
+        x = layers.Conv2D(filters, (3, 3), activation='relu', padding='same')(x)
+        x = layers.BatchNormalization()(x)
+        x = layers.MaxPooling2D((2, 2))(x)
+    return inputs, layers.GlobalAveragePooling2D()(x)
+
+def build_model():
+    rgb_in, rgb_f = get_rgb_branch()
+    ela_in, ela_f = get_ela_branch()
+    fused = layers.Concatenate()([rgb_f, ela_f])
+    out = layers.Dense(1, activation='sigmoid')(
+        layers.Dropout(0.5)(layers.Dense(256, activation='relu')(fused))
+    )
+    return models.Model(inputs=[rgb_in, ela_in], outputs=out)
+
+if __name__ == "__main__":
+    generate_robust_dataset(120)
+    splits = split_dataset(TARGET_DIR)
+    train_rgb, train_ela, train_labels = preload_images(splits['train'])
+    val_rgb,   val_ela,   val_labels   = preload_images(splits['val'])
+
+    train_ds = make_dataset(train_rgb, train_ela, train_labels, shuffle=True)
+    val_ds   = make_dataset(val_rgb,   val_ela,   val_labels,   shuffle=False)
+
+    model = build_model()
+    model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
+
+    steps_per_epoch  = max(1, int(np.ceil(len(train_labels) / BATCH_SIZE)))
+    validation_steps = max(1, int(np.ceil(len(val_labels)   / BATCH_SIZE)))
+
+    model.fit(
+        train_ds,
+        validation_data=val_ds,
+        epochs=EPOCHS,
+        steps_per_epoch=steps_per_epoch,
+        validation_steps=validation_steps,
+        verbose=1,
+    )
+    model.save('M3_best.keras')
+    print("Model saved as M3_best.keras")