Uploaded model and UI

.gitignore

@@ -0,0 +1 @@
+__pycache__/

app.py

@@ -0,0 +1,111 @@
+import streamlit as st
+import cv2
+import numpy as np
+from tensorflow.keras.models import load_model
+from PIL import Image
+import io
+import os
+from testing2 import combined_prediction, predict_video
+
+# Load the model
+model = load_model("deepfake_detector.h5")
+
+st.set_page_config(page_title="Deepfake Detection System", layout="wide")
+
+def process_image_in_memory(file):
+    image = Image.open(file)
+    # Convert PIL Image to bytes
+    img_byte_arr = io.BytesIO()
+    image.save(img_byte_arr, format='JPEG')
+    img_byte_arr = img_byte_arr.getvalue()
+    
+    # Create temporary file, process it, and delete immediately
+    temp_path = "temp_image.jpg"
+    with open(temp_path, "wb") as f:
+        f.write(img_byte_arr)
+    
+    results = combined_prediction(temp_path)
+    
+    # Clean up
+    if os.path.exists(temp_path):
+        os.remove(temp_path)
+        
+    return results, image
+
+def process_video_in_memory(file):
+    temp_path = "temp_video.mp4"
+    
+    # Save temporarily for processing
+    with open(temp_path, "wb") as f:
+        f.write(file.read())
+    
+    results = predict_video(temp_path)
+    
+    # Clean up
+    if os.path.exists(temp_path):
+        os.remove(temp_path)
+        
+    return results
+
+def display_detailed_analysis(results):
+    st.subheader("🔍 Detailed Analysis")
+    
+    # Main Metrics
+    col1, col2 = st.columns(2)
+    with col1:
+        st.metric("Final Verdict", results["Final Prediction"])
+        st.metric("CNN Analysis", results["CNN Prediction"])
+    with col2:
+        st.metric("Confidence Score", f"{results['Confidence Score']*100:.1f}%")
+        st.metric("Metadata Check", results["Metadata Analysis"])
+    
+    # Technical Analysis
+    st.write("📊 Technical Analysis:")
+    st.write(f"- **Artifact Detection**: {results['Artifact Analysis']}")
+    st.write(f"- **Noise Pattern Analysis**: {results['Noise Pattern Analysis']}")
+    
+    # Symmetry Analysis if available
+    if "Symmetry Analysis" in results:
+        st.write("🎯 Symmetry Measurements:")
+        symmetry = results["Symmetry Analysis"]
+        st.write(f"- **Vertical Symmetry**: {symmetry['Vertical Symmetry']*100:.1f}%")
+        st.write(f"- **Horizontal Symmetry**: {symmetry['Horizontal Symmetry']*100:.1f}%")
+
+def main():
+    st.title("Deepfake Detection System")
+    st.write("Upload an image or video to detect if it's real or manipulated")
+
+    file = st.file_uploader("Choose a file", type=['jpg', 'jpeg', 'png', 'mp4', 'avi'])
+    
+    if file:
+        file_type = file.type.split('/')[0]
+        
+        if file_type == 'image':
+            results, image = process_image_in_memory(file)
+            st.image(image, caption="Uploaded Image", use_container_width=True, width=100)
+                    
+            display_detailed_analysis(results)
+                    
+        elif file_type == 'video':
+            st.video(file)
+            
+            if st.button("Analyze Video"):
+                with st.spinner("Analyzing video frames..."):
+                    results = process_video_in_memory(file)
+                    
+                    # Display results
+                    st.subheader("Video Analysis Results")
+                    col1, col2 = st.columns(2)
+                    
+                    with col1:
+                        st.metric("Final Prediction", results["Final Video Prediction"])
+                        st.metric("Confidence Score", f"{results['Confidence Score']*100:.2f}%")
+                    
+                    with col2:
+                        st.metric("Fake Frames", results["Fake Frames"])
+                        st.metric("Real Frames", results["Real Frames"])
+                    
+                    display_detailed_analysis(results)
+
+if __name__ == "__main__":
+    main()

deepfake2.py

