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 Models
fake_news_detector = pipeline("text-classification", model="microsoft/deberta-v3-base")

# Load Deepfake Detection Models
base_model_image = Xception(weights="imagenet", include_top=False)
base_model_image.trainable = False  # Freeze base layers
x = GlobalAveragePooling2D()(base_model_image.output)
x = Dense(1024, activation="relu")(x)
x = Dense(1, activation="sigmoid")(x)  # Sigmoid for probability output
deepfake_image_model = Model(inputs=base_model_image.input, outputs=x)

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)

# Function to Preprocess Image
def preprocess_image(image_path):
    img = load_img(image_path, target_size=(100, 100))  # Xception expects 299x299
    img = img_to_array(img)
    img = np.expand_dims(img, axis=0)
    img /= 255.0  # Normalize pixel values
    return img

# Function to Detect Deepfake Image
def detect_deepfake_image(image_path):
    image = preprocess_image(image_path)
    prediction = deepfake_image_model.predict(image)[0][0]
    confidence = round(float(prediction), 2)
    label = "FAKE" if confidence > 0.5 else "REAL"
    return {"label": label, "score": confidence}

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

# Manually verified facts database (you can expand this)
fact_check_db = {
    "elon musk was born in 1932": "FAKE",
    "earth revolves around the sun": "REAL",
    "the moon is made of cheese": "FAKE",
}

def check_manual_facts(text):
    text_lower = text.lower().strip()
    return fact_check_db.get(text_lower, None)

if st.button("Check News"):
    st.write("🔍 Processing...")

    # Check if the news is in the fact-check database
    manual_result = check_manual_facts(news_input)
    if manual_result:
        if manual_result == "FAKE":
            st.error(f"⚠️ Result: This news is **FAKE** (Verified by Database).")
        else:
            st.success(f"✅ Result: This news is **REAL** (Verified by Database).")
    else:
        # Use AI model if fact is not in the database
        prediction = fake_news_detector(news_input)
        label = prediction[0]['label'].lower()
        confidence = prediction[0]['score']

        if "fake" in label or confidence < 0.5:
            st.error(f"⚠️ Result: This news is **FAKE**. (Confidence: {confidence:.2f})")
        else:
            st.success(f"✅ Result: This news is **REAL**. (Confidence: {confidence:.2f})")

# ---- 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"):
        st.write("🔍 Processing...")
        result = detect_deepfake_image(temp_file.name)
        
        if result["label"] == "REAL":
          st.success(f"✅ Result: This image is Real. (Confidence: {1 - result['score']:.2f})")
        else: 
            
            st.error(f"⚠️ Result: This image is a Deepfake. (Confidence: {result['score']:.2f})")

# ---- 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 = []
    frame_count = 0
    
    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break
        
        if frame_count % 10 == 0:  # ہر 10ویں فریم کا تجزیہ کریں
            frame_path = "temp_frame.jpg"
            cv2.imwrite(frame_path, frame)
            result = detect_deepfake_image(frame_path)
            frame_scores.append(result["score"])
            os.remove(frame_path)
        
        frame_count += 1
    
    cap.release()
    
    if not frame_scores:
        return {"label": "UNKNOWN", "score": 0.0}  # اگر کوئی فریم پراسیس نہ ہو سکے
    
    avg_score = np.mean(frame_scores)
    confidence = round(float(avg_score), 2)
    final_label = "FAKE" if avg_score > 0.5 else "REAL"
    
    return {"label": final_label, "score": confidence}

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"):
        st.write("🔍 Processing... Please wait.")
        result = detect_deepfake_video(temp_file.name)
        
        if result["label"] == "FAKE":
            st.error(f"⚠️ Deepfake Detected! This video appears to be FAKE. (Confidence: {result['score']:.2f})")
        elif result["label"] == "REAL":
            st.success(f"✅ This video appears to be REAL. (Confidence: {1 - result['score']:.2f})")
        else:
            st.warning("⚠️ Unable to analyze the video. Please try a different file.")

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