Real-World Use Cases: Deepfakes and Their Impact

import cv2
import dlib
import numpy as np
from pathlib import Path

def preprocess_dataset(input_dir, output_dir, target_size=(256, 256)):
    """
    Preprocess images for deepfake training by detecting faces,
    aligning them, and normalizing the images.
    """
    # Initialize face detector and landmark predictor
    detector = dlib.get_frontal_face_detector()
    predictor = dlib.shape_predictor('shape_predictor_68_face_landmarks.dat')
    
    # Create output directory
    output_path = Path(output_dir)
    output_path.mkdir(exist_ok=True, parents=True)
    
    # Process each image in the input directory
    for img_path in Path(input_dir).glob('*.jpg'):
        # Load image
        img = cv2.imread(str(img_path))
        
        if img is None:
            print(f"Could not read {img_path}")
            continue
            
        # Convert to grayscale for face detection
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        
        # Detect faces
        faces = detector(gray)
        
        if not faces:
            print(f"No face detected in {img_path}")
            continue
            
        # Process each detected face
        for i, face in enumerate(faces):
            # Get facial landmarks
            landmarks = predictor(gray, face)
            
            # Extract face bounding box
            x1, y1 = face.left(), face.top()
            x2, y2 = face.right(), face.bottom()
            
            # Add margin
            margin = int(0.2 * (x2 - x1))
            x1 = max(0, x1 - margin)
            y1 = max(0, y1 - margin)
            x2 = min(img.shape[1], x2 + margin)
            y2 = min(img.shape[0], y2 + margin)
            
            # Extract face region
            face_img = img[y1:y2, x1:x2]
            
            # Resize to target size
            face_img = cv2.resize(face_img, target_size)
            
            # Normalize pixel values
            face_img = face_img / 255.0
            
            # Apply histogram equalization for lighting normalization
            # Convert to LAB color space (L=lightness, A=green-red, B=blue-yellow)
            lab = cv2.cvtColor(face_img, cv2.COLOR_BGR2LAB)
            l, a, b = cv2.split(lab)
            
            # Apply CLAHE (Contrast Limited Adaptive Histogram Equalization)
            clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
            cl = clahe.apply(np.uint8(l * 255)) / 255.0
            
            # Merge channels back
            merged = cv2.merge((cl, a, b))
            
            # Convert back to BGR
            norm_img = cv2.cvtColor(merged, cv2.COLOR_LAB2BGR)
            
            # Save the preprocessed face
            output_file = output_path / f"{img_path.stem}_face_{i}.jpg"
            cv2.imwrite(str(output_file), (norm_img * 255).astype(np.uint8))
            
    print(f"Preprocessing complete. Results saved to {output_dir}")

# Example usage
preprocess_dataset(
    input_dir="raw_faces", 
    output_dir="preprocessed_faces"
)

import tensorflow as tf
from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, UpSampling2D, Flatten, Dense, Reshape, Conv2DTranspose
from tensorflow.keras.models import Model
import numpy as np
import os
from glob import glob
from tensorflow.keras.preprocessing.image import load_img, img_to_array

def build_autoencoder(input_shape=(256, 256, 3), latent_dim=1024):
    """Build an autoencoder model for deepfake generation"""
    # Encoder
    encoder_input = Input(shape=input_shape, name='encoder_input')
    
    # Convolutional layers
    x = Conv2D(64, (3, 3), activation='relu', padding='same')(encoder_input)
    x = MaxPooling2D((2, 2), padding='same')(x)
    x = Conv2D(128, (3, 3), activation='relu', padding='same')(x)
    x = MaxPooling2D((2, 2), padding='same')(x)
    x = Conv2D(256, (3, 3), activation='relu', padding='same')(x)
    x = MaxPooling2D((2, 2), padding='same')(x)
    x = Conv2D(512, (3, 3), activation='relu', padding='same')(x)
    x = MaxPooling2D((2, 2), padding='same')(x)
    
    # Flatten and encode to latent space
    volumeSize = K.int_shape(x)
    x = Flatten()(x)
    latent = Dense(latent_dim, name='latent_vector')(x)
    
    # Build the encoder model
    encoder = Model(encoder_input, latent, name='encoder')
    
    # Decoder architecture (we'll create two decoders)
    decoder_input = Input(shape=(latent_dim,), name='decoder_input')
    
    # Reshape to the last convolution output dimensions
    x = Dense(volumeSize[1] * volumeSize[2] * volumeSize[3])(decoder_input)
    x = Reshape((volumeSize[1], volumeSize[2], volumeSize[3]))(x)
    
    # Deconvolutional layers
    x = Conv2DTranspose(512, (3, 3), activation='relu', padding='same')(x)
    x = UpSampling2D((2, 2))(x)
    x = Conv2DTranspose(256, (3, 3), activation='relu', padding='same')(x)
    x = UpSampling2D((2, 2))(x)
    x = Conv2DTranspose(128, (3, 3), activation='relu', padding='same')(x)
    x = UpSampling2D((2, 2))(x)
    x = Conv2DTranspose(64, (3, 3), activation='relu', padding='same')(x)
    x = UpSampling2D((2, 2))(x)
    
    # Output layer
    decoder_output = Conv2D(3, (3, 3), activation='sigmoid', padding='same')(x)
    
    # Create a reusable decoder architecture
    decoder_template = Model(decoder_input, decoder_output, name='decoder_template')
    
    # Create two instances of the decoder (one for each face)
    decoder_A = Model(decoder_input, decoder_template(decoder_input), name='decoder_A')
    decoder_B = Model(decoder_input, decoder_template(decoder_input), name='decoder_B')
    
    # Create two autoencoders (A→A and B→B)
    autoencoder_A = Model(encoder_input, decoder_A(encoder(encoder_input)), name='autoencoder_A')
    autoencoder_B = Model(encoder_input, decoder_B(encoder(encoder_input)), name='autoencoder_B')
    
    # Compile the models
    autoencoder_A.compile(optimizer='adam', loss='mean_absolute_error')
    autoencoder_B.compile(optimizer='adam', loss='mean_absolute_error')
    
    return encoder, decoder_A, decoder_B, autoencoder_A, autoencoder_B

