Upload 3 files

face_segmentation_project.py

@@ -0,0 +1,1038 @@
+# -*- coding: utf-8 -*-
+"""Face_Segmentation_Project.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1sLYDzM6pK7GBZW2JH7xMoVa0kOYYS9B5
+
+## STEP 1 — Google Drive Mount Karo
+"""
+
+from google.colab import drive
+drive.mount('/content/drive')
+
+"""## ✅ STEP 2 — Set Path
+
+"""
+
+# Pehle path define karo (Apne folder ke hisaab se check kar lena)
+TRAIN_NPY = "/content/drive/MyDrive/Face_Segmentation_Project/data/raw/Part 1- Train data - images.npy"
+
+import numpy as np
+
+print("Loading .npy file... (thoda time lagega 1.26GB hai)")
+data = np.load(TRAIN_NPY, allow_pickle=True)
+
+print("\n--- DATA INFO ---")
+print("Type   :", type(data))
+print("Shape  :", data.shape)
+print("Dtype  :", data.dtype)
+
+# Agar object/dictionary ho
+if data.dtype == object:
+    print("\nObject type hai, keys dekho:")
+    try:
+        d = data.item()
+        print("Keys:", d.keys())
+    except:
+        print("Array of objects - length:", len(data))
+        print("First element type:", type(data[0]))
+        print("First element shape:", data[0].shape if hasattr(data[0], 'shape') else "no shape")
+else:
+    print("\nMin value :", data.min())
+    print("Max value :", data.max())
+    print("Total images:", data.shape[0])
+
+# STEP 3 — Data Visualization (Andar kya hai dekho)
+
+import matplotlib.pyplot as plt
+
+# Pehla sample nikaalte hain
+sample = data[0]
+image_data = sample[0] # Pehla part image hona chahiye
+mask_data = sample[1]  # Dusra part mask ya annotations
+
+print(f"Image shape: {image_data.shape}")
+print(f"Mask/Metadata type: {type(mask_data)}")
+
+# Ek bar visualize karke dekhte hain
+plt.imshow(image_data)
+plt.title("Sample Image")
+plt.show()
+
+# ✅ STEP 4 — Mask Check Karo (Andar kya hai?)
+
+# List ka content check karte hain
+print("Mask List Content:")
+print(mask_data)
+
+# Agar list ke pehle element mein 'notes' ya 'points' jaisi koi key hai toh:
+if len(mask_data) > 0:
+    print("\nFirst element in list:", mask_data[0])
+
+# 🛠️ STEP 5 — Coordinates se Binary Mask Banana
+
+import cv2
+import numpy as np
+
+def create_mask(image_shape, mask_list):
+    # Ek khali black image banao (0s)
+    mask = np.zeros(image_shape[:2], dtype=np.uint8)
+
+    h, w = image_shape[:2]
+
+    for item in mask_list:
+        # Normalized coordinates ko pixel values mein badlo
+        p1 = item['points'][0]
+        p2 = item['points'][1]
+
+        x1, y1 = int(p1['x'] * w), int(p1['y'] * h)
+        x2, y2 = int(p2['x'] * w), int(p2['y'] * h)
+
+        # Is area ko white (255) kar do
+        cv2.rectangle(mask, (x1, y1), (x2, y2), 255, -1)
+
+    return mask
+
+# Test karte hain
+test_mask = create_mask(image_data.shape, mask_data)
+
+# Visualize Image + Mask
+plt.figure(figsize=(10, 5))
+plt.subplot(1, 2, 1)
+plt.imshow(image_data); plt.title("Original Image")
+plt.subplot(1, 2, 2)
+plt.imshow(test_mask, cmap='gray'); plt.title("Generated Mask")
+plt.show()
+
+# ✅ STEP 6 — Data Preprocessing for U-Net
+
+import cv2
+import numpy as np
+from tqdm import tqdm
+
+IMG_HEIGHT = 256
+IMG_WIDTH = 256
+
+X = []
+y = []
+
+print("Processing 409 images and masks...")
+
+for i in tqdm(range(len(data))):
+    img_array = data[i][0]
+    mask_list = data[i][1]
+
+    img_resized = cv2.resize(img_array, (IMG_WIDTH, IMG_HEIGHT))
+
+    if len(img_resized.shape) == 2:
+        img_resized = cv2.cvtColor(img_resized, cv2.COLOR_GRAY2RGB)
+    elif img_resized.shape[2] == 4:
+        img_resized = cv2.cvtColor(img_resized, cv2.COLOR_RGBA2RGB)
+
+    m_array = create_mask(img_array.shape, mask_list)
+    mask_resized = cv2.resize(m_array, (IMG_WIDTH, IMG_HEIGHT))
+
+    img_norm = img_resized / 255.0
+    mask_norm = mask_resized / 255.0
+
+    # ✅ Original image add karo
+    X.append(img_norm)
+    y.append(mask_norm)
+
+    # ✅ Augmentation 1 — Horizontal Flip
+    X.append(cv2.flip(img_norm, 1))
+    y.append(cv2.flip(mask_norm, 1))
+
+    # ✅ Augmentation 2 — Rotation 15 degree
+    M = cv2.getRotationMatrix2D((128, 128), 15, 1.0)
+    X.append(cv2.warpAffine(img_norm, M, (256, 256)))
+    y.append(cv2.warpAffine(mask_norm, M, (256, 256)))
+
+    # ✅ Augmentation 3 — Brightness Change
+    bright = np.clip(img_norm * 1.2, 0, 1)
+    X.append(bright)
+    y.append(mask_norm)
+
+X = np.array(X, dtype=np.float32)
+y = np.array(y, dtype=np.float32)
+y = np.expand_dims(y, axis=-1)
+
+print("\n✅ Preprocessing Complete!")
+print(f"Images Shape: {X.shape}")
+print(f"Masks Shape : {y.shape}")
+
+# 🚀 STEP 7 — Model Building: U-Net with MobileNetV2
+
+from sklearn.model_selection import train_test_split
+
+X_train, X_temp, y_train, y_temp = train_test_split(
+    X, y, test_size=0.2, random_state=42
+)
+
+X_val, X_test, y_val, y_test = train_test_split(
+    X_temp, y_temp, test_size=0.5, random_state=42
+)
+
+print(f"Training data   : {X_train.shape}")
+print(f"Validation data : {X_val.shape}")
+print(f"Test data       : {X_test.shape}")
+
+from tensorflow.keras.applications import MobileNetV2
+from tensorflow.keras.layers import Input, Conv2D, UpSampling2D, Concatenate, BatchNormalization, Activation, Dropout
+from tensorflow.keras.models import Model
+import tensorflow as tf
+
+def build_unet(input_shape):
+    inputs = Input(input_shape)
+
+    base_model = MobileNetV2(input_tensor=inputs, weights="imagenet", include_top=False)
+
+    # ✅ FIX 1: Encoder freeze karo
+    base_model.trainable = False
+    for layer in base_model.layers[-30:]:
+        layer.trainable = True
+
+    # Skip connections
+    s1 = inputs
+    s2 = base_model.get_layer("block_1_expand_relu").output
+    s3 = base_model.get_layer("block_3_expand_relu").output
+    s4 = base_model.get_layer("block_6_expand_relu").output
+    bridge = base_model.get_layer("block_13_expand_relu").output
+
+    # ✅ FIX 2: Dropout add kiya har decoder block mein
+    u1 = UpSampling2D((2, 2))(bridge)
+    u1 = Concatenate()([u1, s4])
+    u1 = Conv2D(256, 3, padding="same", kernel_initializer="he_normal")(u1)
+    u1 = BatchNormalization()(u1)
+    u1 = Activation("relu")(u1)
+    u1 = Dropout(0.3)(u1)  # ✅
+
+    u2 = UpSampling2D((2, 2))(u1)
+    u2 = Concatenate()([u2, s3])
+    u2 = Conv2D(128, 3, padding="same", kernel_initializer="he_normal")(u2)
+    u2 = BatchNormalization()(u2)
+    u2 = Activation("relu")(u2)
+    u2 = Dropout(0.3)(u2)  # ✅
+
+    u3 = UpSampling2D((2, 2))(u2)
+    u3 = Concatenate()([u3, s2])
+    u3 = Conv2D(64, 3, padding="same", kernel_initializer="he_normal")(u3)
+    u3 = BatchNormalization()(u3)
+    u3 = Activation("relu")(u3)
+    u3 = Dropout(0.2)(u3)  # ✅
+
+    u4 = UpSampling2D((2, 2))(u3)
+    u4 = Concatenate()([u4, s1])
+    u4 = Conv2D(32, 3, padding="same", kernel_initializer="he_normal")(u4)
+    u4 = BatchNormalization()(u4)
+    u4 = Activation("relu")(u4)
+
+    outputs = Conv2D(1, 1, activation="sigmoid")(u4)
+
+    return Model(inputs, outputs)
+
+model = build_unet((256, 256, 3))
+
+# ✅ FIX 3: Combined Loss
+def dice_coefficient(y_true, y_pred):
+    y_true_f = tf.cast(tf.reshape(y_true, [-1]), tf.float32)
+    y_pred_f = tf.cast(tf.reshape(y_pred, [-1]), tf.float32)
+    intersection = tf.reduce_sum(y_true_f * y_pred_f)
+    return (2. * intersection + 1.0) / (tf.reduce_sum(y_true_f) + tf.reduce_sum(y_pred_f) + 1.0)
+
+def dice_loss(y_true, y_pred):
+    return 1 - dice_coefficient(y_true, y_pred)
+
+def combined_loss(y_true, y_pred):
+    return dice_loss(y_true, y_pred) + tf.keras.losses.binary_crossentropy(y_true, y_pred)
+
+model.compile(
+    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3),
+    loss=combined_loss,       # ✅ Combined loss
+    metrics=[dice_coefficient, "accuracy"]
+)
+
+print("✅ Model Compiled Successfully!")
+
+# Training se PEHLE yeh check karo:
+print(f"X_train shape: {X_train.shape}")
+print(f"X_val shape  : {X_val.shape}")
+print(f"X_test shape : {X_test.shape}")
+
+# 🚀 STEP 9 — Model Training (Fit)
+
+from tensorflow.keras.callbacks import ModelCheckpoint, ReduceLROnPlateau, EarlyStopping
+
+callbacks = [
+    ModelCheckpoint("best_face_model.keras", monitor='val_dice_coefficient',
+                    mode='max', save_best_only=True, verbose=1),
+    ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=5,
+                      min_lr=1e-7, verbose=1),
+    EarlyStopping(monitor='val_loss', patience=12,
+                  restore_best_weights=True, verbose=1)
+]
+
+print("🚀 Training shuru ho rahi hai!")
+
+history = model.fit(
+    X_train, y_train,
+    validation_data=(X_val, y_val),
+    epochs=50,
+    batch_size=8,
+    callbacks=callbacks,
+    shuffle=True
+)
+
+print("\n✅ Training Complete!")
+
+# Step - Evaluation Metrix
+from sklearn.metrics import f1_score
+import time
+import numpy as np
+
+def evaluate_model(model, X_test, y_test):
+    y_pred = model.predict(X_test)
+    y_pred_binary = (y_pred > 0.5).astype(np.float32)
+
+    # 1. Dice Coefficient
+    intersection = np.sum(y_test * y_pred_binary)
+    dice = (2. * intersection + 1.0) / (
+        np.sum(y_test) + np.sum(y_pred_binary) + 1.0
+    )
+
+    # 2. IoU Score
+    union = np.sum(y_test) + np.sum(y_pred_binary) - intersection
+    iou = intersection / union
+
+    # 3. F1 Score
+    f1 = f1_score(
+        y_test.flatten().astype(int),
+        y_pred_binary.flatten().astype(int)
+    )
+
+    # 4. ✅ Inference Speed — FIXED VERSION
+    model.predict(X_test[:1], verbose=0)  # Warmup 1
+    model.predict(X_test[:1], verbose=0)  # Warmup 2
+    times = []
+    for _ in range(5):
+        start = time.time()
+        model.predict(X_test[:1], verbose=0)
+        times.append((time.time() - start) * 1000)
+    speed = np.mean(times)
+
+    print("="*45)
+    print(f"Dice Coefficient : {dice:.4f}  (Target >0.92)")
+    print(f"IoU Score        : {iou:.4f}  (Target >0.88)")
+    print(f"F1 Score         : {f1:.4f}  (Target >0.90)")
+    print(f"Inference Speed  : {speed:.1f}ms (Target <100ms)")
+    print("="*45)
+
+# Dobara chalao
+evaluate_model(model, X_test, y_test)
+
+# STEP 11 — Training Curves Plot
+
+import matplotlib.pyplot as plt
+
+plt.figure(figsize=(12, 4))
+
+plt.subplot(1, 2, 1)
+plt.plot(history.history['dice_coefficient'], label='Train Dice')
+plt.plot(history.history['val_dice_coefficient'], label='Val Dice')
+plt.title('Dice Coefficient Progress')
+plt.xlabel('Epoch')
+plt.legend()
+
+plt.subplot(1, 2, 2)
+plt.plot(history.history['loss'], label='Train Loss')
+plt.plot(history.history['val_loss'], label='Val Loss')
+plt.title('Loss Progress')
+plt.xlabel('Epoch')
+plt.legend()
+
+plt.tight_layout()
+plt.show()
+
+import matplotlib.pyplot as plt
+
+def visualize_prediction(index):
+    img = X_val[index]
+    gt_mask = y_val[index]
+
+    # Model se prediction lo
+    pred_mask = model.predict(np.expand_dims(img, axis=0))[0]
+
+    # Thresholding (0.5 se upar white, niche black)
+    pred_mask_binary = (pred_mask > 0.5).astype(np.uint8)
+
+    plt.figure(figsize=(12, 4))
+    plt.subplot(1, 3, 1)
+    plt.imshow(img); plt.title("Original Image")
+
+    plt.subplot(1, 3, 2)
+    plt.imshow(gt_mask.squeeze(), cmap='gray'); plt.title("Ground Truth Mask")
+
+    plt.subplot(1, 3, 3)
+    plt.imshow(pred_mask_binary.squeeze(), cmap='gray'); plt.title("Predicted Mask")
+    plt.show()
+
+# Pehli 3 validation images check karte hain
+for i in [0, 5, 10]:
+    visualize_prediction(i)
+
+# 🚀 STEP 12 — Improving Accuracy with Hugging Face (SegFormer)
+
+!pip install -q transformers datasets
+
+from transformers import SegformerImageProcessor, SegformerForSemanticSegmentation
+import torch
+from PIL import Image
+
+# 1. Pre-trained Model Load Karein
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+# Processor images ko transform karega, model segmentation karega
+processor = SegformerImageProcessor.from_pretrained("nvidia/mit-b0")
+hf_model = SegformerForSemanticSegmentation.from_pretrained("nvidia/mit-b0",
+                                                           num_labels=1,
+                                                           ignore_mismatched_sizes=True).to(device)
+
+print("✅ Hugging Face SegFormer Model Loaded!")
+
+# 🛠️ STEP 12 — SegFormer Dataset Class
+import torch
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
+
+class FaceDataset(Dataset):
+    def __init__(self, images, masks, processor):
+        self.images = images
+        self.masks = masks
+        self.processor = processor
+
+    def __len__(self):
+        return len(self.images)
+
+    def __getitem__(self, idx):
+        # Image aur Mask uthayein
+        # (X_train already normalized hai, hume original format chahiye processor ke liye)
+        image = (self.images[idx] * 255).astype(np.uint8)
+        mask = self.masks[idx].squeeze().astype(np.longlong) # SegFormer expects long for masks
+
+        # Processor se transform karein
+        encoded_inputs = self.processor(image, mask, return_tensors="pt")
+
+        # Squeeze batch dimension jo processor add karta hai
+        for k, v in encoded_inputs.items():
+            encoded_inputs[k] = v.squeeze(0)
+
+        return encoded_inputs
+
+# 1. Dataset Objects Banayein
+train_dataset = FaceDataset(X_train, y_train, processor)
+val_dataset = FaceDataset(X_val, y_val, processor)
+
+# 2. DataLoaders Banayein
+train_dataloader = DataLoader(train_dataset, batch_size=4, shuffle=True)
+val_dataloader = DataLoader(val_dataset, batch_size=4)
+
+print(f"✅ DataLoaders Ready! Training samples: {len(train_dataset)}")
+
+# 🚀 STEP 13 — Fine-tuning SegFormer (Training Loop)
+
+from tqdm.notebook import tqdm
+from torch.optim import AdamW
+
+# 1. Optimizer setup
+optimizer = AdamW(hf_model.parameters(), lr=5e-5)
+
+# 2. Training Loop
+num_epochs = 10  # SegFormer jaldi seekh jata hai
+hf_model.train()
+
+print("🚀 SegFormer Training shuru ho rahi hai...")
+
+for epoch in range(num_epochs):
+    train_loss = 0
+    # Tqdm progress bar ke liye
+    pbar = tqdm(train_dataloader, desc=f"Epoch {epoch+1}")
+
+    for batch in pbar:
+        # Data ko GPU/CPU par bhejein
+        pixel_values = batch["pixel_values"].to(device)
+        labels = batch["labels"].to(device)
+
+        # Forward pass
+        outputs = hf_model(pixel_values=pixel_values, labels=labels)
+        loss = outputs.loss
+
+        # Backward pass
+        loss.backward()
+        optimizer.step()
+        optimizer.zero_grad()
+
+        train_loss += loss.item()
+        pbar.set_postfix({'loss': loss.item()})
+
+    avg_train_loss = train_loss / len(train_dataloader)
+    print(f"✅ Epoch {epoch+1} Complete | Average Loss: {avg_train_loss:.4f}")
+
+print("\n🎉 SegFormer Fine-tuning Finished!")
+
+# 🎨 STEP 14 — SegFormer Prediction & Visualization
+
+import torch.nn as nn
+
+def visualize_segformer_prediction(index):
+    # 1. Validation set se data lein
+    inputs = val_dataset[index]
+    pixel_values = inputs["pixel_values"].unsqueeze(0).to(device)
+    gt_mask = inputs["labels"].numpy()
+
+    # 2. Prediction karein
+    hf_model.eval()
+    with torch.no_grad():
+        outputs = hf_model(pixel_values=pixel_values)
+        logits = outputs.logits  # [1, num_labels, height/4, width/4]
+
+    # 3. Logits ko original image size (256x256) par upsample karein
+    upsampled_logits = nn.functional.interpolate(
+        logits,
+        size=(256, 256),
+        mode='bilinear',
+        align_corners=False
+    )
+
+    # 4. Binary mask banayein (Squeeze karke threshold lagayein)
+    pred_mask = torch.sigmoid(upsampled_logits).cpu().numpy().squeeze()
+    pred_mask_binary = (pred_mask > 0.5).astype(np.uint8)
+
+    # 5. Plotting
+    plt.figure(figsize=(12, 4))
+
+    # Original Image (Pixel values ko denormalize karke dikhayenge)
+    display_img = pixel_values.cpu().squeeze().permute(1, 2, 0).numpy()
+    display_img = (display_img - display_img.min()) / (display_img.max() - display_img.min())
+
+    plt.subplot(1, 3, 1)
+    plt.imshow(display_img)
+    plt.title("Original Image")
+
+    plt.subplot(1, 3, 2)
+    plt.imshow(gt_mask, cmap='gray')
+    plt.title("Ground Truth Mask")
+
+    plt.subplot(1, 3, 3)
+    plt.imshow(pred_mask_binary, cmap='gray')
+    plt.title("SegFormer Prediction")
+
+    plt.show()
+
+# Pehle 3 validation images par results dekhein
+for i in [0, 5, 10]:
+    visualize_segformer_prediction(i)
+
+# 💾 STEP 15 — Model aur Processor ko Save Karein
+
+import os
+
+# 1. Ek folder banate hain model ke liye
+save_directory = "my_face_segformer_model"
+os.makedirs(save_directory, exist_ok=True)
+
+# 2. Model ke weights aur config save karein
+hf_model.save_pretrained(save_directory)
+
+# 3. Processor (jo image resize aur normalize karta hai) bhi save karein
+processor.save_pretrained(save_directory)
+
+print(f"✅ Model successfully saved in: {save_directory}")
+
+# --- Google Colab Users ke liye ---
+# Agar aap chahte hain ki ye hamesha ke liye safe rahe, toh ise Zip karke download kar lein
+!zip -r face_model.zip my_face_segformer_model/
+print("📦 Zip file ban gayi hai! Ab aap ise left side ke 'Files' tab se download kar sakte hain.")
+
+from google.colab import drive
+import shutil
+import os
+
+# 1. Drive mount karein
+drive.mount('/content/drive')
+
+# 2. Aapka bataya hua path define karein
+# Hum Face_Segmentation_Project ke andar 'saved_model' naam ka folder banayenge
+base_path = '/content/drive/MyDrive/Face_Segmentation_Project'
+model_save_path = os.path.join(base_path, 'trained_segformer_model')
+
+# 3. Folder banayein agar nahi hai toh
+os.makedirs(model_save_path, exist_ok=True)
+
+# 4. Colab ki temporary files ko Drive par copy karein
+source_folder = '/content/my_face_segformer_model'
+
+# Purani files clear karke fresh copy karein
+if os.path.exists(model_save_path):
+    shutil.rmtree(model_save_path)
+
+shutil.copytree(source_folder, model_save_path)
+
+print(f"✅ Kaam ho gaya! Aapka model yahan save hai:")
+print(f"📂 {model_save_path}")
+
+import os
+
+# Actor folders banao
+actors = [
+    "Robert_Downey_Jr",
+    "Scarlett_Johansson",
+    "Chris_Evans",
+    "Tom_Cruise",
+    "Leonardo_DiCaprio",
+    "Brad_Pitt",
+    "Chris Hemsworth"
+]
+
+for actor in actors:
+    os.makedirs(f"/content/actor_db/{actor}", exist_ok=True)
+
+print("✅ Actor folders ban gaye!")
+print(os.listdir("/content/actor_db"))
+
+import requests
+import os
+
+actor_images = {
+    "Robert_Downey_Jr": [
+        "https://wallpapers.com/images/hd/focused-photography-robert-downey-jr-pjs7jatnx0yfofsc.jpg",
+        "https://static1.srcdn.com/wordpress/wp-content/uploads/2024/07/instar53643496.jpg"
+    ],
+    "Scarlett_Johansson": [
+        "https://tse2.mm.bing.net/th/id/OIP.OwNfXHWEAynGbQwhmUNQWwHaKk?rs=1&pid=ImgDetMain&o=7&rm=3",
+        "https://m.media-amazon.com/images/M/MV5BMjAyNjE1NjgyMF5BMl5BanBnXkFtZTcwMjg0ODY1NA@@._V1_.jpg"
+    ],
+    "Chris_Evans": [
+        "https://cdn.britannica.com/28/215028-050-94E9EA1E/American-actor-Chris-Evans-2019.jpg",
+        "https://tse4.mm.bing.net/th/id/OIP._aupdpOey-23R2KHLQd0OgHaLH?rs=1&pid=ImgDetMain&o=7&rm=3"
+    ],
+    "Tom_Cruise": [
+        "https://image.tmdb.org/t/p/original/8qBylBsQf4llkGrWR3qAsOtOU8O.jpg",
+        "https://m.media-amazon.com/images/M/MV5BMmU1YWU1NmMtMjAyMi00MjFiLWFmZmUtOTc1ZjI5ODkxYmQyXkEyXkFqcGc@._V1_FMjpg_UX1000_.jpg"
+    ],
+    "Leonardo_DiCaprio": [
+        "https://image.tmdb.org/t/p/original/aLUFp0zWpLVyIOgY0scIpuuKZLE.jpg",
+        "https://wallpapers.com/images/hd/leonardo-dicaprio-actor-nl2l96xppg1rj9hz.jpg"
+    ],
+    "Brad_Pitt": [
+        "https://fr.web.img2.acsta.net/pictures/20/02/10/10/37/1374948.jpg",
+        "https://www.gratistodo.com/wp-content/uploads/2016/09/Brad-Pitt-7.jpg"
+    ],
+    "Chris Hemsworth": [
+        "https://cdn.britannica.com/92/215392-050-96A4BC1D/Australian-actor-Chris-Hemsworth-2019.jpg",
+        "https://static1.cbrimages.com/wordpress/wp-content/uploads/2023/06/chris-hemsworth-thor-love-and-thunder-mcu.jpg"
+    ]
+}
+
+success = 0
+fail = 0
+
+for actor_name, urls in actor_images.items():
+    for i, url in enumerate(urls):
+        try:
+            response = requests.get(url, timeout=15)
+            if response.status_code == 200:
+                path = f"/content/actor_db/{actor_name}/{i}.jpg"
+                with open(path, 'wb') as f:
+                    f.write(response.content)
+                print(f"✅ {actor_name} — photo {i+1} downloaded")
+                success += 1
+            else:
+                print(f"❌ {actor_name} — photo {i+1} failed ({response.status_code})")
+                fail += 1
+        except Exception as e:
+            print(f"❌ {actor_name} — photo {i+1} error: {e}")
+            fail += 1
+
+print(f"\n✅ Success: {success} | ❌ Failed: {fail}")
+
+# Verify karo
+print("\n📁 Database Status:")
+for actor in os.listdir("/content/actor_db"):
+    photos = os.listdir(f"/content/actor_db/{actor}")
+    print(f"  {actor}: {len(photos)} photos")
+
+!pip install deepface -q
+!pip install tf-keras -q
+print("✅ DeepFace installed!")
+
+# Test Karo
+
+from deepface import DeepFace
+import cv2
+import numpy as np
+
+# Test — ek image pe try karo
+test_img = "/content/actor_db/Robert_Downey_Jr/0.jpg"
+
+result = DeepFace.analyze(
+    img_path=test_img,
+    actions=['age', 'gender'],
+    enforce_detection=False
+)
+print("✅ DeepFace working!")
+print(f"Age: {result[0]['age']}")
+print(f"Gender: {result[0]['dominant_gender']}")
+
+# Step 1 — Sahi versions install karo
+!pip install tf-keras==2.19.0 -q
+!pip install keras==2.19.0 -q
+print("✅ Done!")
+
+import keras
+import tensorflow as tf
+
+def dice_coefficient(y_true, y_pred):
+    y_true_f = tf.cast(tf.reshape(y_true,[-1]),tf.float32)
+    y_pred_f = tf.cast(tf.reshape(y_pred,[-1]),tf.float32)
+    i = tf.reduce_sum(y_true_f*y_pred_f)
+    return (2.*i+1.)/(tf.reduce_sum(y_true_f)+tf.reduce_sum(y_pred_f)+1.)
+
+def combined_loss(y_true, y_pred):
+    return 1-dice_coefficient(y_true,y_pred)+tf.keras.losses.binary_crossentropy(y_true,y_pred)
+
+# Pehle load karo
+model = keras.models.load_model(
+    "/content/best_face_model.keras",
+    custom_objects={
+        'dice_coefficient': dice_coefficient,
+        'combined_loss': combined_loss
+    }
+)
+
+# Weights alag save karo
+model.save_weights("/content/model_weights.weights.h5")
+print("✅ Weights saved!")
+
+# Commented out IPython magic to ensure Python compatibility.
+# %%writefile /content/app.py
+# import os
+# os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
+# os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+# 
+# import streamlit as st
+# import numpy as np
+# import cv2
+# from PIL import Image
+# import tensorflow as tf
+# import time
+# import io
+# 
+# st.set_page_config(page_title="Scene Cast AI", page_icon="🎬", layout="wide")
+# 
+# st.markdown("""<style>
+# @import url('https://fonts.googleapis.com/css2?family=Syne:wght@700;800&family=DM+Sans:wght@300;400&display=swap');
+# :root{--bg:#0a0a0f;--card:#16161f;--gold:#f5c518;--blue:#4cc9f0;--text:#f0f0f5;--muted:#7a7a8c;--border:rgba(245,197,24,0.15);}
+# html,body,[class*="css"]{font-family:'DM Sans',sans-serif;background:var(--bg);color:var(--text);}
+# .stApp{background:var(--bg);}
+# #MainMenu,footer,header{visibility:hidden;}
+# [data-testid="stSidebar"]{background:#111118;border-right:1px solid var(--border);}
+# .hero-title{font-family:'Syne',sans-serif;font-size:3rem;font-weight:800;background:linear-gradient(135deg,#f5c518,#f0f0f5,#4cc9f0);-webkit-background-clip:text;-webkit-text-fill-color:transparent;margin:0;}
+# .card{background:var(--card);border:1px solid var(--border);border-radius:16px;padding:1.2rem;position:relative;overflow:hidden;}
+# .card::before{content:'';position:absolute;top:0;left:0;right:0;height:2px;background:linear-gradient(90deg,var(--gold),var(--blue));}
+# .label{font-family:'Syne',sans-serif;font-size:0.75rem;font-weight:700;letter-spacing:0.15em;text-transform:uppercase;color:var(--gold);margin-bottom:0.8rem;}
+# .metric-grid{display:grid;grid-template-columns:repeat(4,1fr);gap:1rem;margin:1rem 0;}
+# .metric{background:var(--card);border:1px solid var(--border);border-radius:14px;padding:1rem;text-align:center;}
+# .mval{font-family:'Syne',sans-serif;font-size:1.5rem;font-weight:800;color:var(--gold);}
+# .mval.warn{color:#fb923c;}.mval.fast{color:var(--blue);}
+# .mlbl{color:var(--muted);font-size:0.75rem;text-transform:uppercase;}
+# .mtgt{font-size:0.65rem;color:var(--muted);margin-top:0.2rem;}
+# .info{background:rgba(245,197,24,0.08);border-left:3px solid var(--gold);padding:0.8rem;border-radius:0 8px 8px 0;font-size:0.83rem;color:var(--muted);margin-top:0.8rem;}
+# .sec{display:flex;align-items:center;gap:0.8rem;margin:1.5rem 0 1rem;}
+# .sec-line{flex:1;height:1px;background:var(--border);}
+# .sec-title{font-family:'Syne',sans-serif;font-size:0.75rem;font-weight:700;letter-spacing:0.2em;text-transform:uppercase;color:var(--muted);}
+# .actor-card{background:var(--card);border:1px solid rgba(245,197,24,0.3);border-radius:16px;padding:1rem;text-align:center;}
+# .actor-name{font-family:'Syne',sans-serif;font-size:1rem;font-weight:800;color:var(--gold);margin:0.5rem 0 0.2rem;}
+# .stDownloadButton>button{background:linear-gradient(135deg,rgba(245,197,24,0.15),rgba(76,201,240,0.1))!important;border:1px solid rgba(245,197,24,0.4)!important;color:var(--gold)!important;font-family:'Syne',sans-serif!important;font-weight:700!important;border-radius:10px!important;width:100%!important;}
+# </style>""", unsafe_allow_html=True)
+# 
+# # ── Model Architecture Rebuild + Weights Load ──
+# from tensorflow.keras.applications import MobileNetV2
+# from tensorflow.keras.layers import Input, Conv2D, UpSampling2D, Concatenate, BatchNormalization, Activation, Dropout
+# from tensorflow.keras.models import Model
+# 
+# def dice_coefficient(y_true, y_pred):
+#     y_true_f = tf.cast(tf.reshape(y_true,[-1]),tf.float32)
+#     y_pred_f = tf.cast(tf.reshape(y_pred,[-1]),tf.float32)
+#     i = tf.reduce_sum(y_true_f*y_pred_f)
+#     return (2.*i+1.)/(tf.reduce_sum(y_true_f)+tf.reduce_sum(y_pred_f)+1.)
+# 
+# def combined_loss(y_true, y_pred):
+#     return 1-dice_coefficient(y_true,y_pred)+tf.keras.losses.binary_crossentropy(y_true,y_pred)
+# 
+# def build_unet(input_shape=(256,256,3)):
+#     inputs = Input(input_shape)
+#     base = MobileNetV2(input_tensor=inputs, weights=None, include_top=False)
+#     base.trainable = False
+#     s1=inputs
+#     s2=base.get_layer("block_1_expand_relu").output
+#     s3=base.get_layer("block_3_expand_relu").output
+#     s4=base.get_layer("block_6_expand_relu").output
+#     bridge=base.get_layer("block_13_expand_relu").output
+#     u1=UpSampling2D((2,2))(bridge)
+#     u1=Concatenate()([u1,s4])
+#     u1=Conv2D(256,3,padding="same",kernel_initializer="he_normal")(u1)
+#     u1=BatchNormalization()(u1); u1=Activation("relu")(u1); u1=Dropout(0.3)(u1)
+#     u2=UpSampling2D((2,2))(u1)
+#     u2=Concatenate()([u2,s3])
+#     u2=Conv2D(128,3,padding="same",kernel_initializer="he_normal")(u2)
+#     u2=BatchNormalization()(u2); u2=Activation("relu")(u2); u2=Dropout(0.3)(u2)
+#     u3=UpSampling2D((2,2))(u2)
+#     u3=Concatenate()([u3,s2])
+#     u3=Conv2D(64,3,padding="same",kernel_initializer="he_normal")(u3)
+#     u3=BatchNormalization()(u3); u3=Activation("relu")(u3); u3=Dropout(0.2)(u3)
+#     u4=UpSampling2D((2,2))(u3)
+#     u4=Concatenate()([u4,s1])
+#     u4=Conv2D(32,3,padding="same",kernel_initializer="he_normal")(u4)
+#     u4=BatchNormalization()(u4); u4=Activation("relu")(u4)
+#     outputs=Conv2D(1,1,activation="sigmoid")(u4)
+#     return Model(inputs,outputs)
+# 
+# @st.cache_resource(show_spinner=False)
+# def load_model():
+#     with tf.device('/CPU:0'):
+#         m = build_unet()
+#         m.load_weights("/content/model_weights.weights.h5", by_name=True, skip_mismatch=True)
+#         m.compile(
+#             optimizer=tf.keras.optimizers.Adam(1e-4),
+#             loss=combined_loss,
+#             metrics=[dice_coefficient]
+#         )
+#     return m
+# 
+# def create_overlay(image, mask):
+#     img=cv2.resize(np.array(image),(256,256))
+#     cm=np.zeros_like(img); cm[mask>127]=[245,197,24]
+#     ov=cv2.addWeighted(img,0.55,cm,0.45,0)
+#     ctrs,_=cv2.findContours(mask,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
+#     cv2.drawContours(ov,ctrs,-1,(245,197,24),2)
+#     return ov
+# 
+# def face_count(mask):
+#     ctrs,_=cv2.findContours(mask,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
+#     return len([c for c in ctrs if cv2.contourArea(c)>256*256*0.005])
+# 
+# def img_bytes(arr):
+#     buf=io.BytesIO(); Image.fromarray(arr).save(buf,format="PNG"); return buf.getvalue()
+# 
+# def get_face_crops(image,mask):
+#     img=cv2.resize(np.array(image),(256,256))
+#     ctrs,_=cv2.findContours(mask,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
+#     crops=[]
+#     for c in ctrs:
+#         if cv2.contourArea(c)>256*256*0.005:
+#             x,y,w,h=cv2.boundingRect(c)
+#             crop=img[max(0,y-10):min(255,y+h+10),max(0,x-10):min(255,x+w+10)]
+#             if crop.size>0: crops.append(crop)
+#     return crops
+# 
+# def identify_actors(crops):
+#     results=[]; db="/content/actor_db"
+#     if not os.path.exists(db): return results
+#     has_photos=any(len(os.listdir(f"{db}/{a}"))>0 for a in os.listdir(db) if os.path.isdir(f"{db}/{a}"))
+#     if not has_photos: return results
+#     try:
+#         from deepface import DeepFace
+#         for crop in crops:
+#             try:
+#                 dfs=DeepFace.find(img_path=crop,db_path=db,model_name="VGG-Face",enforce_detection=False,silent=True)
+#                 if len(dfs)>0 and len(dfs[0])>0:
+#                     best=dfs[0].iloc[0]
+#                     name=best['identity'].split('/')[-2].replace('_',' ')
+#                     dist=best.get('distance',1)
+#                     conf=max(0,(1-dist)*100)
+#                     results.append({"name":name,"confidence":conf})
+#                 else:
+#                     results.append({"name":"Unknown Actor","confidence":0})
+#             except:
+#                 results.append({"name":"Unknown Actor","confidence":0})
+#     except ImportError:
+#         pass
+#     return results
+# 
+# with st.sidebar:
+#     st.markdown("""<div style="text-align:center;padding:1rem 0 1.5rem;">
+#         <div style="font-size:2.5rem;">🎬</div>
+#         <div style="font-family:'Syne',sans-serif;font-weight:800;color:#f5c518;">Scene Cast AI</div>
+#         <div style="font-size:0.75rem;color:#7a7a8c;">Face Segmentation Engine</div>
+#     </div>""",unsafe_allow_html=True)
+#     st.markdown("**⚙️ SETTINGS**")
+#     threshold=st.slider("Confidence Threshold",0.1,0.9,0.5,0.05)
+#     show_ov=st.checkbox("Face Overlay",value=True)
+#     show_mask=st.checkbox("Binary Mask",value=True)
+#     show_conf=st.checkbox("Confidence Map",value=False)
+#     show_actor=st.checkbox("🎭 Actor Recognition",value=True)
+#     st.markdown("---")
+#     st.markdown("""**📊 MODEL INFO**
+# <div style="font-size:0.8rem;color:#7a7a8c;line-height:1.9;">
+# 🏗️ <b style="color:#f0f0f5;">Architecture:</b> U-Net<br>
+# 🔧 <b style="color:#f0f0f5;">Encoder:</b> MobileNetV2<br>
+# 📦 <b style="color:#f0f0f5;">Input:</b> 256×256<br>
+# 📈 <b style="color:#f0f0f5;">Val Dice:</b> 0.8742
+# </div>""",unsafe_allow_html=True)
+# 
+# st.markdown("""<div style="text-align:center;padding:2rem 1rem 1.5rem;">
+#     <div style="display:inline-block;background:rgba(245,197,24,0.1);border:1px solid rgba(245,197,24,0.3);color:#f5c518;font-size:0.7rem;letter-spacing:0.2em;text-transform:uppercase;padding:0.3rem 1rem;border-radius:2rem;margin-bottom:1rem;">🎬 Powered by Deep Learning</div>
+#     <h1 class="hero-title">Scene Cast AI</h1>
+#     <p style="color:#7a7a8c;font-size:1rem;max-width:480px;margin:0.5rem auto;">Real-time face segmentation + actor identification.</p>
+#     <div style="width:60px;height:2px;background:linear-gradient(90deg,#f5c518,#4cc9f0);margin:1.2rem auto 0;border-radius:2px;"></div>
+# </div>""",unsafe_allow_html=True)
+# 
+# with st.spinner("🔄 Loading AI Model..."):
+#     try:
+#         model=load_model()
+#         st.success("✅ Model loaded!", icon="🤖")
+#     except Exception as e:
+#         st.error(f"❌ Error: {e}")
+#         st.stop()
+# 
+# st.markdown('<div class="sec"><div class="sec-line"></div><div class="sec-title">📁 Upload Movie Scene</div><div class="sec-line"></div></div>',unsafe_allow_html=True)
+# f=st.file_uploader("Upload",type=["jpg","jpeg","png","webp"],label_visibility="collapsed")
+# 
+# if f:
+#     # 🔥 FIX: Streamlit upload → OpenCV decode
+#     file_bytes = np.asarray(bytearray(f.read()), dtype=np.uint8)
+#     img = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
+# 
+#     if img is None:
+#         st.error("❌ Image read nahi ho pa rahi. Dusri image try karo.")
+#         st.stop()
+# 
+#     img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+#     image = Image.fromarray(img)
+# 
+#     # 👇 same code as before
+#     ir = cv2.resize(np.array(image),(256,256))/255.0
+#     ii = np.expand_dims(ir,0).astype(np.float32)
+# 
+#     with st.spinner("🧠 Analyzing..."):
+#         with tf.device('/CPU:0'):
+#             t0 = time.time()
+#             pred = model.predict(ii,verbose=0)[0]
+#             spd = (time.time()-t0)*1000
+# 
+#     mask = (pred.squeeze()>threshold).astype(np.uint8)*255
+#     fc = face_count(mask)
+#     cov = (np.sum(mask>0)/(256*256))*100
+# 
+#     st.markdown('<div class="sec"><div class="sec-line"></div><div class="sec-title">🎯 Detection Results</div><div class="sec-line"></div></div>',unsafe_allow_html=True)
+# 
+#     ncols = 1+show_ov+show_mask+show_conf
+#     dcols = st.columns(ncols)
+#     with dcols[0]:
+#         st.markdown('<div class="card"><div class="label">🎬 Original Frame</div>',unsafe_allow_html=True)
+#         st.image(image,use_container_width=True)
+#         st.markdown(f'<div class="info">📐 {image.width}×{image.height}px | 👥 ~{fc} face(s)</div></div>',unsafe_allow_html=True)
+#     idx=1
+#     if show_ov:
+#         ov=create_overlay(image,mask)
+#         with dcols[idx]:
+#             st.markdown('<div class="card"><div class="label">✨ Face Overlay</div>',unsafe_allow_html=True)
+#             st.image(ov,use_container_width=True)
+#             st.markdown(f'<div class="info">🟡 Gold=face | {cov:.1f}%</div></div>',unsafe_allow_html=True)
+#         idx+=1
+#     if show_mask:
+#         with dcols[idx]:
+#             st.markdown('<div class="card"><div class="label">🔲 Binary Mask</div>',unsafe_allow_html=True)
+#             st.image(mask,use_container_width=True)
+#             st.markdown(f'<div class="info">⬜ White=face | {threshold:.2f}</div></div>',unsafe_allow_html=True)
+#         idx+=1
+#     if show_conf:
+#         cm=cv2.applyColorMap((pred.squeeze()*255).astype(np.uint8),cv2.COLORMAP_INFERNO)
+#         cm=cv2.cvtColor(cm,cv2.COLOR_BGR2RGB)
+#         with dcols[idx]:
+#             st.markdown('<div class="card"><div class="label">🌡️ Confidence</div>',unsafe_allow_html=True)
+#             st.image(cm,use_container_width=True)
+#             st.markdown('<div class="info">🔴 Hot=face</div></div>',unsafe_allow_html=True)
+#     if show_actor:
+#         st.markdown('<div class="sec"><div class="sec-line"></div><div class="sec-title">🎭 Actor Recognition</div><div class="sec-line"></div></div>',unsafe_allow_html=True)
+#         with st.spinner("🔍 Identifying..."):
+#             crops=get_face_crops(image,mask); actors=identify_actors(crops)
+#         if actors:
+#             acols=st.columns(min(len(actors),4))
+#             for i,a in enumerate(actors):
+#                 cc="#4ade80" if a['confidence']>60 else "#fb923c"
+#                 with acols[i%4]:
+#                     st.markdown(f"""<div class="actor-card"><div style="font-size:2rem;">🎭</div>
+#                         <div class="actor-name">{a['name']}</div>
+#                         <div style="font-size:0.78rem;color:{cc};">Confidence: {a['confidence']:.1f}%</div>
+#                     </div>""",unsafe_allow_html=True)
+#         else:
+#             st.info("🔍 Actor DB mein photos upload karo!",icon="ℹ️")
+#     st.markdown('<div class="sec"><div class="sec-line"></div><div class="sec-title">📊 Performance</div><div class="sec-line"></div></div>',unsafe_allow_html=True)
+#     sc="fast" if spd<100 else "warn"
+#     st.markdown(f"""<div class="metric-grid">
+#         <div class="metric"><div style="font-size:1.3rem;">🎯</div><div class="mval warn">0.8845</div><div class="mlbl">Dice</div><div class="mtgt">&gt;0.92</div></div>
+#         <div class="metric"><div style="font-size:1.3rem;">📐</div><div class="mval warn">0.7929</div><div class="mlbl">IoU</div><div class="mtgt">&gt;0.88</div></div>
+#         <div class="metric"><div style="font-size:1.3rem;">⚖️</div><div class="mval warn">0.8849</div><div class="mlbl">F1</div><div class="mtgt">&gt;0.90</div></div>
+#         <div class="metric"><div style="font-size:1.3rem;">⚡</div><div class="mval {sc}">{spd:.0f}ms</div><div class="mlbl">Speed</div><div class="mtgt">&lt;100ms</div></div>
+#     </div>""",unsafe_allow_html=True)
+#     c1,c2,c3=st.columns(3)
+#     for col,icon,val,lbl,clr in [(c1,"👥",str(fc),"Faces","#f5c518"),(c2,"📊",f"{cov:.1f}%","Coverage","#4cc9f0"),(c3,"🎚️",f"{threshold:.2f}","Threshold","#4ade80")]:
+#         with col:
+#             st.markdown(f"""<div class="card" style="text-align:center;padding:1rem;">
+#                 <div style="font-size:2rem;">{icon}</div>
+#                 <div style="font-family:'Syne',sans-serif;font-size:1.8rem;font-weight:800;color:{clr};">{val}</div>
+#                 <div style="color:#7a7a8c;font-size:0.78rem;text-transform:uppercase;">{lbl}</div>
+#             </div>""",unsafe_allow_html=True)
+#     st.markdown('<div class="sec"><div class="sec-line"></div><div class="sec-title">📥 Export</div><div class="sec-line"></div></div>',unsafe_allow_html=True)
+#     d1,d2,d3=st.columns(3)
+#     with d1:
+#         st.download_button("⬇️ Mask",img_bytes(mask),"mask.png","image/png",use_container_width=True)
+#     with d2:
+#         ov2=create_overlay(image,mask)
+#         st.download_button("⬇️ Overlay",img_bytes(ov2),"overlay.png","image/png",use_container_width=True)
+#     with d3:
+#         log=f"File:{f.name}\nFaces:{fc}\nSpeed:{spd:.1f}ms\nDice:0.8845\nIoU:0.7929"
+#         st.download_button("⬇️ Log",log,"log.txt","text/plain",use_container_width=True)
+# else:
+#     st.markdown("""<div style="background:#16161f;border:2px dashed rgba(245,197,24,0.2);border-radius:20px;padding:4rem 2rem;text-align:center;margin:2rem 0;">
+#         <div style="font-size:4rem;">🎬</div>
+#         <div style="font-family:'Syne',sans-serif;font-size:1.4rem;font-weight:700;color:#f0f0f5;margin:0.8rem 0 0.4rem;">Ready to Detect & Identify</div>
+#         <div style="color:#7a7a8c;">Upload movie screenshot → AI detects + identifies actors!</div>
+#     </div>""",unsafe_allow_html=True)
+
+!sed -i 's/use_container_width=True/use_column_width=True/g' /content/app.py
+
+# Yeh cell chalao — warning fix hogi
+!sed -i 's/use_column_width=True/use_container_width=True/g' /content/app.py
+print("✅ Fixed!")
+
+!pip install streamlit pyngrok -q
+
+# Ek Cell Mein Sab
+!fuser -k 8501/tcp
+!pkill -f streamlit
+
+import time
+time.sleep(2)
+
+import subprocess, threading
+
+def run():
+    subprocess.Popen([
+        'streamlit', 'run', '/content/app.py',
+        '--server.port=8501',
+        '--server.headless=true',
+        '--server.enableCORS=false',
+        '--server.enableXsrfProtection=false'
+    ])
+
+threading.Thread(target=run).start()
+time.sleep(15)
+
+from google.colab.output import eval_js
+url = eval_js("google.colab.kernel.proxyPort(8501)")
+print(f"✅ URL: {url}")

requirements.txt

@@ -1,3 +1,8 @@
-altair
-pandas
-streamlit
+streamlit 
+pandas
+numpy
+matplotlib
+seaborn
+scikit-learn
+tensorflow
+keras