app.py

# import streamlit as st
# import numpy as np
# import cv2
# import tempfile
# import os
# from PIL import Image

# # ---- Page Configuration ----
# st.set_page_config(page_title="Fake & Deepfake Detection", layout="wide")

# st.title("📰 Fake News & Deepfake Detection Tool")
# st.write("🚀 Detect Fake News, Deepfake Images, and Videos using AI")

# # ---- Fake News Detection Section ----
# st.subheader("📝 Fake News Detection")
# news_input = st.text_area("Enter News Text:", "Type here...")

# if st.button("Check News"):
#     st.write("🔍 Processing...")
#     st.success("✅ Result: This news is FAKE.")  # Replace with ML Model

# # ---- Deepfake Image Detection Section ----
# st.subheader("📸 Deepfake Image Detection")
# uploaded_image = st.file_uploader("Upload an Image", type=["jpg", "png", "jpeg"])

# def compress_image(image, quality=90, max_size=(300, 300)):  # ✅ High clarity image
#     img = Image.open(image).convert("RGB")
#     img.thumbnail(max_size)  
#     temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".jpg")
#     img.save(temp_file.name, "JPEG", quality=quality)
#     return temp_file.name

# if uploaded_image is not None:
#     compressed_image_path = compress_image(uploaded_image)
#     st.image(compressed_image_path, caption="🖼️ Compressed & Clear Image", use_column_width=True)
#     if st.button("Analyze Image"):
#         st.write("🔍 Processing...")
#         st.error("⚠️ Result: This image is a Deepfake.")  # Replace with model

# # ---- Deepfake Video Detection Section ----
# st.subheader("🎥 Deepfake Video Detection")
# uploaded_video = st.file_uploader("Upload a Video", type=["mp4", "avi", "mov"])

# def compress_video(video):
#     temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")

#     with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as temp_video:
#         temp_video.write(video.read())
#         video_path = temp_video.name

#     cap = cv2.VideoCapture(video_path)
    
#     if not cap.isOpened():
#         st.error("❌ Error: Unable to read video!")
#         return None

#     fourcc = cv2.VideoWriter_fourcc(*'mp4v')

#     # ✅ New Resolution (100x80) & 15 FPS
#     frame_width = 50  
#     frame_height = 80  
#     out = cv2.VideoWriter(temp_file.name, fourcc, 15.0, (frame_width, frame_height))  

#     while cap.isOpened():
#         ret, frame = cap.read()
#         if not ret:
#             break
#         frame = cv2.resize(frame, (frame_width, frame_height))
#         out.write(frame)

#     cap.release()
#     out.release()
    
#     return temp_file.name

# if uploaded_video is not None:
#     st.video(uploaded_video)  # ✅ فوراً ویڈیو اپ لوڈ ہونے کے بعد دکھائیں
#     compressed_video_path = compress_video(uploaded_video)
#     if compressed_video_path:
#         st.video(compressed_video_path)  # ✅ کمپریسڈ ویڈیو بھی دکھائیں
#         if st.button("Analyze Video"):
#             st.write("🔍 Processing...")
#             st.warning("⚠️ Result: This video contains Deepfake elements.")  # Replace with model

# st.markdown("🔹 **Developed for Fake News & Deepfake Detection Hackathon**")

import streamlit as st
import numpy as np
import cv2
import tempfile
import os
from PIL import Image
import tensorflow as tf
from transformers import pipeline
from tensorflow.keras.applications import Xception, EfficientNetB7
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Dense, GlobalAveragePooling2D
from tensorflow.keras.preprocessing.image import load_img, img_to_array

# ---- Page Configuration ----
st.set_page_config(page_title="Fake & Deepfake Detection", layout="wide")

st.title("📰 Fake News & Deepfake Detection Tool")
st.write("🚀 Detect Fake News, Deepfake Images, and Videos using AI")

# ---- Load Fake News Detector ----
try:
    fake_news_detector = pipeline("text-classification", model="microsoft/deberta-v3-base")
except Exception as e:
    st.error(f"Error loading fake news model: {e}")
    fake_news_detector = None

# ---- Load Deepfake Detection Models ----
try:
    base_model_image = Xception(weights="imagenet", include_top=False)
    base_model_image.trainable = False
    x = GlobalAveragePooling2D()(base_model_image.output)
    x = Dense(1024, activation="relu")(x)
    x = Dense(1, activation="sigmoid")(x)
    deepfake_image_model = Model(inputs=base_model_image.input, outputs=x)
