first commit

.gitignore

@@ -0,0 +1,3 @@
+.venv
+pyodide
+venv/

Evaluation/visualize_tsne.py

@@ -0,0 +1,24 @@
+import matplotlib.pyplot as plt
+from sklearn.manifold import TSNE
+import numpy as np
+
+# Load your embeddings (X) and labels (y)
+X = np.load("../features/embeddings.npy")  # FaceNet embeddings
+y = np.load("../features/labels.npy")  # Labels (real, fake, AI-generated)
+
+# Ensure that the number of samples is greater than the perplexity value
+n_samples = X.shape[0]
+perplexity_value = min(30, n_samples - 1)  # Set perplexity less than number of samples
+
+# Apply t-SNE to reduce dimensionality to 2D
+tsne = TSNE(n_components=2, random_state=42, perplexity=perplexity_value)
+X_tsne = tsne.fit_transform(X)
+
+# Plot the results
+plt.figure(figsize=(8, 6))
+plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=y, cmap='viridis', s=50, alpha=0.7)
+plt.title("t-SNE Visualization of FaceNet Embeddings")
+plt.colorbar(label='Class')
+
+# Show the plot in a window
+plt.show()

README.md

@@ -1,11 +1 @@
----
-title: DeepscanAPI
-emoji: 🐠
-colorFrom: red
-colorTo: green
-sdk: docker
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Please create venv and install the requirementss.txt

app.py

@@ -0,0 +1,67 @@
+import os
+import torch
+import numpy as np
+import joblib
+from PIL import Image
+from flask import Flask, request, jsonify
+from transformers import CLIPProcessor, CLIPModel
+from io import BytesIO
+from flask_cors import CORS
+import base64
+import io
+
+# Flask app initialization
+app = Flask(__name__)
+CORS(app)
+
+# Load models once at the start
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"[INFO] Using device: {device}")
+
+# Load the CLIP model and processor
+model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32").to(device)
+processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
+
+# Load the ensemble classifier model
+ensemble_clf = joblib.load("model/random_forest_tuned_aug.pkl")
+
+# Label mapping
+label_map = {0: "real", 1: "deepfake", 2: "ai_gen"}
+
+def extract_features(image):
+    image = image.resize((224, 224))  # Resize to the required input size (224x224)
+    inputs = processor(images=image, return_tensors="pt").to(device)
+    
+    with torch.no_grad():
+        # Extract image features using CLIP
+        outputs = model.get_image_features(**inputs)
+    
+    emb = outputs.cpu().numpy().squeeze()
+    return emb
+
+@app.route("/predict", methods=["POST"])
+def predict():
+    # Get the uploaded image
+    data = request.json
+    if 'image' not in data:
+        return jsonify({"error": "No image provided"}), 400
+
+    image_data = base64.b64decode(data['image'])
+    image = Image.open(io.BytesIO(image_data)).convert("RGB")
+    
+    # Extract features and predict
+    features = extract_features(image)
+    probs = ensemble_clf.predict_proba([features])[0]
+    top_idx = np.argmax(probs)
+    
+    # Prepare response
+    response = {
+        "prediction": label_map[top_idx],
+        "probabilities": probs.tolist()
+    }
+    
+    return jsonify(response)
+
+if __name__ == "__main__":
+    # Run Flask app
+    app.run(debug=True)

features/embeddings.npy

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

features/labels.npy

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

model/random_forest.pkl

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

model/random_forest_aug.pkl

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

model/random_forest_tuned_aug.pkl

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

render.yaml

@@ -0,0 +1,7 @@
+services:
+  - type: web
+    name: deepfake-detector
+    env: python
+    plan: free
+    buildCommand: ""
+    startCommand: gunicorn app:app

scripts/augment_data.py