def load_images(directory, target_size=(256, 256)):
    """Load all images from a directory and convert to numpy arrays"""
    images = []
    image_paths = glob(os.path.join(directory, "*.jpg"))
    
    for img_path in image_paths:
        img = load_img(img_path, target_size=target_size)
        img_array = img_to_array(img) / 255.0  # Normalize to [0,1]
        images.append(img_array)
    
    return np.array(images)

def train_deepfake_model(person_A_dir, person_B_dir, epochs=100, batch_size=16):
    """Train a deepfake model on two people's face datasets"""
    # Load datasets
    faces_A = load_images(person_A_dir)
    faces_B = load_images(person_B_dir)
    
    print(f"Loaded {len(faces_A)} images of person A and {len(faces_B)} images of person B")
    
    # Build models
    encoder, decoder_A, decoder_B, autoencoder_A, autoencoder_B = build_autoencoder()
    
    # Train the autoencoders
    for epoch in range(epochs):
        print(f"Epoch {epoch+1}/{epochs}")
        
        # Train autoencoder A (A→A)
        history_A = autoencoder_A.fit(
            faces_A, faces_A,
            epochs=1,
            batch_size=batch_size,
            verbose=1
        )
        
        # Train autoencoder B (B→B)
        history_B = autoencoder_B.fit(
            faces_B, faces_B,
            epochs=1,
            batch_size=batch_size,
            verbose=1
        )
        
        # Print progress
        print(f"A: {history_A.history['loss'][0]:.4f} - B: {history_B.history['loss'][0]:.4f}")
        
        # Optional: Save sample outputs periodically
        if (epoch + 1) % 10 == 0:
            # Generate sample A→A, A→B, B→B, B→A conversions
            sample_A = faces_A[0:1]  # Get a sample face A
            sample_B = faces_B[0:1]  # Get a sample face B
            
            # Encode the faces
            latent_A = encoder.predict(sample_A)
            latent_B = encoder.predict(sample_B)
            
            # Generate the outputs
            recon_A = decoder_A.predict(latent_A)  # A→A
            recon_B = decoder_B.predict(latent_B)  # B→B
            fake_B = decoder_B.predict(latent_A)   # A→B (deepfake)
            fake_A = decoder_A.predict(latent_B)   # B→A (deepfake)
            
            # Save the images
            for i, img in enumerate([sample_A[0], recon_A[0], fake_B[0], sample_B[0], recon_B[0], fake_A[0]]):
                tf.keras.preprocessing.image.save_img(
                    f"samples/epoch_{epoch+1}_img_{i}.jpg",
                    img
                )
    
    # Save the final models
    encoder.save("models/encoder.h5")
    decoder_A.save("models/decoder_A.h5")
    decoder_B.save("models/decoder_B.h5")
    
    return encoder, decoder_A, decoder_B

# Example usage
train_deepfake_model(
    person_A_dir="preprocessed_faces/person_A",
    person_B_dir="preprocessed_faces/person_B",
    epochs=100
)

import cv2
import numpy as np
from PIL import Image, ImageFilter
import face_recognition
import dlib