except Exception as e:
    st.error(f"Error loading image model: {e}")
    deepfake_image_model = None

try:
    base_model_video = EfficientNetB7(weights="imagenet", include_top=False)
    base_model_video.trainable = False
    x = GlobalAveragePooling2D()(base_model_video.output)
    x = Dense(1024, activation="relu")(x)
    x = Dense(1, activation="sigmoid")(x)
    deepfake_video_model = Model(inputs=base_model_video.input, outputs=x)
except Exception as e:
    st.error(f"Error loading video model: {e}")
    deepfake_video_model = None

# ---- Image Preprocessing Function ----
def preprocess_image(image_path):
    try:
        img = load_img(image_path, target_size=(299, 299))  # Xception requires 299x299
        img = img_to_array(img)
        img = np.expand_dims(img, axis=0)
        img /= 255.0  # Normalize
        return img
    except Exception as e:
        st.error(f"Error processing image: {e}")
        return None

# ---- Fake News Detection Section ----
st.subheader("📝 Fake News Detection")
news_input = st.text_area("Enter News Text:", placeholder="Type here...")

if st.button("Check News"):
    if not news_input.strip():
        st.warning("⚠️ Please enter news text before checking.")
    elif fake_news_detector:
        st.write("🔍 Processing...")
        prediction = fake_news_detector(news_input)
        label = prediction[0]['label']
        confidence = prediction[0]['score']

        if label.lower() == "fake":
            st.error(f"⚠️ Result: This news is FAKE. (Confidence: {confidence:.2f})")
        else:
            st.success(f"✅ Result: This news is REAL. (Confidence: {confidence:.2f})")
    else:
        st.error("Fake news detection model not loaded.")

# ---- Deepfake Image Detection Section ----
st.subheader("📸 Deepfake Image Detection")
uploaded_image = st.file_uploader("Upload an Image", type=["jpg", "png", "jpeg"])

if uploaded_image is not None:
    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".jpg")
    img = Image.open(uploaded_image).convert("RGB")
    img.save(temp_file.name, "JPEG")
    st.image(temp_file.name, caption="🖼️ Uploaded Image", use_column_width=True)

    if st.button("Analyze Image"):
        if deepfake_image_model:
            st.write("🔍 Processing...")
            image_data = preprocess_image(temp_file.name)
            if image_data is not None:
                prediction = deepfake_image_model.predict(image_data)[0][0]
                confidence = round(float(prediction), 2)
                label = "FAKE" if confidence > 0.5 else "REAL"

                if label == "REAL":
                    st.success(f"✅ Result: This image is Real. (Confidence: {1 - confidence:.2f})")
                else:
                    st.error(f"⚠️ Result: This image is a Deepfake. (Confidence: {confidence:.2f})")
        else:
            st.error("Deepfake image detection model not loaded.")

# ---- Deepfake Video Detection Section ----
st.subheader("🎥 Deepfake Video Detection")
uploaded_video = st.file_uploader("Upload a Video", type=["mp4", "avi", "mov"])

def detect_deepfake_video(video_path):
    cap = cv2.VideoCapture(video_path)
    frame_scores = []
    
    if not cap.isOpened():
        st.error("Error: Cannot open video file.")
        return None

    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break

        frame_path = "temp_frame.jpg"
        cv2.imwrite(frame_path, frame)
        processed_image = preprocess_image(frame_path)
        
        if processed_image is not None:
            prediction = deepfake_image_model.predict(processed_image)[0][0]
            frame_scores.append(prediction)
        os.remove(frame_path)
    
    cap.release()
    if not frame_scores:
        return None

    avg_score = np.mean(frame_scores)
    final_label = "FAKE" if avg_score > 0.5 else "REAL"
    return {"label": final_label, "score": round(float(avg_score), 2)}

if uploaded_video is not None:
    st.video(uploaded_video)
    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
    with open(temp_file.name, "wb") as f:
        f.write(uploaded_video.read())

    if st.button("Analyze Video"):
        if deepfake_video_model:
            st.write("🔍 Processing...")
            result = detect_deepfake_video(temp_file.name)

            if result is None:
                st.error("⚠️ Unable to analyze video.")
            elif result["label"] == "FAKE":
                st.warning(f"⚠️ Result: This video contains Deepfake elements. (Confidence: {result['score']:.2f})")
            else:
                st.success(f"✅ Result: This video is Real. (Confidence: {1 - result['score']:.2f})")
        else:
            st.error("Deepfake video detection model not loaded.")

st.markdown("🔹 **Developed for Fake News & Deepfake Detection Hackathon**")