@@ -0,0 +1,44 @@
+import os
+import cv2
+import numpy as np
+import albumentations as A
+from glob import glob
+
+# Define the augmentation pipeline
+AUG = A.Compose([
+    A.HorizontalFlip(p=0.5),
+    A.RandomBrightnessContrast(p=0.5),
+    A.GaussianBlur(blur_limit=3, p=0.3),
+    A.Rotate(limit=15, p=0.3),
+    A.RandomResizedCrop(160, 160, scale=(0.9, 1.0), p=0.3),
+    A.ElasticTransform(alpha=1.0, sigma=50, alpha_affine=50, p=0.3),  # Elastic transformation
+    A.CoarseDropout(max_holes=1, max_height=8, max_width=8, p=0.3),  # Random Erasing
+    A.PerspectiveTransform(scale=(0.01, 0.1), p=0.5)  # Random perspective shift
+])
+
+# Directory with input images
+INPUT_DIR = "data"
+CATEGORIES = ["real", "deepfake", "ai_gen"]
+valid_extensions = ['.jpg', '.jpeg', '.png']
+
+for cat in CATEGORIES:
+    os.makedirs(os.path.join(INPUT_DIR, cat, 'augmented'), exist_ok=True)  # Create an 'augmented' folder inside each category
+    files = glob(f"{INPUT_DIR}/{cat}/*")
+    
+    for i, file in enumerate(files):
+        # Skip non-image files
+        if not any(file.lower().endswith(ext) for ext in valid_extensions):
+            continue
+        
+        img = cv2.imread(file)
+        if img is None:
+            continue
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        
+        # Generate 3 augmented images
+        for j in range(3):  
+            aug = AUG(image=img)["image"]
+            save_path = os.path.join(INPUT_DIR, cat, 'augmented', f"aug_{i}_{j}.jpg")
+            cv2.imwrite(save_path, cv2.cvtColor(aug, cv2.COLOR_RGB2BGR))
+
+print("✅ Augmentation complete. You can now re-run feature extraction and model training.")

scripts/ensemble_model.py

@@ -0,0 +1,44 @@
+import os
+import numpy as np
+from sklearn.ensemble import VotingClassifier
+from sklearn.metrics import classification_report
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.svm import SVC
+from xgboost import XGBClassifier
+import joblib
+from sklearn.model_selection import train_test_split
+
+# Load pre-extracted features and labels
+print("📦 Loading pre-extracted features and labels...")
+
+# Load the features (X) and labels (y)
+X = np.load("features/embeddings.npy")
+y = np.load("features/labels.npy")
+
+print(f"✅ Loaded {len(X)} samples with {X.shape[1]} features each.")
+
+# Split into training and testing sets
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Initialize individual classifiers
+rf = RandomForestClassifier(n_estimators=100, random_state=42)
+svm = SVC(probability=True, kernel='linear')  # Using probability=True for soft voting
+xgb = XGBClassifier(use_label_encoder=False, eval_metric='mlogloss')
+
+# Create the Voting Classifier ensemble
+ensemble_clf = VotingClassifier(estimators=[('rf', rf), ('svm', svm), ('xgb', xgb)], voting='soft')
+
+# Train the ensemble model
+print("🧠 Training the ensemble classifier...")
+ensemble_clf.fit(X_train, y_train)
+
+# Evaluate the ensemble model
+print("\n📊 Evaluation Report:")
+y_pred = ensemble_clf.predict(X_test)
+print(classification_report(y_test, y_pred, target_names=["real", "deepfake", "ai_gen"]))
+
+# Save the trained ensemble model
+os.makedirs("model", exist_ok=True)
+joblib.dump(ensemble_clf, "model/ensemble_model.pkl")
+
+print("\n✅ Ensemble model trained and saved to model/ensemble_model.pkl")

scripts/extract_audio_features.py