def post_process_deepfake(source_image, generated_face, target_image):
    """
    Post-process a generated face to blend it seamlessly into a target image
    
    Args:
        source_image: Original source image (for color correction reference)
        generated_face: The swapped face generated by the deepfake model
        target_image: The target image where the face will be placed
        
    Returns:
        Composite image with the face seamlessly integrated
    """
    # Convert to numpy arrays if needed
    if isinstance(source_image, str):
        source_image = cv2.imread(source_image)
    if isinstance(generated_face, str):
        generated_face = cv2.imread(generated_face)
    if isinstance(target_image, str):
        target_image = cv2.imread(target_image)
    
    # 1. Detect face in target image to determine placement
    face_locations = face_recognition.face_locations(target_image)
    if not face_locations:
        print("No face detected in target image")
        return target_image
    
    # Take the first face (assuming main subject)
    top, right, bottom, left = face_locations[0]
    
    # 2. Get facial landmarks for precise alignment
    target_landmarks = face_recognition.face_landmarks(target_image, face_locations)[0]
    
    # 3. Resize generated face to match target face dimensions
    target_face_height = bottom - top
    target_face_width = right - left
    generated_face_resized = cv2.resize(generated_face, (target_face_width, target_face_height))
    
    # 4. Color correction to match the target image tone
    # Convert to LAB color space
    source_lab = cv2.cvtColor(source_image, cv2.COLOR_BGR2LAB)
    generated_lab = cv2.cvtColor(generated_face_resized, cv2.COLOR_BGR2LAB)
    target_face_lab = cv2.cvtColor(target_image[top:bottom, left:right], cv2.COLOR_BGR2LAB)
    
    # Split channels
    source_l, source_a, source_b = cv2.split(source_lab)
    generated_l, generated_a, generated_b = cv2.split(generated_lab)
    target_l, target_a, target_b = cv2.split(target_face_lab)
    
    # Get mean and standard deviation of each channel
    source_l_mean, source_l_std = np.mean(source_l), np.std(source_l)
    generated_l_mean, generated_l_std = np.mean(generated_l), np.std(generated_l)
    target_l_mean, target_l_std = np.mean(target_l), np.std(target_l)
    
    # Adjust lighting
    generated_l = ((generated_l - generated_l_mean) * (target_l_std / generated_l_std)) + target_l_mean
    
    # Merge channels back
    color_corrected = cv2.merge([generated_l.astype(np.uint8), generated_a, generated_b])
    color_corrected = cv2.cvtColor(color_corrected, cv2.COLOR_LAB2BGR)
    
    # 5. Create a mask for seamless blending
    mask = np.zeros((target_face_height, target_face_width), dtype=np.uint8)
    
    # Create an oval mask based on face dimensions
    center = (target_face_width // 2, target_face_height // 2)
    axes = (int(target_face_width * 0.45), int(target_face_height * 0.55))
    cv2.ellipse(mask, center, axes, 0, 0, 360, 255, -1)
    
    # Feather the mask edges
    mask = cv2.GaussianBlur(mask, (19, 19), 0)
    
    # 6. Alpha blending using the mask
    mask_3channel = cv2.merge([mask, mask, mask]) / 255.0
    
    # Create a copy of the target image
    result = target_image.copy()
    face_area = result[top:bottom, left:right]
    
    # Blend the generated face with the target image
    blended_face = (color_corrected * mask_3channel) + (face_area * (1 - mask_3channel))
    result[top:bottom, left:right] = blended_face.astype(np.uint8)
    
    # 7. Apply additional post-processing for realism
    # Slightly blur the boundary
    temp_result = Image.fromarray(cv2.cvtColor(result, cv2.COLOR_BGR2RGB))
    face_area = temp_result.crop((left, top, right, bottom))
    face_area = face_area.filter(ImageFilter.SMOOTH_MORE)
    temp_result.paste(face_area, (left, top))
    result = cv2.cvtColor(np.array(temp_result), cv2.COLOR_RGB2BGR)
    
    return result

def process_video_deepfake(source_video_path, target_video_path, output_path, 
                          encoder_model, decoder_model):
    """
    Process a video to create a deepfake by swapping faces frame by frame
    
    Args:
        source_video_path: Path to the source video with the face to use
        target_video_path: Path to the target video where faces will be replaced
        output_path: Path to save the resulting deepfake video
        encoder_model: The encoder model for feature extraction
        decoder_model: The decoder model for face generation
    """
    # Open target video
    target_cap = cv2.VideoCapture(target_video_path)
    fps = target_cap.get(cv2.CAP_PROP_FPS)
    width = int(target_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(target_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    frame_count = int(target_cap.get(cv2.CAP_PROP_FRAME_COUNT))
    
    # Create source face extractor
    source_cap = cv2.VideoCapture(source_video_path)
    _, source_frame = source_cap.read()
    source_cap.release()
    
    # Setup output video
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
    
    # Face detector
    detector = dlib.get_frontal_face_detector()
    
    # Process each frame
    frame_num = 0
    while True:
        ret, target_frame = target_cap.read()
        if not ret:
            break
            
        # Detect faces in target frame
        gray = cv2.cvtColor(target_frame, cv2.COLOR_BGR2GRAY)
        faces = detector(gray)
        
        # If no faces found, use original frame
        if not faces:
            out.write(target_frame)
            continue
        
        # Process each detected face
        for face in faces:
            # Extract face region
            x1, y1 = face.left(), face.top()
            x2, y2 = face.right(), face.bottom()
            
            # Add margin
            margin = int(0.2 * (x2 - x1))
            x1 = max(0, x1 - margin)
            y1 = max(0, y1 - margin)
            x2 = min(target_frame.shape[1], x2 + margin)
            y2 = min(target_frame.shape[0], y2 + margin)
            
            face_img = target_frame[y1:y2, x1:x2]
            
            # Resize to model input size
            face_resized = cv2.resize(face_img, (256, 256))
            face_norm = face_resized / 255.0
            
            # Encode and decode to generate the swapped face
            face_encoded = encoder_model.predict(np.expand_dims(face_norm, axis=0))
            face_generated = decoder_model.predict(face_encoded)[0]
            
            # Convert generated face back to uint8
            face_generated = (face_generated * 255).astype(np.uint8)
            
            # Post-process and blend the face
            processed_face = post_process_deepfake(
                source_image=source_frame,
                generated_face=face_generated,
                target_image=target_frame
            )
            
            # Replace the frame with the processed result
            target_frame = processed_face
        
        # Write the frame to output video
        out.write(target_frame)
        
        # Show progress
        frame_num += 1
        if frame_num % 10 == 0:
            print(f"Processed {frame_num}/{frame_count} frames ({frame_num/frame_count*100:.1f}%)")
    
    # Release resources
    target_cap.release()
    out.release()
    print(f"Deepfake video saved to {output_path}")

import boto3
import json
import numpy as np
from PIL import Image
import io
import cv2

# Setup AWS services
s3 = boto3.client('s3')
rekognition = boto3.client('rekognition')
sagemaker = boto3.client('sagemaker-runtime')

def extract_frames(video_path, frame_interval=30):
    """Extract frames from video at specific intervals"""
    frames = []
    video = cv2.VideoCapture(video_path)
    frame_count = 0
    
    while True:
        success, frame = video.read()
        if not success:
            break
        
        if frame_count % frame_interval == 0:
            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            frames.append(frame_rgb)
        
        frame_count += 1
    
    video.release()
    return frames

def detect_faces(frame):
    """Detect faces in a frame using Amazon Rekognition"""
    img_bytes = cv2.imencode('.jpg', frame)[1].tostring()
    response = rekognition.detect_faces(
        Image={'Bytes': img_bytes},
        Attributes=['ALL']
    )
    return response['FaceDetails']

def analyze_frame_for_deepfake(frame, endpoint_name):
    """Send frame to SageMaker endpoint for deepfake analysis"""
    img_bytes = cv2.imencode('.jpg', frame)[1].tostring()
    
    response = sagemaker.invoke_endpoint(
        EndpointName=endpoint_name,
        ContentType='application/x-image',
        Body=img_bytes
    )
    
    result = json.loads(response['Body'].read().decode())
    return result

def process_video(video_path, sagemaker_endpoint):
    """Process video to detect deepfakes"""
    frames = extract_frames(video_path)
    results = []
    
    for frame in frames:
        faces = detect_faces(frame)
        
        if not faces:
            continue
            
        # For each detected face, check if it's a deepfake
        for face in faces:
            # Extract face bounding box
            bbox = face['BoundingBox']
            h, w, _ = frame.shape
            
            # Convert relative coordinates to absolute
            x1 = int(bbox['Left'] * w)
            y1 = int(bbox['Top'] * h)
            x2 = int((bbox['Left'] + bbox['Width']) * w)
            y2 = int((bbox['Top'] + bbox['Height']) * h)
            
            # Extract face region
            face_img = frame[y1:y2, x1:x2]
            
            # Analyze face for deepfake
            analysis = analyze_frame_for_deepfake(face_img, sagemaker_endpoint)
            results.append(analysis)
    
    # Aggregate results
    real_prob = np.mean([r['real_probability'] for r in results])
    fake_prob = np.mean([r['fake_probability'] for r in results])
    
    return {
        'is_deepfake': fake_prob > real_prob,
        'confidence': max(real_prob, fake_prob),
        'frame_results': results
    }

# Example SageMaker model deployment script
def deploy_deepfake_model():
    """Deploy a pre-trained deepfake detection model to SageMaker"""
    sagemaker_client = boto3.client('sagemaker')
    
    # Create model
    model_name = 'deepfake-detection-model'
    
    sagemaker_client.create_model(
        ModelName=model_name,
        PrimaryContainer={
            'Image': '12345.dkr.ecr.us-west-2.amazonaws.com/deepfake-detection:latest',
            'ModelDataUrl': 's3://my-bucket/model-artifacts/deepfake-model.tar.gz'
        },
        ExecutionRoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole'
    )
    
    # Create endpoint configuration
    endpoint_config_name = 'deepfake-detection-config'
    
    sagemaker_client.create_endpoint_config(
        EndpointConfigName=endpoint_config_name,
        ProductionVariants=[
            {
                'VariantName': 'AllTraffic',
                'ModelName': model_name,
                'InstanceType': 'ml.g4dn.xlarge',  # GPU instance
                'InitialInstanceCount': 1
            }
        ]
    )
    
    # Create endpoint
    endpoint_name = 'deepfake-detection-endpoint'
    
    sagemaker_client.create_endpoint(
        EndpointName=endpoint_name,
        EndpointConfigName=endpoint_config_name
    )
    
    return endpoint_name

# Lambda function for processing videos uploaded to S3
def lambda_handler(event, context):
    bucket = event['Records'][0]['s3']['bucket']['name']
    key = event['Records'][0]['s3']['object']['key']
    
    # Download video from S3
    tmp_video_path = '/tmp/video.mp4'
    s3.download_file(bucket, key, tmp_video_path)
    
    # Process video
    endpoint_name = 'deepfake-detection-endpoint'
    result = process_video(tmp_video_path, endpoint_name)
    
    # Save result to S3
    result_key = key.replace('.mp4', '-analysis.json')
    s3.put_object(
        Bucket=bucket,
        Key=result_key,
        Body=json.dumps(result)
    )
    
    return {
        'statusCode': 200,
        'body': json.dumps({
            'message': 'Video analysis complete',
            'result_location': f's3://{bucket}/{result_key}'
        })
    }

from google.cloud import storage, vision, videointelligence
from google.cloud import aiplatform
import os
import tempfile
import cv2
import numpy as np
import json
import tensorflow as tf

# Initialize GCP clients
storage_client = storage.Client()
vision_client = vision.ImageAnnotatorClient()
video_client = videointelligence.VideoIntelligenceServiceClient()

def extract_frames_gcs(gcs_uri, local_dir, frame_interval=30):
    """Download video from GCS and extract frames"""
    bucket_name, blob_name = gcs_uri.replace('gs://', '').split('/', 1)
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(blob_name)
    
    # Download to temporary file
    _, temp_local_filename = tempfile.mkstemp(suffix='.mp4')
    blob.download_to_filename(temp_local_filename)
    
    # Extract frames
    frames = []
    frame_paths = []
    video = cv2.VideoCapture(temp_local_filename)
    frame_count = 0
    
    os.makedirs(local_dir, exist_ok=True)
    
    while True:
        success, frame = video.read()
        if not success:
            break
        
        if frame_count % frame_interval == 0:
            frame_path = os.path.join(local_dir, f'frame_{frame_count:04d}.jpg')
            cv2.imwrite(frame_path, frame)
            frames.append(frame)
            frame_paths.append(frame_path)
        
        frame_count += 1
    
    video.release()
    os.remove(temp_local_filename)
    
    return frames, frame_paths

def detect_faces_gcp(image_path):
    """Detect faces using Google Vision API"""
    with open(image_path, 'rb') as image_file:
        content = image_file.read()
    
    image = vision.Image(content=content)
    response = vision_client.face_detection(image=image)
    faces = response.face_annotations
    
    return faces

def upload_frames_to_gcs(frame_paths, gcs_output_uri):
    """Upload frames to GCS for processing"""
    bucket_name, base_path = gcs_output_uri.replace('gs://', '').split('/', 1)
    bucket = storage_client.bucket(bucket_name)
    
    gcs_frame_paths = []
    
    for frame_path in frame_paths:
        frame_name = os.path.basename(frame_path)
        blob_path = f"{base_path}/{frame_name}"
        blob = bucket.blob(blob_path)
        blob.upload_from_filename(frame_path)
        gcs_frame_paths.append(f"gs://{bucket_name}/{blob_path}")
    
    return gcs_frame_paths

def analyze_faces_for_deepfake(gcs_frame_paths, model_endpoint):
    """Analyze extracted faces using Vertex AI endpoint"""
    aiplatform.init(project='my-gcp-project', location='us-central1')
    endpoint = aiplatform.Endpoint(model_endpoint)
    
    results = []
    
    for frame_path in gcs_frame_paths:
        # Get prediction from endpoint
        prediction = endpoint.predict(
            instances=[{"image_gcs_uri": frame_path}]
        )
        
        results.append({
            'frame': frame_path,
            'real_probability': float(prediction.predictions[0][0]),
            'fake_probability': float(prediction.predictions[0][1])
        })
    
    return results

def deploy_vertex_model():
    """Deploy a pre-trained deepfake model to Vertex AI"""
    aiplatform.init(project='my-gcp-project', location='us-central1')
    
    # Upload model to Vertex AI
    model = aiplatform.Model.upload(
        display_name="deepfake-detection",
        artifact_uri="gs://my-models/deepfake-model/",
        serving_container_image_uri="gcr.io/my-project/deepfake-model:latest"
    )
    
    # Deploy model to endpoint
    endpoint = model.deploy(
        machine_type="n1-standard-4",
        accelerator_type="NVIDIA_TESLA_T4",
        accelerator_count=1,
        min_replica_count=1,
        max_replica_count=1
    )
    
    return endpoint.resource_name

def create_cloud_function():
    """Example Cloud Function code for deepfake detection"""
    # This would be in main.py of your Cloud Function
    
    def process_video(request):
        """Process video for deepfake detection when uploaded to GCS"""
        data = request.get_json()
        
        if not data or 'gcs_uri' not in data:
            return {'error': 'Missing GCS URI'}, 400
        
        gcs_uri = data['gcs_uri']
        output_dir = data.get('output_dir', 'gs://output-bucket/results/')
        
        # Create temporary directory for frames
        temp_dir = tempfile.mkdtemp()
        
        try:
            # Extract frames
            _, frame_paths = extract_frames_gcs(gcs_uri, temp_dir)
            
            # Upload frames for processing
            gcs_frame_paths = upload_frames_to_gcs(frame_paths, output_dir)
            
            # Analyze frames
            model_endpoint = "projects/my-project/locations/us-central1/endpoints/12345"
            results = analyze_faces_for_deepfake(gcs_frame_paths, model_endpoint)
            
            # Aggregate results
            real_probs = [r['real_probability'] for r in results]
            fake_probs = [r['fake_probability'] for r in results]
            
            final_result = {
                'is_deepfake': np.mean(fake_probs) > np.mean(real_probs),
                'confidence': max(np.mean(real_probs), np.mean(fake_probs)),
                'frame_results': results
            }
            
            # Save results
            bucket_name, base_path = output_dir.replace('gs://', '').split('/', 1)
            bucket = storage_client.bucket(bucket_name)
            result_blob = bucket.blob(f"{base_path}/analysis_result.json")
            result_blob.upload_from_string(json.dumps(final_result))
            
            return {
                'status': 'success',
                'result_uri': f"gs://{bucket_name}/{base_path}/analysis_result.json"
            }
            
        finally:
            # Cleanup
            import shutil
            shutil.rmtree(temp_dir)
    
    return process_video

import os
import tempfile
import json
import numpy as np
import cv2
from azure.storage.blob import BlobServiceClient
from azure.cognitiveservices.vision.face import FaceClient
from msrest.authentication import CognitiveServicesCredentials
from azure.ai.ml import MLClient
from azure.ai.ml.entities import ManagedOnlineEndpoint, ManagedOnlineDeployment
from azure.identity import DefaultAzureCredential
import azure.functions as func

# Azure credentials
face_key = os.environ["FACE_API_KEY"]
face_endpoint = os.environ["FACE_API_ENDPOINT"]
storage_connection_string = os.environ["STORAGE_CONNECTION_STRING"]

# Setup Azure clients
face_client = FaceClient(face_endpoint, CognitiveServicesCredentials(face_key))
blob_service_client = BlobServiceClient.from_connection_string(storage_connection_string)

def extract_frames_azure(blob_url, local_dir, frame_interval=30):
    """Download video from Azure Blob Storage and extract frames"""
    # Parse blob URL
    container_name = blob_url.split('/')[3]
    blob_path = '/'.join(blob_url.split('/')[4:])
    
    # Download blob
    container_client = blob_service_client.get_container_client(container_name)
    blob_client = container_client.get_blob_client(blob_path)
    
    _, temp_local_filename = tempfile.mkstemp(suffix='.mp4')
    with open(temp_local_filename, "wb") as video_file:
        download_stream = blob_client.download_blob()
        video_file.write(download_stream.readall())
    
    # Extract frames
    frames = []
    frame_paths = []
    video = cv2.VideoCapture(temp_local_filename)
    frame_count = 0
    
    os.makedirs(local_dir, exist_ok=True)
    
    while True:
        success, frame = video.read()
        if not success:
            break
        
        if frame_count % frame_interval == 0:
            frame_path = os.path.join(local_dir, f'frame_{frame_count:04d}.jpg')
            cv2.imwrite(frame_path, frame)
            frames.append(frame)
            frame_paths.append(frame_path)
        
        frame_count += 1
    
    video.release()
    os.remove(temp_local_filename)
    
    return frames, frame_paths

def detect_faces_azure(image_path):
    """Detect faces using Azure Face API"""
    with open(image_path, 'rb') as image_file:
        detected_faces = face_client.face.detect_with_stream(
            image_file,
            return_face_attributes=['age', 'gender', 'emotion']
        )
    
    return detected_faces

def upload_frames_to_blob(frame_paths, container_name, base_path):
    """Upload frames to Azure Blob Storage"""
    container_client = blob_service_client.get_container_client(container_name)
    
    blob_paths = []
    
    for frame_path in frame_paths:
        frame_name = os.path.basename(frame_path)
        blob_path = f"{base_path}/{frame_name}"
        blob_client = container_client.get_blob_client(blob_path)
        
        with open(frame_path, "rb") as data:
            blob_client.upload_blob(data, overwrite=True)
            
        blob_paths.append(f"https://{blob_service_client.account_name}.blob.core.windows.net/{container_name}/{blob_path}")
    
    return blob_paths

def deploy_azure_ml_model():
    """Deploy a pre-trained deepfake model to Azure ML"""
    # Initialize MLClient
    credential = DefaultAzureCredential()
    ml_client = MLClient(
        credential=credential,
        subscription_id="your-subscription-id",
        resource_group_name="your-resource-group",
        workspace_name="your-workspace"
    )
    
    # Create an online endpoint
    endpoint = ManagedOnlineEndpoint(
        name="deepfake-endpoint",
        description="Endpoint for deepfake detection",
        auth_mode="key"
    )
    ml_client.begin_create_or_update(endpoint).result()
    
    # Create a deployment
    deployment = ManagedOnlineDeployment(
        name="deepfake-deployment",
        endpoint_name=endpoint.name,
        model="azureml:deepfake-model:1",
        instance_type="Standard_NC6s_v3",  # GPU instance
        instance_count=1
    )
    ml_client.begin_create_or_update(deployment).result()
    
    return endpoint.name

def analyze_frames_for_deepfake(blob_paths, endpoint_name):
    """Analyze frames using Azure ML endpoint"""
    credential = DefaultAzureCredential()
    ml_client = MLClient(
        credential=credential,
        subscription_id="your-subscription-id",
        resource_group_name="your-resource-group",
        workspace_name="your-workspace"
    )
    
    endpoint = ml_client.online_endpoints.get(name=endpoint_name)
    
    results = []
    for blob_path in blob_paths:
        # Prepare the input data
        input_data = {
            "image_url": blob_path
        }
        
        # Get prediction
        response = ml_client.online_endpoints.invoke(
            endpoint_name=endpoint_name,
            deployment_name="deepfake-deployment",
            request_file=json.dumps(input_data)
        )
        
        prediction = json.loads(response)
        
        results.append({
            'frame': blob_path,
            'real_probability': prediction['real_probability'],
            'fake_probability': prediction['fake_probability']
        })
    
    return results

# Azure Function implementation
def main(req: func.HttpRequest) -> func.HttpResponse:
    """Azure Function for deepfake detection"""
    try:
        req_body = req.get_json()
        video_url = req_body.get('video_url')
        
        if not video_url:
            return func.HttpResponse(
                "Please provide a video_url in the request body",
                status_code=400
            )
        
        # Create temporary directory for frames
        temp_dir = tempfile.mkdtemp()
        
        try:
            # Extract frames
            _, frame_paths = extract_frames_azure(video_url, temp_dir)
            
            # Upload frames for processing
            output_container = "deepfake-output"
            base_path = f"analysis/{os.path.basename(video_url)}"
            blob_paths = upload_frames_to_blob(frame_paths, output_container, base_path)
            
            # Detect faces in frames
            face_results = []
            for frame_path in frame_paths:
                faces = detect_faces_azure(frame_path)
                face_results.append({
                    'frame': os.path.basename(frame_path),
                    'faces': len(faces)
                })
            
            # Analyze frames for deepfakes
            endpoint_name = "deepfake-endpoint"
            deepfake_results = analyze_frames_for_deepfake(blob_paths, endpoint_name)
            
            # Aggregate results
            real_probs = [r['real_probability'] for r in deepfake_results]
            fake_probs = [r['fake_probability'] for r in deepfake_results]
            
            final_result = {
                'is_deepfake': np.mean(fake_probs) > np.mean(real_probs),
                'confidence': max(np.mean(real_probs), np.mean(fake_probs)),
                'frame_results': deepfake_results,
                'face_detection': face_results
            }
            
            # Save results to blob storage
            container_client = blob_service_client.get_container_client(output_container)
            result_blob_path = f"{base_path}/analysis_result.json"
            result_blob = container_client.get_blob_client(result_blob_path)
            result_blob.upload_blob(json.dumps(final_result), overwrite=True)
            
            return func.HttpResponse(
                json.dumps({
                    'status': 'success',
                    'result_url': f"https://{blob_service_client.account_name}.blob.core.windows.net/{output_container}/{result_blob_path}"
                }),
                mimetype="application/json"
            )
            
        finally:
            # Cleanup
            import shutil
            shutil.rmtree(temp_dir)
            
    except Exception as e:
        return func.HttpResponse(
            f"An error occurred: {str(e)}",
            status_code=500
        )

import tensorflow as tf
from tensorflow.keras import layers, Model, applications
import cv2
import numpy as np
import os
import glob
from sklearn.model_selection import train_test_split

# Define model architecture for deepfake detection
def create_deepfake_detection_model(input_shape=(224, 224, 3)):
    """Create a CNN model for deepfake detection"""
    # Use a pre-trained model as base
    base_model = applications.EfficientNetB0(
        include_top=False,
        weights='imagenet',
        input_shape=input_shape
    )
    
    # Freeze the base model
    base_model.trainable = False
    
    # Create new model on top
    inputs = tf.keras.Input(shape=input_shape)
    x = tf.keras.applications.efficientnet.preprocess_input(inputs)
    x = base_model(x, training=False)
    x = layers.GlobalAveragePooling2D()(x)
    x = layers.Dropout(0.2)(x)
    x = layers.Dense(1024, activation='relu')(x)
    x = layers.Dropout(0.2)(x)
    x = layers.Dense(512, activation='relu')(x)
    outputs = layers.Dense(2, activation='softmax')(x)
    
    model = Model(inputs, outputs)
    
    # Compile the model
    model.compile(
        optimizer='adam',
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )
    
    return model

def prepare_dataset(real_dir, fake_dir, img_size=(224, 224)):
    """Prepare dataset from directories of real and fake images"""
    # Load real images
    real_images = glob.glob(os.path.join(real_dir, "*.jpg"))
    real_images.extend(glob.glob(os.path.join(real_dir, "*.png")))
    
    # Load fake images
    fake_images = glob.glob(os.path.join(fake_dir, "*.jpg"))
    fake_images.extend(glob.glob(os.path.join(fake_dir, "*.png")))
    
    # Create labels
    real_labels = np.array([[1, 0]] * len(real_images))  # [1, 0] for real
    fake_labels = np.array([[0, 1]] * len(fake_images))  # [0, 1] for fake
    
    # Combine datasets
    all_images = real_images + fake_images
    all_labels = np.vstack((real_labels, fake_labels))
    
    # Split into train and validation sets
    train_images, val_images, train_labels, val_labels = train_test_split(
        all_images, all_labels, test_size=0.2, random_state=42
    )
    
    # Create data generators
    def data_generator(images, labels, batch_size=32):
        num_samples = len(images)
        while True:
            indices = np.random.permutation(num_samples)
            for i in range(0, num_samples, batch_size):
                batch_indices = indices[i:i+batch_size]
                batch_images = []
                
                for idx in batch_indices:
                    img = cv2.imread(images[idx])
                    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
                    img = cv2.resize(img, img_size)
                    batch_images.append(img)
                
                batch_images = np.array(batch_images) / 255.0
                batch_labels = labels[batch_indices]
                
                yield batch_images, batch_labels
    
    return data_generator(train_images, train_labels), data_generator(val_images, val_labels), len(train_images), len(val_images)

def train_model(model, train_generator, val_generator, train_steps, val_steps, epochs=10):
    """Train the deepfake detection model"""
    history = model.fit(
        train_generator,
        steps_per_epoch=train_steps // 32,
        epochs=epochs,
        validation_data=val_generator,
        validation_steps=val_steps // 32,
        callbacks=[
            tf.keras.callbacks.EarlyStopping(
                monitor='val_loss',
                patience=3,
                restore_best_weights=True
            ),
            tf.keras.callbacks.ReduceLROnPlateau(
                monitor='val_loss',
                factor=0.2,
                patience=2
            )
        ]
    )
    
    return history

def fine_tune_model(model, train_generator, val_generator, train_steps, val_steps, epochs=5):
    """Fine-tune the model by unfreezing some layers"""
    # Unfreeze the top layers of the base model
    base_model = model.layers[2]  # Assuming base_model is at index 2
    base_model.trainable = True
    
    # Freeze all the layers except the last 15
    for layer in base_model.layers[:-15]:
        layer.trainable = False
    
    # Recompile the model with a lower learning rate
    model.compile(
        optimizer=tf.keras.optimizers.Adam(1e-5),
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )
    
    # Continue training
    history = model.fit(
        train_generator,
        steps_per_epoch=train_steps // 32,
        epochs=epochs,
        validation_data=val_generator,
        validation_steps=val_steps // 32,
        callbacks=[
            tf.keras.callbacks.EarlyStopping(
                monitor='val_loss',
                patience=3,
                restore_best_weights=True
            )
        ]
    )
    
    return history

def detect_deepfake(model, image_path, threshold=0.5):
    """Detect if an image is a deepfake"""
    # Load and preprocess image
    img = cv2.imread(image_path)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    img = cv2.resize(img, (224, 224))
    img = np.expand_dims(img / 255.0, axis=0)
    
    # Make prediction
    prediction = model.predict(img)[0]
    real_prob = prediction[0]
    fake_prob = prediction[1]
    
    result = {
        'is_deepfake': fake_prob > threshold,
        'confidence': max(real_prob, fake_prob),
        'real_probability': float(real_prob),
        'fake_probability': float(fake_prob)
    }
    
    return result

def process_video_for_deepfakes(model, video_path, frame_interval=30, threshold=0.5):
    """Process a video to detect deepfakes"""
    # Extract frames
    frames = []
    video = cv2.VideoCapture(video_path)
    frame_count = 0
    
    while True:
        success, frame = video.read()
        if not success:
            break
        
        if frame_count % frame_interval == 0:
            frames.append(frame)
        
        frame_count += 1
    
    video.release()
    
    # Analyze each frame
    results = []
    for i, frame in enumerate(frames):
        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        frame_resized = cv2.resize(frame_rgb, (224, 224))
        frame_normalized = np.expand_dims(frame_resized / 255.0, axis=0)
        
        prediction = model.predict(frame_normalized)[0]
        results.append({
            'frame': i *