@@ -0,0 +1,207 @@
+import os
+import shutil
+import cv2
+import numpy as np
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing import image
+import random
+
+# Paths to dataset directories
+data_dir = "C:/Users/ramya/OneDrive - iiit-b/Desktop/data_deepfake/Dataset/"
+train_dir = os.path.join(data_dir, "Train")
+val_dir = os.path.join(data_dir, "Validation")
+temp_train_dir = os.path.join(data_dir, "Temp_Train")
+temp_val_dir = os.path.join(data_dir, "Temp_Validation")
+
+# Image dimensions
+img_height, img_width = 128, 128
+
+# Limit the number of images for training and validation
+max_images_per_class = 12000 # Adjust as needed
+
+def count_images(directory):
+    """Count the number of real and fake images in a directory."""
+    real_count = len(os.listdir(os.path.join(directory, 'Real')))
+    fake_count = len(os.listdir(os.path.join(directory, 'Fake')))
+    return real_count, fake_count
+
+def prepare_limited_dataset(source_dir, target_dir, max_images):
+    """Create a temporary dataset with a limited number of images per class."""
+    if os.path.exists(target_dir):
+        shutil.rmtree(target_dir)
+    os.makedirs(os.path.join(target_dir, 'Real'), exist_ok=True)
+    os.makedirs(os.path.join(target_dir, 'Fake'), exist_ok=True)
+
+    for class_dir in ['Real', 'Fake']:
+        class_path = os.path.join(source_dir, class_dir)
+        target_class_path = os.path.join(target_dir, class_dir)
+        all_images = os.listdir(class_path)
+        random.shuffle(all_images)
+        selected_images = all_images[:max_images]
+
+        for image_name in selected_images:
+            shutil.copy(os.path.join(class_path, image_name), target_class_path)
+
+def get_processed_images_info(generator):
+    """Calculate information about processed images from a generator."""
+    n_samples = generator.n
+    n_classes = len(generator.class_indices)
+    batch_size = generator.batch_size
+    steps_per_epoch = int(np.ceil(n_samples / batch_size))
+
+    class_distribution = {}
+    for class_name, class_index in generator.class_indices.items():
+        class_count = len(generator.classes[generator.classes == class_index])
+        class_distribution[class_name] = class_count
+
+    return {
+        'total_samples': n_samples,
+        'batch_size': batch_size,
+        'steps_per_epoch': steps_per_epoch,
+        'class_distribution': class_distribution
+    }
+
+# Print initial image counts
+print("\nInitial image counts:")
+train_real, train_fake = count_images(train_dir)
+val_real, val_fake = count_images(val_dir)
+print(f"Training - Real: {train_real}, Fake: {train_fake}")
+print(f"Validation - Real: {val_real}, Fake: {val_fake}")
+
+# Prepare temporary directories with limited images
+prepare_limited_dataset(train_dir, temp_train_dir, max_images_per_class)
+prepare_limited_dataset(val_dir, temp_val_dir, max_images_per_class)
+
+# Print filtered image counts
+print("\nAfter filtering:")
+train_real, train_fake = count_images(temp_train_dir)
+val_real, val_fake = count_images(temp_val_dir)
+print(f"Training - Real: {train_real}, Fake: {train_fake}")
+print(f"Validation - Real: {val_real}, Fake: {val_fake}")
+
+# Data generators for training and validation
+datagen = ImageDataGenerator(rescale=1./255)
+
+train_gen = datagen.flow_from_directory(
+    temp_train_dir,
+    target_size=(img_height, img_width),
+    batch_size=32,
+    class_mode='binary',
+    classes=['Real', 'Fake']
+)
+
+val_gen = datagen.flow_from_directory(
+    temp_val_dir,
+    target_size=(img_height, img_width),
+    batch_size=32,
+    class_mode='binary',
+    classes=['Real', 'Fake']
+)
+
+# Get training and validation information
+train_info = get_processed_images_info(train_gen)
+val_info = get_processed_images_info(val_gen)
+
+print("\nTraining Data Processing Info:")
+print(f"Total training samples: {train_info['total_samples']}")
+print(f"Batch size: {train_info['batch_size']}")
+print(f"Steps per epoch: {train_info['steps_per_epoch']}")
+print("\nClass distribution in training:")
+for class_name, count in train_info['class_distribution'].items():
+    print(f"{class_name}: {count} images")
+
+print("\nValidation Data Processing Info:")
+print(f"Total validation samples: {val_info['total_samples']}")
+print(f"Batch size: {val_info['batch_size']}")
+print(f"Steps per epoch: {val_info['steps_per_epoch']}")
+print("\nClass distribution in validation:")
+for class_name, count in val_info['class_distribution'].items():
+    print(f"{class_name}: {count} images")
+
+# Define the CNN model
+model = Sequential([
+    Conv2D(32, (3, 3), activation='relu', input_shape=(img_height, img_width, 3)),
+    MaxPooling2D((2, 2)),
+    Conv2D(64, (3, 3), activation='relu'),
+    MaxPooling2D((2, 2)),
+    Conv2D(128, (3, 3), activation='relu'),
+    MaxPooling2D((2, 2)),
+    Flatten(),
+    Dense(128, activation='relu'),
+    Dropout(0.5),
+    Dense(1, activation='sigmoid')
+])
+
+# Compile the model
+model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
+
+# Train the model
+history = model.fit(
+    train_gen,
+    steps_per_epoch=train_info['steps_per_epoch'],
+    validation_data=val_gen,
+    validation_steps=val_info['steps_per_epoch'],
+    epochs=10
+)
+
+# Calculate total images processed
+total_training_images_processed = train_info['total_samples'] * 10  # 10 epochs
+total_validation_images_processed = val_info['total_samples'] * 10  # 10 epochs
+
+print(f"\nTotal images processed during training: {total_training_images_processed}")
+print(f"Total images processed during validation: {total_validation_images_processed}")
+print(f"Combined total processed: {total_training_images_processed + total_validation_images_processed}")
+
+# Save the model
+model.save("deepfake_detector.h5")
+
+# Functions for prediction
+def predict_image(img_path):
+    """Predict whether a single image is real or fake."""
+    img = image.load_img(img_path, target_size=(img_height, img_width))
+    img_array = image.img_to_array(img) / 255.0
+    img_array = np.expand_dims(img_array, axis=0)
+    prediction = model.predict(img_array)
+    return "Fake" if prediction[0][0] > 0.5 else "Real"
+
+def predict_video(video_path):
+    """Predict whether a video is real or fake by analyzing frames."""
+    cap = cv2.VideoCapture(video_path)
+    fake_count, real_count = 0, 0
+
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        # Preprocess the frame
+        frame_resized = cv2.resize(frame, (img_height, img_width))
+        frame_array = np.array(frame_resized) / 255.0
+        frame_array = np.expand_dims(frame_array, axis=0)
+
+        # Predict
+        prediction = model.predict(frame_array)
+        if prediction[0][0] > 0.5:
+            fake_count += 1
+        else:
+            real_count += 1
+
+    cap.release()
+    return "Fake" if fake_count > real_count else "Real"
+
+# Example usage
+if __name__ == "__main__":
+    # Test an image
+    test_image_path = "C:/Users/ramya/OneDrive - iiit-b/Desktop/test1.jpg"
+    if os.path.exists(test_image_path):
+        image_result = predict_image(test_image_path)
+        print(f"\nTest image prediction: {image_result}")
+
+    # Test a video (uncomment and modify path as needed)
+    # test_video_path = "example_video.mp4"
+    # if os.path.exists(test_video_path):
+    #     video_result = predict_video(test_video_path)
+    #     print(f"Test video prediction: {video_result}")