@@ -0,0 +1,60 @@
+import os
+import librosa
+import numpy as np
+
+DATA_DIR = "data"
+CATEGORIES = ["real_audio", "fake_audio"]
+OUTPUT_DIR = "features_audio"
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+X, y = [], []
+
+# Data augmentation techniques
+def augment_audio(audio, sr):
+    # Example: Shift pitch randomly within a range
+    pitch_shift = np.random.randint(-5, 5)  # Random pitch shift between -5 and 5 semitones
+    audio = librosa.effects.pitch_shift(audio, sr, n_steps=pitch_shift)
+
+    # Example: Time stretch randomly between 0.8x and 1.2x speed
+    rate = np.random.uniform(0.8, 1.2)
+    audio = librosa.effects.time_stretch(audio, rate)
+
+    # Example: Add random noise
+    noise_factor = np.random.uniform(0.001, 0.005)  # Random noise factor
+    noise = np.random.randn(len(audio)) * noise_factor
+    audio = audio + noise
+
+    return audio
+
+def extract_mfcc(path):
+    try:
+        audio, sr = librosa.load(path, sr=16000)  # Load the audio with 16kHz sampling rate
+        
+        # Apply audio augmentation
+        audio = augment_audio(audio, sr)
+        
+        # Extract MFCCs from the augmented audio
+        mfcc = librosa.feature.mfcc(y=audio, sr=sr, n_mfcc=13)
+        mfcc_mean = np.mean(mfcc.T, axis=0)  # Average MFCC features
+        return mfcc_mean
+    except Exception as e:
+        print(f"[ERROR] Failed to process {path}: {e}")
+        return None
+
+# Loop through each category and process audio files
+for label, cat in enumerate(CATEGORIES):
+    folder = os.path.join(DATA_DIR, cat)
+    for fname in os.listdir(folder):
+        if not fname.endswith(".wav"):  # Only process .wav files
+            continue
+        fpath = os.path.join(folder, fname)
+        features = extract_mfcc(fpath)  # Extract MFCC features
+        if features is not None:
+            X.append(features)
+            y.append(label)
+
+# Save the extracted features and labels
+np.save(os.path.join(OUTPUT_DIR, "embeddings.npy"), np.array(X))
+np.save(os.path.join(OUTPUT_DIR, "labels.npy"), np.array(y))
+
+print(f"✅ Extracted MFCC features for {len(X)} audio samples.")

scripts/extract_features.py

@@ -0,0 +1,114 @@
+import os
+import torch
+import numpy as np
+from PIL import Image
+from tqdm import tqdm
+from facenet_pytorch import InceptionResnetV1, MTCNN
+from transformers import CLIPProcessor, CLIPModel
+import albumentations as A
+import cv2
+
+# Set device
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"[INFO] Using device: {device}")
+
+# Initialize models
+mtcnn = MTCNN(image_size=160, device=device)
+facenet = InceptionResnetV1(pretrained='vggface2').eval().to(device)
+
+# Load CLIP model and processor
+clip_model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32").to(device)
+clip_processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
+
+# Input data folders
+DATA_DIR = "data"
+CATEGORIES = ["real", "deepfake", "ai_gen"]
+
+# Output path
+os.makedirs("features", exist_ok=True)
+
+# Data augmentation pipeline
+augment = A.Compose([
+    A.RandomBrightnessContrast(p=0.2),
+    A.HorizontalFlip(p=0.5),
+    A.Rotate(limit=10, p=0.3),
+    A.MotionBlur(p=0.2),
+    A.Resize(160, 160),  # For MTCNN size requirement
+])
+
+def extract_facenet_features(img_path):
+    image = Image.open(img_path).convert("RGB")
+    
+    # Resize image before passing it to MTCNN
+    img_np = np.array(image)
+    img_resized = cv2.resize(img_np, (160, 160))  # Resize image to 160x160
+
+    # Apply augmentation
+    augmented = augment(image=img_resized)["image"]
+    img_aug = Image.fromarray(augmented)
+
+    # Face detection using MTCNN
+    face = mtcnn(img_aug)
+    if face is None:
+        print(f"[WARN] No face detected in {img_path}")
+        return None
+    face = face.unsqueeze(0).to(device)
+
+    # Feature extraction using FaceNet
+    with torch.no_grad():
+        face_emb = facenet(face)
+    
+    return face_emb.squeeze().cpu().numpy()
+
+def extract_clip_features(img_path):
+    image = Image.open(img_path).convert("RGB")
+    
+    # Apply the same augmentation to the image before passing to CLIP
+    img_np = np.array(image)
+    augmented = augment(image=img_np)["image"]
+    img_aug = Image.fromarray(augmented)
+
+    # Extract features using CLIP
+    inputs = clip_processor(images=img_aug, return_tensors="pt").to(device)
+    with torch.no_grad():
+        clip_outputs = clip_model.get_image_features(**inputs)
+    
+    return clip_outputs.cpu().numpy().squeeze()
+
+def extract_combined_features(img_path):
+    # Extract features from both FaceNet and CLIP
+    facenet_features = extract_facenet_features(img_path)
+    clip_features = extract_clip_features(img_path)
+    
+    if facenet_features is None:
+        return None
+    
+    # Combine (concatenate) the features from FaceNet and CLIP
+    combined_features = np.concatenate((facenet_features, clip_features))
+    return combined_features
+
+def extract_all_features():
+    X, y = [], []
+    for label, category in enumerate(CATEGORIES):
+        folder = os.path.join(DATA_DIR, category)
+        if not os.path.isdir(folder):
+            print(f"[WARN] Missing folder: {folder}")
+            continue
+
+        print(f"\n🧠 Extracting from: {category} ({folder})")
+        for fname in tqdm(os.listdir(folder)):
+            if not fname.lower().endswith((".jpg", ".jpeg", ".png")):
+                continue
+            path = os.path.join(folder, fname)
+            combined_features = extract_combined_features(path)
+            if combined_features is not None:
+                X.append(combined_features)
+                y.append(label)
+
+    # Save the extracted features
+    np.save("../features/embeddings.npy", np.array(X))
+    np.save("../features/labels.npy", np.array(y))
+    print(f"\n✅ Done: Saved {len(X)} embeddings.")
+
+if __name__ == "__main__":
+    extract_all_features()

