application file

README.md

@@ -1,7 +1,7 @@
 ---
 title: FaceDetection
-emoji: 🦀
-colorFrom: gray
+emoji: 🎭
+colorFrom: blue
 colorTo: purple
 sdk: gradio
 sdk_version: 5.49.1
@@ -10,4 +10,4 @@ pinned: false
 short_description: An AI application for automatic face detection from video fi
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+

app.py

@@ -0,0 +1,760 @@
+import os
+import cv2
+import gradio as gr
+import numpy as np
+from datetime import datetime
+from scrfd import SCRFD
+from arcface_onnx import ArcFaceONNX
+from sklearn.metrics.pairwise import cosine_similarity
+from sklearn.cluster import DBSCAN
+import time
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+import logging
+from typing import List, Tuple, Optional, Dict
+import json
+from pathlib import Path
+import shutil
+import requests
+import tempfile
+from urllib.parse import urlparse
+import logging
+
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+try:
+    import yt_dlp
+    YOUTUBE_SUPPORT = True
+except ImportError:
+    YOUTUBE_SUPPORT = False
+    logger.warning("Youtube desteği yüklü değil.")
+
+@dataclass
+class FaceDetectionConfig:    
+    frame_skip: int = 30  
+    face_size_threshold: int = 1000  
+    clustering_eps: float = 0.5
+    min_samples: int = 2
+    resize_factor: float = 0.5  
+    chunk_size: int = 500  
+    max_workers: int = 2  
+    use_gpu: bool = False  
+
+class FaceDetector:
+    def __init__(self, config: FaceDetectionConfig):
+        self.config = config
+        self.models = None
+        self.progress_callback = None
+        self.temp_files = []
+        
+    def set_progress_callback(self, callback):
+        self.progress_callback = callback
+    
+    def is_youtube_url(self, url: str) -> bool:
+        
+        youtube_domains = ['youtube.com', 'youtu.be', 'youtube-nocookie.com']
+        parsed = urlparse(url)
+        return any(domain in parsed.netloc for domain in youtube_domains)
+    
+    def download_youtube_video(self, url: str) -> str:
+        
+        if not YOUTUBE_SUPPORT:
+            raise ValueError("YouTube desteği için paket kurulmalı")
+        
+        try:
+            if self.progress_callback:
+                self.progress_callback(0, "YouTube videosu indiriliyor...")
+            
+            
+            temp_dir = tempfile.gettempdir()
+            temp_filename = f"yt_{int(time.time())}_{np.random.randint(1000, 9999)}"
+            temp_path_without_ext = os.path.join(temp_dir, temp_filename)
+                       
+            ydl_opts = {
+                'format': 'best[ext=mp4][height<=720]/best[height<=720]/best',  
+                'outtmpl': temp_path_without_ext + '.%(ext)s',  
+                'quiet': True,
+                'no_warnings': True,
+                'socket_timeout': 60,
+                'retries': 3,
+                'fragment_retries': 3,
+                'keepvideo': True,
+                'merge_output_format': 'mp4',
+                'postprocessors': [{
+                    'key': 'FFmpegVideoConvertor',
+                    'preferedformat': 'mp4',
+                }],
+                'progress_hooks': [self._youtube_progress_hook],
+            }
+            
+            logger.info(f"YouTube videosu indiriliyor: {url}")
+            logger.info(f"Hedef dosya: {temp_path_without_ext}.mp4")
+            
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                info = ydl.extract_info(url, download=True)
+                video_title = info.get('title', 'video')
+                video_ext = info.get('ext', 'mp4')
+                logger.info(f"YouTube video başlığı: {video_title}")
+            
+           
+            final_path = temp_path_without_ext + '.mp4'
+            
+            
+            if not os.path.exists(final_path):
+                for ext in ['.mp4', '.webm', '.mkv']:
+                    alt_path = temp_path_without_ext + ext
+                    if os.path.exists(alt_path):
+                        final_path = alt_path
+                        logger.info(f"Video bulundu: {final_path}")
+                        break
+            
+            if not os.path.exists(final_path):               
+                possible_files = [f for f in os.listdir(temp_dir) if f.startswith(temp_filename)]
+                if possible_files:
+                    final_path = os.path.join(temp_dir, possible_files[0])
+                    logger.info(f"Alternatif dosya bulundu: {final_path}")
+                else:
+                    raise ValueError(f"YouTube videosu indirilemedi! Beklenen: {final_path}")
+            
+            
+            file_size = os.path.getsize(final_path)
+            if file_size == 0:
+                raise ValueError("İndirilen YouTube videosu boş!")
+            
+            self.temp_files.append(final_path)
+            
+            logger.info(f"YouTube videosu başarıyla indirildi: {final_path} ({file_size / 1024 / 1024:.1f}MB)")
+            
+            if self.progress_callback:
+                self.progress_callback(20, f"YouTube videosu indirildi ({file_size / 1024 / 1024:.1f}MB)")
+            
+            return final_path
+            
+        except Exception as e:
+            logger.error(f"YouTube indirme hatası: {e}", exc_info=True)
+            raise ValueError(f"YouTube videosu indirilemedi: {str(e)}")
+    
+    def _youtube_progress_hook(self, d):
+       
+        if d['status'] == 'downloading':
+            if 'total_bytes' in d:
+                progress = (d['downloaded_bytes'] / d['total_bytes']) * 20
+                if self.progress_callback:
+                    self.progress_callback(
+                        progress,
+                        f"YouTube indiriliyor: {d['downloaded_bytes'] / 1024 / 1024:.1f}MB / {d['total_bytes'] / 1024 / 1024:.1f}MB"
+                    )
+        elif d['status'] == 'finished':
+            if self.progress_callback:
+                self.progress_callback(18, "YouTube videosu işleniyor...")
+    
+    def download_video_from_url(self, url: str) -> str:
+        
+        if self.is_youtube_url(url):
+            return self.download_youtube_video(url)
+        
+       
+        temp_path = None
+        try:
+            if self.progress_callback:
+                self.progress_callback(0, "Video indiriliyor...")
+            
+            parsed = urlparse(url)
+            if not parsed.scheme in ['http', 'https']:
+                raise ValueError("Geçersiz URL! HTTP veya HTTPS protokolü kullanın.")
+            
+            # Dosya uzantısını belirle
+            ext = os.path.splitext(parsed.path)[1]
+            if not ext or ext not in ['.mp4', '.avi', '.mov', '.mkv', '.webm']:
+                ext = '.mp4'
+            
+            # Geçici dosya oluştur
+            temp_fd, temp_path = tempfile.mkstemp(suffix=ext, prefix='video_')
+            os.close(temp_fd)  # File descriptor'ı kapat
+            self.temp_files.append(temp_path)
+            
+            logger.info(f"Geçici dosya oluşturuldu: {temp_path}")
+            
+            # URL'den indir
+            response = requests.get(url, stream=True, timeout=60, 
+                                   headers={'User-Agent': 'Mozilla/5.0'})
+            response.raise_for_status()
+            
+            total_size = int(response.headers.get('content-length', 0))
+            downloaded = 0
+            
+           
+            with open(temp_path, 'wb') as f:
+                for chunk in response.iter_content(chunk_size=65536):  # 64KB chunks
+                    if chunk:
+                        f.write(chunk)
+                        downloaded += len(chunk)
+                        if total_size > 0 and self.progress_callback:
+                            progress = (downloaded / total_size) * 20
+                            if downloaded % (1024 * 1024) < 65536:  # Her 1MB'de güncelle
+                                self.progress_callback(
+                                    progress, 
+                                    f"İndiriliyor: {downloaded / 1024 / 1024:.1f}MB / {total_size / 1024 / 1024:.1f}MB"
+                                )
+            
+            
+            if not os.path.exists(temp_path):
+                raise ValueError("Video dosyası oluşturulamadı!")
+            
+            file_size = os.path.getsize(temp_path)
+            if file_size == 0:
+                raise ValueError("İndirilen video dosyası boş!")
+            
+            logger.info(f"Video başarıyla indirildi: {temp_path} ({file_size / 1024 / 1024:.1f}MB)")
+            
+            if self.progress_callback:
+                self.progress_callback(20, f"Video indirildi ({file_size / 1024 / 1024:.1f}MB), işleme başlanıyor...")
+            
+            return temp_path
+            
+        except requests.exceptions.Timeout:
+            if temp_path and os.path.exists(temp_path):
+                os.unlink(temp_path)
+            raise ValueError("Video indirme zaman aşımına uğradı. Lütfen tekrar deneyin.")
+        except requests.exceptions.RequestException as e:
+            if temp_path and os.path.exists(temp_path):
+                os.unlink(temp_path)
+            raise ValueError(f"Video indirme hatası: {str(e)}")
+        except Exception as e:
+            if temp_path and os.path.exists(temp_path):
+                os.unlink(temp_path)
+            raise ValueError(f"Beklenmeyen hata: {str(e)}")
+    
+    def cleanup_temp_files(self):
+        for temp_file in self.temp_files:
+            try:
+                if os.path.exists(temp_file):
+                    os.unlink(temp_file)
+                    logger.info(f"Geçici dosya silindi: {temp_file}")
+            except Exception as e:
+                logger.warning(f"Geçici dosya silinemedi {temp_file}: {e}")
+        self.temp_files = []
+        
+    
+    def _load_models(self) -> Tuple[SCRFD, ArcFaceONNX]:
+        try:
+            logger.info("Modeller yükleniyor (CPU mode)...")
+            current_dir = os.path.dirname(os.path.abspath(__file__))
+            models_dir = os.path.join(current_dir, 'deploy', 'models')
+
+            import onnxruntime as ort
+            sess_options = ort.SessionOptions()
+            ort.set_default_logger_severity(3)
+            sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+            sess_options.intra_op_num_threads = 2  
+            
+            # Sadece CPU provider
+            providers = ['CPUExecutionProvider']
+
+            det_model = os.path.join(models_dir, 'det_10g.onnx')
+            arc_model = os.path.join(models_dir, 'w600k_r50.onnx')
+
+            if not os.path.exists(det_model) or not os.path.exists(arc_model):
+                raise FileNotFoundError(f"Model dosyaları bulunamadı: {models_dir}")
+
+            detector = SCRFD(det_model)
+            detector.session = ort.InferenceSession(det_model, sess_options, providers=providers)
+            
+            recognizer = ArcFaceONNX(arc_model)
+            recognizer.session = ort.InferenceSession(arc_model, sess_options, providers=providers)
+
+            logger.info(f"✅ CPU mode aktif: {recognizer.session.get_providers()}")
+            return detector, recognizer
+        except Exception as e:
+            logger.error(f"Model yükleme hatası: {e}")
+            raise
+
+
+    def create_output_directory(self, video_path: str, is_temp: bool = False) -> str:
+        logger.info(f"burası {self},{video_path},{is_temp}")
+        """Çıktı dizinini oluşturur - Gradio uyumlu"""
+        if is_temp:
+            # URL/YouTube için temp dizini kullan
+            temp_dir = tempfile.gettempdir()            
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            output_dir = os.path.join(temp_dir, f"face_detection_{timestamp}")
+        else:
+            # Yerel dosya için aynı dizini kullan
+            base_dir = os.path.dirname(video_path)
+            video_name = os.path.splitext(os.path.basename(video_path))[0]
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            output_dir = os.path.join(base_dir, f"{video_name}_{timestamp}")
+        
+        os.makedirs(output_dir, exist_ok=True)
+        logger.info(f"Output dizini oluşturuldu: {output_dir}")
+        return output_dir
+
+    def extract_embeddings(self, face_img: np.ndarray) -> Tuple[Optional[np.ndarray], Optional[np.ndarray]]:
+        try:
+            detector, recognizer = self.models
+            bboxes, kpss = detector.autodetect(face_img, max_num=1)
+            if len(bboxes) == 0:
+                return None, None
+            kps = kpss[0]
+            embedding = recognizer.get(face_img, kps)
+            return embedding, kps
+        except Exception as e:
+            logger.error(f"Embedding çıkarma hatası: {e}")
+            return None, None
+
+    def calculate_face_quality(self, face_img: np.ndarray, face_size: float, kps: np.ndarray) -> float:
+        quality_score = 0
+        size_score = min(face_size / 5000, 2.0)
+        quality_score += size_score
+        left_eye, right_eye = kps[0], kps[1]
+        eye_distance = np.linalg.norm(left_eye - right_eye)
+        face_width = np.sqrt(face_size)
+        eye_ratio = eye_distance / face_width
+        angle_score = min(eye_ratio * 3, 2.0)
+        quality_score += angle_score
+        gray = cv2.cvtColor(face_img, cv2.COLOR_BGR2GRAY)
+        blur_var = cv2.Laplacian(gray, cv2.CV_64F).var()
+        blur_score = min(blur_var / 500, 2.0)
+        quality_score += blur_score
+        left_mouth, right_mouth = kps[3], kps[4]
+        mouth_distance = np.linalg.norm(left_mouth - right_mouth)
+        mouth_ratio = mouth_distance / face_width
+        symmetry_score = min(mouth_ratio * 3, 2.0)
+        quality_score += symmetry_score
+        return quality_score
+
+    def process_frame(self, frame: np.ndarray) -> List[Dict]:
+        frame = cv2.resize(frame, (0, 0), fx=self.config.resize_factor, fy=self.config.resize_factor)
+        detector, _ = self.models
+        faces_data = []
+        
+        try:
+            bboxes, _ = detector.autodetect(frame)
+            for x1, y1, x2, y2, _ in bboxes:
+                face_size = (x2 - x1) * (y2 - y1)
+                if face_size < self.config.face_size_threshold:
+                    continue
+
+                face_img = frame[int(y1):int(y2), int(x1):int(x2)]
+                embedding, kps = self.extract_embeddings(face_img)
+                
+                if embedding is not None and kps is not None:
+                    quality_score = self.calculate_face_quality(face_img, face_size, kps)
+                    faces_data.append({
+                        'embedding': embedding,
+                        'face_img': face_img,
+                        'quality_score': quality_score,
+                        'bbox': [float(x1), float(y1), float(x2), float(y2)]
+                    })
+        except Exception as e:
+            logger.error(f"Frame işleme hatası: {e}")
+            
+        return faces_data
+
+    def process_video_chunk(self, frames: List[np.ndarray]) -> List[Dict]:
+        all_faces = []
+        for frame in frames:
+            faces = self.process_frame(frame)
+            all_faces.extend(faces)
+        return all_faces
+
+    def detect_faces(self, video_path: str, is_url: bool = False):
+        start_time = time.time()
+        original_path = video_path
+        downloaded_path = None
+        
+        try:
+            if is_url:
+                downloaded_path = self.download_video_from_url(video_path)
+                video_path = downloaded_path
+                logger.info(f"URL'den indirilen video kullanılıyor: {video_path}")
+            
+            # Video dosyasının varlığını kontrol et
+            if not os.path.exists(video_path):
+                raise ValueError(f"Video dosyası bulunamadı: {video_path}")
+            
+            file_size = os.path.getsize(video_path)
+            if file_size == 0:
+                raise ValueError(f"Video dosyası boş: {video_path}")
+            
+            logger.info(f"Video dosyası kontrol edildi: {video_path} ({file_size / 1024 / 1024:.1f}MB)")
+            
+            if self.models is None:
+                self.models = self._load_models()
+            
+            output_dir = self.create_output_directory(video_path if not is_url else tempfile.gettempdir(), is_temp=is_url)
+            metadata = {
+                'video_path': original_path,
+                'is_url': is_url,
+                'processing_start': datetime.now().isoformat(),
+                'config': vars(self.config),
+                'faces': []
+            }
+
+            cap = cv2.VideoCapture(video_path)
+            if not cap.isOpened():
+                raise ValueError(f"Video açılamadı: {video_path}. Dosya bozuk veya desteklenmeyen format olabilir.")
+
+            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            fps = int(cap.get(cv2.CAP_PROP_FPS))
+            duration = total_frames / fps if fps > 0 else 0
+            
+            logger.info(f"Video: {total_frames} frame, {fps} FPS, {duration:.1f} saniye")
+            
+            progress_offset = 20 if is_url else 0
+            max_progress = 80 if is_url else 100
+            
+            if self.progress_callback:
+                self.progress_callback(progress_offset, f"Video açıldı: {total_frames} frame")
+
+            current_frames = []
+            all_faces_data = []
+            frame_count = 0
+
+            with ThreadPoolExecutor(max_workers=self.config.max_workers) as executor:
+                while True:
+                    ret, frame = cap.read()
+                    if not ret:
+                        break
+                        
+                    frame_count += 1
+                    if frame_count % self.config.frame_skip == 0:
+                        current_frames.append(frame)
+
+                    if len(current_frames) >= self.config.chunk_size:
+                        future = executor.submit(self.process_video_chunk, current_frames)
+                        all_faces_data.extend(future.result())
+                        current_frames = []
+
+                    if frame_count % 500 == 0:
+                        progress = (frame_count / total_frames) * 100
+                        if self.progress_callback:
+                            adjusted_progress = progress_offset + (progress / 2) * ((max_progress - progress_offset) / 100)
+                            self.progress_callback(
+                                adjusted_progress,
+                                f"Frame işleniyor: {frame_count}/{total_frames} ({progress:.1f}%)"
+                            )
+
+                if current_frames:
+                    future = executor.submit(self.process_video_chunk, current_frames)
+                    all_faces_data.extend(future.result())
+
+            cap.release()
+
+            if not all_faces_data:
+                raise ValueError("Hiç yüz bulunamadı!")
+
+            clustering_progress = progress_offset + (max_progress - progress_offset) * 0.6
+            if self.progress_callback:
+                self.progress_callback(clustering_progress, f"{len(all_faces_data)} yüz tespit edildi, clustering yapılıyor...")
+
+            embeddings_array = np.array([face['embedding'] for face in all_faces_data])
+            clustering = DBSCAN(
+                eps=self.config.clustering_eps,
+                min_samples=self.config.min_samples,
+                metric='cosine'
+            ).fit(embeddings_array)
+
+            labels = clustering.labels_
+            n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
+            
+            saving_progress = progress_offset + (max_progress - progress_offset) * 0.8
+            if self.progress_callback:
+                self.progress_callback(saving_progress, f"{n_clusters} benzersiz kişi tespit edildi, yüzler kaydediliyor...")
+
+            saved_faces = []
+            for cluster_id in range(n_clusters):
+                cluster_indices = np.where(labels == cluster_id)[0]
+                cluster_faces = [all_faces_data[i] for i in cluster_indices]
+                best_face = max(cluster_faces, key=lambda x: x['quality_score'])
+                
+                face_img_resized = cv2.resize(best_face['face_img'], (112, 112))
+                
+                face_file = f"person_{cluster_id}.jpg"
+                face_path = os.path.join(output_dir, face_file)
+                cv2.imwrite(face_path, face_img_resized, [cv2.IMWRITE_JPEG_QUALITY, 95])
+                
+                saved_faces.append(face_path)
+                
+                metadata['faces'].append({
+                    'cluster_id': cluster_id,
+                    'face_file': face_file,
+                    'quality_score': float(best_face['quality_score']),
+                    'bbox': best_face['bbox'],
+                    'cluster_size': len(cluster_indices)
+                })
+
+            elapsed_time = time.time() - start_time
+            metadata['processing_end'] = datetime.now().isoformat()
+            metadata['elapsed_time'] = elapsed_time
+            metadata['total_frames'] = total_frames
+            metadata['fps'] = fps
+            metadata['duration'] = duration
+            metadata['unique_persons'] = n_clusters
+            
+            metadata_path = os.path.join(output_dir, 'metadata.json')
+            with open(metadata_path, 'w', encoding='utf-8') as f:
+                json.dump(metadata, f, indent=2, ensure_ascii=False)
+
+            if self.progress_callback:
+                self.progress_callback(100, f"✅ Tamamlandı! {n_clusters} kişi bulundu ({elapsed_time:.1f}s)")
+
+            return output_dir, saved_faces, metadata
+
+        except Exception as e:
+            logger.error(f"İşlem hatası: {e}")
+            raise
+        finally:
+            if is_url:
+                self.cleanup_temp_files()
+
+detector_instance = None
+
+def initialize_detector(frame_skip, face_threshold, clustering_eps, use_gpu):
+    global detector_instance
+    config = FaceDetectionConfig(
+        frame_skip=frame_skip,
+        face_size_threshold=face_threshold,
+        clustering_eps=clustering_eps,
+        use_gpu=use_gpu
+    )
+    detector_instance = FaceDetector(config)
+    return "✅ Ayarlar kaydedildi!"
+
+def process_video_gradio(video_file, video_url, progress=gr.Progress()):
+    global detector_instance
+    
+    if detector_instance is None:
+        detector_instance = FaceDetector(FaceDetectionConfig())
+    
+    def update_progress(value, message):
+        progress(value / 100, desc=message)
+    
+    detector_instance.set_progress_callback(update_progress)
+    
+    try:
+        progress(0, desc="İşlem başlatılıyor...")
+        
+        if video_url and video_url.strip():
+            video_source = video_url.strip()
+            is_url = True
+            source_name = urlparse(video_url).path.split('/')[-1] or "video"
+            logger.info(f"URL kullanılıyor: {video_url}")
+            
+            # YouTube mu kontrol et
+            if detector_instance.is_youtube_url(video_url):
+                if not YOUTUBE_SUPPORT:
+                    return [], "❌ YouTube desteği için paket kurulmalı", "❌ paket kurulu değil"
+                logger.info("YouTube URL tespit edildi")
+            
+        elif video_file:
+            video_source = video_file
+            is_url = False
+            source_name = os.path.basename(video_file)
+            logger.info(f"Yerel dosya kullanılıyor: {video_file}")
+        else:
+            return [], "❌ Lütfen bir video yükleyin veya URL girin!", "❌ Video bulunamadı"
+        
+        # URL test (YouTube değilse)
+        if is_url and not detector_instance.is_youtube_url(video_source):
+            try:
+                head_response = requests.head(video_source, timeout=10, allow_redirects=True)
+                logger.info(f"URL test - Status: {head_response.status_code}, Content-Type: {head_response.headers.get('content-type', 'unknown')}")
+                if head_response.status_code != 200:
+                    return [], f"❌ URL erişilemez (HTTP {head_response.status_code})", "❌ URL hatası"
+            except Exception as e:
+                logger.warning(f"URL test başarısız: {e}, yine de deneniyor...")
+        
+        # Video süresini kontrol et (detect_faces çağrılmadan önce)
+        if not is_url:
+            cap = cv2.VideoCapture(video_source)
+            if cap.isOpened():
+                total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+                fps = int(cap.get(cv2.CAP_PROP_FPS))
+                duration = total_frames / fps if fps > 0 else 0
+                cap.release()
+                
+                if duration > 300:  # 5 dakika limiti
+                    return [], f"⚠️ Video çok uzun ({duration:.0f} saniye)! CPU modunda maksimum 5 dakika (300 saniye) desteklenir.", "❌ Süre limiti aşıldı"
+        
+        output_dir, saved_faces, metadata = detector_instance.detect_faces(video_source, is_url=is_url)
+        
+        # URL'den indirilen videolar için de süre kontrolü
+        if is_url and metadata['duration'] > 300:
+            return [], f"⚠️ Video çok uzun ({metadata['duration']:.0f} saniye)! CPU modunda maksimum 5 dakika desteklenir.", "❌ Süre limiti aşıldı"
+        
+        report = f"""
+# 📊 İşlem Raporu
+
+## Genel Bilgiler
+- **Video**: {source_name}
+- **Kaynak**: {'🌐 URL' if is_url else '📁 Yerel Dosya'}
+- **Süre**: {metadata['duration']:.1f} saniye
+- **FPS**: {metadata['fps']}
+- **Toplam Frame**: {metadata['total_frames']}
+- **İşlem Süresi**: {metadata['elapsed_time']:.1f} saniye
+
+## Tespit Sonuçları
+- **Benzersiz Kişi**: {metadata['unique_persons']}
+- **Toplam Yüz Tespiti**: {sum(f['cluster_size'] for f in metadata['faces'])}
+
+## Kişi Detayları
+"""
+        for face in metadata['faces']:
+            report += f"\n### Kişi {face['cluster_id']}\n"
+            report += f"- Kalite Skoru: {face['quality_score']:.2f}\n"
+            report += f"- Görülme Sayısı: {face['cluster_size']}\n"
+        
+        return saved_faces, report, f"✅ Başarılı! Çıktı: {output_dir}"
+        
+    except Exception as e:
+        error_msg = f"❌ Hata: {str(e)}"
+        logger.error(error_msg)
+        return [], error_msg, error_msg
+
+def compare_two_faces(face1, face2):
+    global detector_instance
+    
+    if detector_instance is None:
+        detector_instance = FaceDetector(FaceDetectionConfig())
+        detector_instance.models = detector_instance._load_models()
+    
+    try:
+        img1 = cv2.imread(face1) if isinstance(face1, str) else cv2.cvtColor(face1, cv2.COLOR_RGB2BGR)
+        img2 = cv2.imread(face2) if isinstance(face2, str) else cv2.cvtColor(face2, cv2.COLOR_RGB2BGR)
+        
+        emb1, _ = detector_instance.extract_embeddings(img1)
+        emb2, _ = detector_instance.extract_embeddings(img2)
+        
+        if emb1 is None or emb2 is None:
+            return "❌ Yüz tespit edilemedi!"
+        
+        similarity = cosine_similarity([emb1], [emb2])[0][0]
+        percentage = similarity * 100
+        
+        if percentage > 70:
+            result = f"✅ Aynı Kişi ({percentage:.1f}% benzerlik)"
+        elif percentage > 50:
+            result = f"⚠️ Muhtemelen Aynı Kişi ({percentage:.1f}% benzerlik)"
+        else:
+            result = f"❌ Farklı Kişiler ({percentage:.1f}% benzerlik)"
+        
+        return result
+        
+    except Exception as e:
+        return f"❌ Hata: {str(e)}"
+
+with gr.Blocks(title="Yüz Tanıma Sistemi", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🎭 Video Yüz Tanıma Sistemi
+    Video dosyalarından otomatik yüz tespiti ve tanıma yapın
+    ⚠️ **CPU Modunda Çalışıyor**: İşlem süresi uzun olabilir (5 dk video = ~10-15 dk)
+    """)
+    
+    with gr.Tabs():
+        with gr.Tab("📹 Video İşle"):
+            gr.Markdown("### Video kaynağını seçin:")
+            
+            with gr.Row():
+                with gr.Column():
+                    video_input = gr.Video(label="📁 Yerel Video Yükle")
+                    gr.Markdown("**VEYA**")
+                    url_input = gr.Textbox(
+                        label="🌐 Video URL'si",
+                        placeholder="https://example.com/video.mp4",
+                        lines=1
+                    )
+                    gr.Markdown("*URL girilirse öncelikle o kullanılır*")
+                    
+                    process_btn = gr.Button("🚀 İşlemi Başlat", variant="primary", size="lg")
+                    status_text = gr.Textbox(label="Durum", interactive=False)
+                
+                with gr.Column():
+                    gallery_output = gr.Gallery(label="Tespit Edilen Yüzler", columns=4, height=400)
+                    report_output = gr.Markdown(label="Rapor")
+            
+            gr.Markdown("""
+            #### 💡 URL Örnekleri:
+            - **YouTube**: `https://www.youtube.com/watch?v=xxxxx` veya `https://youtu.be/xxxxx` veya Shorts
+            - **Doğrudan video**: `https://example.com/video.mp4`
+            - Google Drive paylaşım linki çalışmaz (direkt indirme linki gerekir)
+            - **Desteklenen formatlar**: MP4, AVI, MOV, MKV, WebM
+            
+            ⚠️ **YouTube için**: İlk kullanımda `pip install yt-dlp` komutu gereklidir
+            """)
+            
+            process_btn.click(
+                fn=process_video_gradio,
+                inputs=[video_input, url_input],
+                outputs=[gallery_output, report_output, status_text]
+            )
+        
+        with gr.Tab("🔍 Yüz Karşılaştır"):
+            gr.Markdown("İki yüz görselini yükleyin ve benzerliklerini kontrol edin")
+            with gr.Row():
+                face1_input = gr.Image(label="Yüz 1", type="filepath")
+                face2_input = gr.Image(label="Yüz 2", type="filepath")
+            
+            compare_btn = gr.Button("⚖️ Karşılaştır", variant="primary")
+            compare_result = gr.Textbox(label="Sonuç", interactive=False)
+            
+            compare_btn.click(
+                fn=compare_two_faces,
+                inputs=[face1_input, face2_input],
+                outputs=compare_result
+            )
+        
+        with gr.Tab("⚙️ Ayarlar"):
+            gr.Markdown("### Gelişmiş Ayarlar")
+            
+            frame_skip_slider = gr.Slider(20, 60, value=30, step=5, 
+                                 label="Frame Atlama (yüksek = daha hızlı)")
+            face_threshold_slider = gr.Slider(600, 2000, value=1000, step=100,
+                                            label="Minimum Yüz Boyutu (piksel)")
+            clustering_slider = gr.Slider(0.3, 0.7, value=0.5, step=0.05,
+                                        label="Clustering Hassasiyeti")
+            
+            
+            save_settings_btn = gr.Button("💾 Ayarları Kaydet")
+            settings_status = gr.Textbox(label="Durum", interactive=False)
+            
+            save_settings_btn.click(
+                fn=initialize_detector,
+                inputs=[frame_skip_slider, face_threshold_slider, clustering_slider],
+                outputs=settings_status
+            )
+    
+    gr.Markdown("""
+    ---
+    ### 💡 İpuçları
+    - **Frame Atlama**: Daha hızlı işlem için artırın, daha fazla tespit için azaltın
+    - **Clustering**: Daha az kişi tespit ediyorsa artırın, fazla tespit ediyorsa azaltın
+    - **GPU**: Cuda destekli GPU varsa aktif edin
+    - **YouTube**: İlk kullanımda terminalde `pip install yt-dlp` çalıştırın
+    """)
+
+if __name__ == "__main__":
+    # YouTube desteği kontrolü
+    print("\n" + "="*60)
+    print("🎬 Video Yüz Tanıma Sistemi")
+    print("="*60)
+    
+    if YOUTUBE_SUPPORT:
+        print("✅ YouTube desteği: AKTİF")
+        try:
+            print(f"   yt-dlp versiyon: {yt_dlp.version.__version__}")
+        except:
+            print("   yt-dlp versiyon bilgisi alınamadı")
+    else:
+        print("⚠️  YouTube desteği: KAPALI")
+        print("   Kurulum için: pip install yt-dlp")
+    
+    print("="*60 + "\n")
+    
+    demo.launch(share=False, server_name="0.0.0.0", server_port=7860)

arcface_onnx.py

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+# @Organization  : insightface.ai
+# @Author        : Jia Guo
+# @Time          : 2021-05-04
+# @Function      : 
+
+import numpy as np
+import cv2
+import onnx
+import onnxruntime
+import face_align
+import os 
+
+__all__ = [
+    'ArcFaceONNX',
+]
+
+
+class ArcFaceONNX:
+    def __init__(self, model_file=None, session=None):
+        assert model_file is not None, "Model dosyası belirtilmedi"
+        self.model_file = model_file
+        self.session = session
+        self.taskname = 'recognition'
+        find_sub = False
+        find_mul = False
+        assert os.path.exists(model_file), f"Model dosyası bulunamadı: {model_file}"  # Model varlığını kontrol et
+        model = onnx.load(self.model_file)
+        graph = model.graph
+        for nid, node in enumerate(graph.node[:8]):
+            #print(nid, node.name)
+            if node.name.startswith('Sub') or node.name.startswith('_minus'):
+                find_sub = True
+            if node.name.startswith('Mul') or node.name.startswith('_mul'):
+                find_mul = True
+        if find_sub and find_mul:
+            #mxnet arcface model
+            input_mean = 0.0
+            input_std = 1.0
+        else:
+            input_mean = 127.5
+            input_std = 127.5
+        self.input_mean = input_mean
+        self.input_std = input_std
+        #print('input mean and std:', self.input_mean, self.input_std)
+        if self.session is None:
+            sess_options = onnxruntime.SessionOptions()
+            sess_options.graph_optimization_level = onnxruntime.GraphOptimizationLevel.ORT_ENABLE_ALL
+            sess_options.intra_op_num_threads = 4
+            self.session = onnxruntime.InferenceSession(
+                self.model_file,
+                sess_options=sess_options,
+                providers=['CUDAExecutionProvider', 'CPUExecutionProvider']
+            )
+        input_cfg = self.session.get_inputs()[0]
+        input_shape = input_cfg.shape
+        input_name = input_cfg.name
+        self.input_size = tuple(input_shape[2:4][::-1])
+        self.input_shape = input_shape
+        outputs = self.session.get_outputs()
+        output_names = []
+        for out in outputs:
+            output_names.append(out.name)
+        self.input_name = input_name
+        self.output_names = output_names
+        assert len(self.output_names)==1
+        self.output_shape = outputs[0].shape
+
+    def prepare(self, ctx_id, **kwargs):
+        if ctx_id<0:
+            self.session.set_providers(['CPUExecutionProvider'])
+
+    def get(self, img, kps):
+        aimg = face_align.norm_crop(img, landmark=kps, image_size=self.input_size[0])
+        embedding = self.get_feat(aimg).flatten()
+        return embedding
+
+    def compute_sim(self, feat1, feat2):
+        from numpy.linalg import norm
+        feat1 = feat1.ravel()
+        feat2 = feat2.ravel()
+
+        # arr_str = ','.join(map(str, feat1))
+        # print(arr_str)
+
+        sim = np.dot(feat1, feat2) / (norm(feat1) * norm(feat2))
+        return sim
+
+    def get_feat(self, imgs):
+        if not isinstance(imgs, list):
+            imgs = [imgs]
+        input_size = self.input_size
+        
+        blob = cv2.dnn.blobFromImages(imgs, 1.0 / self.input_std, input_size,
+                                      (self.input_mean, self.input_mean, self.input_mean), swapRB=True)
+        net_out = self.session.run(self.output_names, {self.input_name: blob})[0]
+        return net_out
+
+    def forward(self, batch_data):
+        blob = (batch_data - self.input_mean) / self.input_std
+        net_out = self.session.run(self.output_names, {self.input_name: blob})[0]
+        return net_out
+
+

models/det_10g.onnx

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

models/w600k_r50.onnx

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

scrfd.py

@@ -0,0 +1,338 @@
+
+
+from __future__ import division
+import datetime
+import numpy as np
+#import onnx
+import onnxruntime
+import os
+import os.path as osp
+import cv2
+import sys
+
+def softmax(z):
+    assert len(z.shape) == 2
+    s = np.max(z, axis=1)
+    s = s[:, np.newaxis] # necessary step to do broadcasting
+    e_x = np.exp(z - s)
+    div = np.sum(e_x, axis=1)
+    div = div[:, np.newaxis] # dito
+    return e_x / div
+
+def distance2bbox(points, distance, max_shape=None):
+    """Decode distance prediction to bounding box.
+
+    Args:
+        points (Tensor): Shape (n, 2), [x, y].
+        distance (Tensor): Distance from the given point to 4
+            boundaries (left, top, right, bottom).
+        max_shape (tuple): Shape of the image.
+
+    Returns:
+        Tensor: Decoded bboxes.
+    """
+    x1 = points[:, 0] - distance[:, 0]
+    y1 = points[:, 1] - distance[:, 1]
+    x2 = points[:, 0] + distance[:, 2]
+    y2 = points[:, 1] + distance[:, 3]
+    if max_shape is not None:
+        x1 = x1.clamp(min=0, max=max_shape[1])
+        y1 = y1.clamp(min=0, max=max_shape[0])
+        x2 = x2.clamp(min=0, max=max_shape[1])
+        y2 = y2.clamp(min=0, max=max_shape[0])
+    return np.stack([x1, y1, x2, y2], axis=-1)
+
+def distance2kps(points, distance, max_shape=None):
+    """Decode distance prediction to bounding box.
+
+    Args:
+        points (Tensor): Shape (n, 2), [x, y].
+        distance (Tensor): Distance from the given point to 4
+            boundaries (left, top, right, bottom).
+        max_shape (tuple): Shape of the image.
+
+    Returns:
+        Tensor: Decoded bboxes.
+    """
+    preds = []
+    for i in range(0, distance.shape[1], 2):
+        px = points[:, i%2] + distance[:, i]
+        py = points[:, i%2+1] + distance[:, i+1]
+        if max_shape is not None:
+            px = px.clamp(min=0, max=max_shape[1])
+            py = py.clamp(min=0, max=max_shape[0])
+        preds.append(px)
+        preds.append(py)
+    return np.stack(preds, axis=-1)
+
+class SCRFD:
+    def __init__(self, model_file=None, session=None):
+        import onnxruntime
+        self.model_file = model_file
+        self.session = session
+        self.taskname = 'detection'
+        self.batched = False
+        if self.session is None:
+            assert self.model_file is not None
+            assert osp.exists(self.model_file), f"Model dosyası bulunamadı: {self.model_file}"  # Hata mesajı ekledim
+            # Session oluşturma kısmını güncelledim
+            sess_options = onnxruntime.SessionOptions()
+            sess_options.graph_optimization_level = onnxruntime.GraphOptimizationLevel.ORT_ENABLE_ALL
+            sess_options.intra_op_num_threads = 4
+            self.session = onnxruntime.InferenceSession(
+                self.model_file,
+                sess_options=sess_options,
+                providers=['CUDAExecutionProvider', 'CPUExecutionProvider']
+            )
+        self.center_cache = {}
+        self.nms_thresh = 0.4
+        self.det_thresh = 0.5
+        self._init_vars()
+
+    def _init_vars(self):
+        input_cfg = self.session.get_inputs()[0]
+        input_shape = input_cfg.shape
+        #print(input_shape)
+        if isinstance(input_shape[2], str):
+            self.input_size = None
+        else:
+            self.input_size = tuple(input_shape[2:4][::-1])
+        #print('image_size:', self.image_size)
+        input_name = input_cfg.name
+        self.input_shape = input_shape
+        outputs = self.session.get_outputs()
+        if len(outputs[0].shape) == 3:
+            self.batched = True
+        output_names = []
+        for o in outputs:
+            output_names.append(o.name)
+        self.input_name = input_name
+        self.output_names = output_names
+        self.input_mean = 127.5
+        self.input_std = 128.0
+        #print(self.output_names)
+        #assert len(outputs)==10 or len(outputs)==15
+        self.use_kps = False
+        self._anchor_ratio = 1.0
+        self._num_anchors = 1
+        if len(outputs)==6:
+            self.fmc = 3
+            self._feat_stride_fpn = [8, 16, 32]
+            self._num_anchors = 2
+        elif len(outputs)==9:
+            self.fmc = 3
+            self._feat_stride_fpn = [8, 16, 32]
+            self._num_anchors = 2
+            self.use_kps = True
+        elif len(outputs)==10:
+            self.fmc = 5
+            self._feat_stride_fpn = [8, 16, 32, 64, 128]
+            self._num_anchors = 1
+        elif len(outputs)==15:
+            self.fmc = 5
+            self._feat_stride_fpn = [8, 16, 32, 64, 128]
+            self._num_anchors = 1
+            self.use_kps = True
+
+    def prepare(self, ctx_id, **kwargs):
+        if ctx_id<0:
+            self.session.set_providers(['CPUExecutionProvider'])
+        nms_thresh = kwargs.get('nms_thresh', None)
+        if nms_thresh is not None:
+            self.nms_thresh = nms_thresh
+        det_thresh = kwargs.get('det_thresh', None)
+        if det_thresh is not None:
+            self.det_thresh = det_thresh
+        input_size = kwargs.get('input_size', None)
+        if input_size is not None:
+            if self.input_size is not None:
+                print('warning: det_size is already set in scrfd model, ignore')
+            else:
+                self.input_size = input_size
+
+    def forward(self, img, threshold):
+        scores_list = []
+        bboxes_list = []
+        kpss_list = []
+        input_size = tuple(img.shape[0:2][::-1])
+        blob = cv2.dnn.blobFromImage(img, 1.0/self.input_std, input_size, (self.input_mean, self.input_mean, self.input_mean), swapRB=True)
+        net_outs = self.session.run(self.output_names, {self.input_name : blob})
+
+        input_height = blob.shape[2]
+        input_width = blob.shape[3]
+        fmc = self.fmc
+        for idx, stride in enumerate(self._feat_stride_fpn):
+            # If model support batch dim, take first output
+            if self.batched:
+                scores = net_outs[idx][0]
+                bbox_preds = net_outs[idx + fmc][0]
+                bbox_preds = bbox_preds * stride
+                if self.use_kps:
+                    kps_preds = net_outs[idx + fmc * 2][0] * stride
+            # If model doesn't support batching take output as is
+            else:
+                scores = net_outs[idx]
+                bbox_preds = net_outs[idx + fmc]
+                bbox_preds = bbox_preds * stride
+                if self.use_kps:
+                    kps_preds = net_outs[idx + fmc * 2] * stride
+
+            height = input_height // stride
+            width = input_width // stride
+            K = height * width
+            key = (height, width, stride)
+            if key in self.center_cache:
+                anchor_centers = self.center_cache[key]
+            else:
+                #solution-1, c style:
+                #anchor_centers = np.zeros( (height, width, 2), dtype=np.float32 )
+                #for i in range(height):
+                #    anchor_centers[i, :, 1] = i
+                #for i in range(width):
+                #    anchor_centers[:, i, 0] = i
+
+                #solution-2:
+                #ax = np.arange(width, dtype=np.float32)
+                #ay = np.arange(height, dtype=np.float32)
+                #xv, yv = np.meshgrid(np.arange(width), np.arange(height))
+                #anchor_centers = np.stack([xv, yv], axis=-1).astype(np.float32)
+
+                #solution-3:
+                anchor_centers = np.stack(np.mgrid[:height, :width][::-1], axis=-1).astype(np.float32)
+                #print(anchor_centers.shape)
+
+                anchor_centers = (anchor_centers * stride).reshape( (-1, 2) )
+                if self._num_anchors>1:
+                    anchor_centers = np.stack([anchor_centers]*self._num_anchors, axis=1).reshape( (-1,2) )
+                if len(self.center_cache)<100:
+                    self.center_cache[key] = anchor_centers
+
+            pos_inds = np.where(scores>=threshold)[0]
+            bboxes = distance2bbox(anchor_centers, bbox_preds)
+            pos_scores = scores[pos_inds]
+            pos_bboxes = bboxes[pos_inds]
+            scores_list.append(pos_scores)
+            bboxes_list.append(pos_bboxes)
+            if self.use_kps:
+                kpss = distance2kps(anchor_centers, kps_preds)
+                #kpss = kps_preds
+                kpss = kpss.reshape( (kpss.shape[0], -1, 2) )
+                pos_kpss = kpss[pos_inds]
+                kpss_list.append(pos_kpss)
+        return scores_list, bboxes_list, kpss_list
+
+    def detect(self, img, input_size = None, thresh=None, max_num=0, metric='default'):
+        assert input_size is not None or self.input_size is not None
+        input_size = self.input_size if input_size is None else input_size
+            
+        im_ratio = float(img.shape[0]) / img.shape[1]
+        model_ratio = float(input_size[1]) / input_size[0]
+        if im_ratio>model_ratio:
+            new_height = input_size[1]
+            new_width = int(new_height / im_ratio)
+        else:
+            new_width = input_size[0]
+            new_height = int(new_width * im_ratio)
+        det_scale = float(new_height) / img.shape[0]
+        resized_img = cv2.resize(img, (new_width, new_height))
+        det_img = np.zeros( (input_size[1], input_size[0], 3), dtype=np.uint8 )
+        det_img[:new_height, :new_width, :] = resized_img
+        det_thresh = thresh if thresh is not None else self.det_thresh
+
+        scores_list, bboxes_list, kpss_list = self.forward(det_img, det_thresh)
+
+        scores = np.vstack(scores_list)
+        scores_ravel = scores.ravel()
+        order = scores_ravel.argsort()[::-1]
+        bboxes = np.vstack(bboxes_list) / det_scale
+        if self.use_kps:
+            kpss = np.vstack(kpss_list) / det_scale
+        pre_det = np.hstack((bboxes, scores)).astype(np.float32, copy=False)
+        pre_det = pre_det[order, :]
+        keep = self.nms(pre_det)
+        det = pre_det[keep, :]
+        if self.use_kps:
+            kpss = kpss[order,:,:]
+            kpss = kpss[keep,:,:]
+        else:
+            kpss = None
+        if max_num > 0 and det.shape[0] > max_num:
+            area = (det[:, 2] - det[:, 0]) * (det[:, 3] -
+                                                    det[:, 1])
+            img_center = img.shape[0] // 2, img.shape[1] // 2
+            offsets = np.vstack([
+                (det[:, 0] + det[:, 2]) / 2 - img_center[1],
+                (det[:, 1] + det[:, 3]) / 2 - img_center[0]
+            ])
+            offset_dist_squared = np.sum(np.power(offsets, 2.0), 0)
+            if metric=='max':
+                values = area
+            else:
+                values = area - offset_dist_squared * 2.0  # some extra weight on the centering
+            bindex = np.argsort(
+                values)[::-1]  # some extra weight on the centering
+            bindex = bindex[0:max_num]
+            det = det[bindex, :]
+            if kpss is not None:
+                kpss = kpss[bindex, :]
+        return det, kpss
+
+    def autodetect(self, img, max_num=0, metric='max'):
+        bboxes, kpss = self.detect(img, input_size=(640, 640), thresh=0.5)
+        bboxes2, kpss2 = self.detect(img, input_size=(128, 128), thresh=0.5)
+        bboxes_all = np.concatenate([bboxes, bboxes2], axis=0)
+        kpss_all = np.concatenate([kpss, kpss2], axis=0)
+        keep = self.nms(bboxes_all)
+        det = bboxes_all[keep,:]
+        kpss = kpss_all[keep,:]
+        if max_num > 0 and det.shape[0] > max_num:
+            area = (det[:, 2] - det[:, 0]) * (det[:, 3] -
+                                                    det[:, 1])
+            img_center = img.shape[0] // 2, img.shape[1] // 2
+            offsets = np.vstack([
+                (det[:, 0] + det[:, 2]) / 2 - img_center[1],
+                (det[:, 1] + det[:, 3]) / 2 - img_center[0]
+            ])
+            offset_dist_squared = np.sum(np.power(offsets, 2.0), 0)
+            if metric=='max':
+                values = area
+            else:
+                values = area - offset_dist_squared * 2.0  # some extra weight on the centering
+            bindex = np.argsort(
+                values)[::-1]  # some extra weight on the centering
+            bindex = bindex[0:max_num]
+            det = det[bindex, :]
+            if kpss is not None:
+                kpss = kpss[bindex, :]
+        return det, kpss
+
+    def nms(self, dets):
+        thresh = self.nms_thresh
+        x1 = dets[:, 0]
+        y1 = dets[:, 1]
+        x2 = dets[:, 2]
+        y2 = dets[:, 3]
+        scores = dets[:, 4]
+
+        areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+        order = scores.argsort()[::-1]
+
+        keep = []
+        while order.size > 0:
+            i = order[0]
+            keep.append(i)
+            xx1 = np.maximum(x1[i], x1[order[1:]])
+            yy1 = np.maximum(y1[i], y1[order[1:]])
+            xx2 = np.minimum(x2[i], x2[order[1:]])
+            yy2 = np.minimum(y2[i], y2[order[1:]])
+
+            w = np.maximum(0.0, xx2 - xx1 + 1)
+            h = np.maximum(0.0, yy2 - yy1 + 1)
+            inter = w * h
+            ovr = inter / (areas[i] + areas[order[1:]] - inter)
+
+            inds = np.where(ovr <= thresh)[0]
+            order = order[inds + 1]
+
+        return keep
+