deepfake_detector.h5

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

testing2.py

@@ -0,0 +1,174 @@
+import os
+import cv2
+import numpy as np
+import imghdr
+from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing import image
+from PIL import Image
+from PIL.ExifTags import TAGS
+
+# Load the saved model
+model_path = "deepfake_detector.h5"
+model = load_model(model_path)
+
+# Image dimensions
+img_height, img_width = 128, 128
+
+# Trained model prediction
+def predict_image(img_path):
+    if not os.path.exists(img_path):
+        return "Image path does not exist."
+    img = image.load_img(img_path, target_size=(img_height, img_width))
+    img_array = image.img_to_array(img) / 255.0
+    img_array = np.expand_dims(img_array, axis=0)
+    prediction = model.predict(img_array)
+    return "Fake" if prediction[0][0] > 0.5 else "Real"
+
+def predict_video(video_path):
+    """Predict whether a video is real or fake by analyzing frames."""
+    try:
+        cap = cv2.VideoCapture(video_path)
+        fake_count, real_count = 0, 0
+        total_frames = 0
+        results = {}
+
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            # Process every 5th frame to improve performance
+            if total_frames % 5 == 0:
+                # Analyze frame using all detection methods
+                frame_path = f"temp_frame_{total_frames}.jpg"
+                cv2.imwrite(frame_path, frame)
+                
+                frame_results = combined_prediction(frame_path)
+                if frame_results["Final Prediction"] == "Fake":
+                    fake_count += 1
+                else:
+                    real_count += 1
+                    
+                os.remove(frame_path)
+            
+            total_frames += 1
+
+        cap.release()
+
+        # Calculate final results
+        total_analyzed_frames = fake_count + real_count
+        fake_percentage = (fake_count / total_analyzed_frames * 100) if total_analyzed_frames > 0 else 0
+        
+        results["Total Frames Analyzed"] = total_analyzed_frames
+        results["Fake Frames"] = fake_count
+        results["Real Frames"] = real_count
+        results["Fake Percentage"] = round(fake_percentage, 2)
+        results["Final Video Prediction"] = "Fake" if fake_percentage > 50 else "Real"
+        results["Confidence Score"] = round(abs(50 - fake_percentage) / 50, 2)
+        
+        return results
+
+    except Exception as e:
+        return {"Error": f"Error analyzing video: {str(e)}"}
+
+# Metadata analysis
+def check_metadata(img_path):
+    try:
+        img = Image.open(img_path)
+        exif_data = img._getexif()
+        if not exif_data:
+            return "Fake (missing metadata)"
+        metadata = {TAGS.get(tag): value for tag, value in exif_data.items() if tag in TAGS}
+        return "Real (metadata present)" if metadata else "Fake (missing metadata)"
+    except Exception as e:
+        return f"Error analyzing metadata: {str(e)}"
+
+# Artifact density analysis
+def analyze_artifacts(img_path):
+    try:
+        img = cv2.imread(img_path)
+        img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        laplacian = cv2.Laplacian(img_gray, cv2.CV_64F)
+        mean_var = np.mean(np.var(laplacian))
+        return "Fake (high artifact density)" if mean_var > 10 else "Real"
+    except Exception as e:
+        return f"Error analyzing artifacts: {str(e)}"
+
+# Noise pattern detection
+def detect_noise_patterns(img_path):
+    try:
+        img = cv2.imread(img_path)
+        img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        noise_std = np.std(img_gray)
+        return "Fake (unnatural noise patterns)" if noise_std < 5 else "Real"
+    except Exception as e:
+        return f"Error analyzing noise patterns: {str(e)}"
+
+# Symmetry analysis
+def calculate_symmetry(img_path):
+    try:
+        img = cv2.imread(img_path)
+        img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        img_flipped_v = cv2.flip(img_gray, 1)
+        img_flipped_h = cv2.flip(img_gray, 0)
+        vertical_symmetry = 1 - np.mean(np.abs(img_gray - img_flipped_v)) / 255
+        horizontal_symmetry = 1 - np.mean(np.abs(img_gray - img_flipped_h)) / 255
+        return {
+            "Vertical Symmetry": round(vertical_symmetry, 2),
+            "Horizontal Symmetry": round(horizontal_symmetry, 2)
+        }
+    except Exception as e:
+        return {"Error": str(e)}
+
+# Combine all methods
+def combined_prediction(img_path):
+    results = {}
+    cnn_prediction = predict_image(img_path)
+    results["CNN Prediction"] = cnn_prediction
+    cnn_score = 1 if cnn_prediction == "Fake" else 0
+    metadata_result = check_metadata(img_path)
+    results["Metadata Analysis"] = metadata_result
+    metadata_score = 1 if "Fake" in metadata_result else 0
+    artifact_result = analyze_artifacts(img_path)
+    results["Artifact Analysis"] = artifact_result
+    artifact_score = 1 if "Fake" in artifact_result else 0
+    noise_result = detect_noise_patterns(img_path)
+    results["Noise Pattern Analysis"] = noise_result
+    noise_score = 1 if "Fake" in noise_result else 0
+    symmetry_results = calculate_symmetry(img_path)
+    results["Symmetry Analysis"] = symmetry_results
+    vertical_symmetry = symmetry_results.get("Vertical Symmetry", 0)
+    horizontal_symmetry = symmetry_results.get("Horizontal Symmetry", 0)
+    symmetry_score = 0
+    if vertical_symmetry != "Unknown" and horizontal_symmetry != "Unknown":
+        if vertical_symmetry > 0.9 or horizontal_symmetry > 0.9:
+            symmetry_score = 1
+    total_score = (cnn_score * 0.4 + metadata_score * 0.1 +
+                   artifact_score * 0.15 + noise_score * 0.15 +
+                   symmetry_score * 0.2)
+    results["Final Prediction"] = "Fake" if total_score > 0.5 else "Real"
+    results["Confidence Score"] = round(total_score, 2)
+    return results
+
+# Main function
+if __name__ == "__main__":
+    test_image_path = "C:/Users/ramya/OneDrive - iiit-b/Desktop/test1.jpg"
+    if os.path.exists(test_image_path):
+        final_results = combined_prediction(test_image_path)
+        print("\nCombined Prediction Results:")
+        for key, value in final_results.items():
+            if isinstance(value, dict):
+                print(f"{key}:")
+                for sub_key, sub_value in value.items():
+                    print(f"  {sub_key}: {sub_value}")
+            else:
+                print(f"{key}: {value}")
+
+# if __name__ == "__main__":
+#     # Test video
+#     test_video_path = "path/to/your/video.mp4"
+#     if os.path.exists(test_video_path):
+#         video_results = predict_video(test_video_path)
+#         print("\nVideo Analysis Results:")
+#         for key, value in video_results.items():
+#             print(f"{key}: {value}")