scripts/predict.py

@@ -0,0 +1,39 @@
+import sys
+import torch
+import numpy as np
+import joblib
+from PIL import Image
+from transformers import CLIPProcessor, CLIPModel
+from io import BytesIO
+
+# Load models
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32").to(device)
+processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
+ensemble_clf = joblib.load("models/random_forest_aug.pkl")
+
+label_map = {0: "real", 1: "deepfake", 2: "ai_gen"}
+
+def extract_features(image):
+    image = image.resize((224, 224))  # Resize image
+    inputs = processor(images=image, return_tensors="pt").to(device)
+    with torch.no_grad():
+        outputs = model.get_image_features(**inputs)
+    emb = outputs.cpu().numpy().squeeze()
+    return emb
+
+def predict(image_path):
+    image = Image.open(image_path).convert("RGB")
+    features = extract_features(image)
+    probs = ensemble_clf.predict_proba([features])[0]
+    top_idx = np.argmax(probs)
+    print(f"Prediction: {label_map[top_idx]}")
+    print(f"Probabilities: {probs}")
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print("Usage: python predict.py <image_path>")
+        sys.exit(1)
+    predict(sys.argv[1])
+
+

scripts/predict_audio.py

@@ -0,0 +1,45 @@
+import sys
+import librosa
+import numpy as np
+import joblib
+
+def extract_mfcc(path):
+    try:
+        audio, sr = librosa.load(path, sr=16000)  # Load the audio with 16kHz sample rate
+        mfcc = librosa.feature.mfcc(y=audio, sr=sr, n_mfcc=13)  # Extract MFCC features
+        return np.mean(mfcc.T, axis=0)  # Return the mean of MFCCs across time
+    except Exception as e:
+        print(f"[ERROR] Failed to process {path}: {e}")
+        return None
+
+def predict_audio(path):
+    # Extract features from the given audio path
+    features = extract_mfcc(path)
+    if features is None:
+        return  # Exit if feature extraction fails
+    
+    # Load pre-trained Random Forest model for audio prediction
+    model = joblib.load("model/audio_rf.pkl")
+
+    # Reshape the features to match the expected input shape (1, -1)
+    features = features.reshape(1, -1)
+
+    # Make prediction
+    pred = model.predict(features)[0]
+    
+    # Map the prediction to class labels (real: 0, fake: 1)
+    label = "real" if pred == 0 else "fake"
+
+    # Print the prediction
+    print(f"🎧 Prediction: {label}")
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print("Usage: python scripts/predict_audio.py <audio_path>")
+        sys.exit(1)
+
+    # Get the audio file path from command line argument
+    path = sys.argv[1]
+    
+    # Predict the audio label
+    predict_audio(path)

scripts/predict_video.py

@@ -0,0 +1,91 @@
+import cv2
+import torch
+import numpy as np
+from PIL import Image
+import joblib
+from facenet_pytorch import MTCNN, InceptionResnetV1
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"[INFO] Using device: {device}")
+
+# Load models
+mtcnn = MTCNN(image_size=160, device=device)
+facenet = InceptionResnetV1(pretrained='vggface2').eval().to(device)
+clf = joblib.load("model/ensemble_model.pkl")  # Example classifier model
+label_map = {0: "real", 1: "deepfake", 2: "ai_gen"}
+
+def extract_faces_from_video(video_path, time_interval_sec=10):
+    cap = cv2.VideoCapture(video_path)
+    embeddings = []
+
+    # Get the total number of frames in the video and the FPS
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    fps = cap.get(cv2.CAP_PROP_FPS())
+    video_duration = total_frames / fps  # Video duration in seconds
+    print(f"[INFO] Video duration: {video_duration} seconds, FPS: {fps}")
+
+    # Calculate the frame skip based on the desired time interval
+    frame_skip = int(fps * time_interval_sec)  # Process frames every 'time_interval_sec' seconds
+    print(f"[INFO] Processing every {time_interval_sec} seconds. Skipping {frame_skip} frames.")
+
+    frame_idx = 0
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        # Process frames based on the calculated frame skip
+        if frame_idx % frame_skip == 0:
+            image = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))  # Convert to RGB
+            combined_features = extract_combined_features(image)  # Assuming extract_combined_features() is defined
+            
+            if combined_features is not None:
+                embeddings.append(combined_features)
+
+        frame_idx += 1
+
+    cap.release()
+    return embeddings
+
+def extract_combined_features(image):
+    # Example: Combine features from FaceNet and CLIP (code for this is assumed to be defined already)
+    facenet_features = extract_facenet_features(image)
+    clip_features = extract_clip_features(image)
+    
+    if facenet_features is None:
+        return None
+    
+    # Combine (concatenate) the features from FaceNet and CLIP
+    combined_features = np.concatenate((facenet_features, clip_features))
+    return combined_features
+
+def extract_facenet_features(image):
+    # Example function for FaceNet feature extraction
+    pass
+
+def extract_clip_features(image):
+    # Example function for CLIP feature extraction
+    pass
+
+def predict_video(video_path):
+    embeddings = extract_faces_from_video(video_path, time_interval_sec=10)
+    
+    if not embeddings:
+        print("[WARN] No faces found in video.")
+        return
+
+    # Predict using the classifier
+    preds = clf.predict(embeddings)
+    
+    # Majority voting for final prediction
+    final_pred = np.bincount(preds).argmax()  # Most frequent label
+    print(f"\n🧠 Final Video Prediction: {label_map[final_pred]} ({len(preds)} frame(s) used)")
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) != 2:
+        print("Usage: python scripts/predict_video.py <video_path>")
+        sys.exit(1)
+    
+    # Run the video prediction function
+    predict_video(sys.argv[1])

scripts/random_forest.py

@@ -0,0 +1,34 @@
+import os
+import numpy as np
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.metrics import classification_report
+import joblib
+
+# Load pre-extracted features and labels
+print("📦 Loading pre-extracted features and labels...")
+
+# Load the features (X) and labels (y)
+X = np.load("features/embeddings.npy")
+y = np.load("features/labels.npy")
+
+print(f"✅ Loaded {len(X)} samples with {X.shape[1]} features each.")
+
+# Split into training and testing sets
+from sklearn.model_selection import train_test_split
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Initialize and train RandomForestClassifier
+print("🧠 Training RandomForestClassifier...")
+rf = RandomForestClassifier(n_estimators=100, random_state=42)
+rf.fit(X_train, y_train)
+
+# Evaluate the model
+print("\n📊 Evaluation Report:")
+y_pred = rf.predict(X_test)
+print(classification_report(y_test, y_pred, target_names=["real", "deepfake", "ai_gen"]))
+
+# Save the trained model
+os.makedirs("model", exist_ok=True)
+joblib.dump(rf, "model/random_forest.pkl")
+
+print("\n✅ Model trained and saved to model/random_forest.pkl")

scripts/stacking_model.py

@@ -0,0 +1,47 @@
+import os
+import numpy as np
+from sklearn.ensemble import RandomForestClassifier, StackingClassifier
+from sklearn.svm import SVC
+from xgboost import XGBClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import classification_report
+from sklearn.model_selection import train_test_split
+import joblib
+
+# Load the pre-extracted features and labels
+print("📦 Loading pre-extracted features and labels...")
+
+# Load the features (X) and labels (y)
+X = np.load("features/embeddings.npy")
+y = np.load("features/labels.npy")
+
+print(f"✅ Loaded {len(X)} samples with {X.shape[1]} features each.")
+
+# Split into training and testing sets
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Initialize the base models
+rf = RandomForestClassifier(n_estimators=100, random_state=42)
+svm = SVC(probability=True, kernel='linear')  # SVM with probability for soft voting
+xgb = XGBClassifier(use_label_encoder=False, eval_metric='mlogloss')
+
+# Create the meta-model (Logistic Regression)
+meta_model = LogisticRegression()
+
+# Create the Stacking Classifier
+stacking_model = StackingClassifier(estimators=[('rf', rf), ('svm', svm), ('xgb', xgb)], final_estimator=meta_model)
+
+# Train the stacking model
+print("🧠 Training the stacking classifier...")
+stacking_model.fit(X_train, y_train)
+
+# Evaluate the model
+print("\n📊 Evaluation Report:")
+y_pred = stacking_model.predict(X_test)
+print(classification_report(y_test, y_pred, target_names=["real", "deepfake", "ai_gen"]))
+
+# Save the trained stacking model
+os.makedirs("model", exist_ok=True)
+joblib.dump(stacking_model, "model/stacking_model.pkl")
+
+print("\n✅ Stacking model trained and saved to model/stacking_model.pkl")

scripts/svm.py

@@ -0,0 +1,34 @@
+import os
+import numpy as np
+from sklearn.svm import SVC
+from sklearn.metrics import classification_report
+import joblib
+
+# Load pre-extracted features and labels
+print("📦 Loading pre-extracted features and labels...")
+
+# Load the features (X) and labels (y)
+X = np.load("features/embeddings.npy")
+y = np.load("features/labels.npy")
+
+print(f"✅ Loaded {len(X)} samples with {X.shape[1]} features each.")
+
+# Split into training and testing sets
+from sklearn.model_selection import train_test_split
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Initialize and train SVM Classifier
+print("🧠 Training SVM Classifier...")
+svm = SVC(probability=True, kernel='linear')  # Using probability=True for soft voting
+svm.fit(X_train, y_train)
+
+# Evaluate the model
+print("\n📊 Evaluation Report:")
+y_pred = svm.predict(X_test)
+print(classification_report(y_test, y_pred, target_names=["real", "deepfake", "ai_gen"]))
+
+# Save the trained model
+os.makedirs("model", exist_ok=True)
+joblib.dump(svm, "model/svm.pkl")
+
+print("\n✅ Model trained and saved to model/svm.pkl")

scripts/xgboost.py

@@ -0,0 +1,34 @@
+import os
+import numpy as np
+from xgboost import XGBClassifier
+from sklearn.metrics import classification_report
+import joblib
+
+# Load pre-extracted features and labels
+print("📦 Loading pre-extracted features and labels...")
+
+# Load the features (X) and labels (y)
+X = np.load("features/embeddings.npy")
+y = np.load("features/labels.npy")
+
+print(f"✅ Loaded {len(X)} samples with {X.shape[1]} features each.")
+
+# Split into training and testing sets
+from sklearn.model_selection import train_test_split
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Initialize and train XGBoost Classifier
+print("🧠 Training XGBoost Classifier...")
+xgb = XGBClassifier(use_label_encoder=False, eval_metric='mlogloss')
+xgb.fit(X_train, y_train)
+
+# Evaluate the model
+print("\n📊 Evaluation Report:")
+y_pred = xgb.predict(X_test)
+print(classification_report(y_test, y_pred, target_names=["real", "deepfake", "ai_gen"]))
+
+# Save the trained model
+os.makedirs("model", exist_ok=True)
+joblib.dump(xgb, "model/xgboost.pkl")
+
+print("\n✅ Model trained and saved to model/xgboost.pkl")

space.yaml

@@ -0,0 +1,3 @@
+# space.yaml
+sdk: docker
+app_port: 7860