pyfaceau 1.3.3__tar.gz → 1.3.4__tar.gz

{pyfaceau-1.3.3/pyfaceau.egg-info → pyfaceau-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyfaceau
-Version: 1.3.3
+Version: 1.3.4
 Summary: Pure Python OpenFace 2.2 AU extraction with CLNF landmark refinement
 Home-page: https://github.com/johnwilsoniv/face-analysis
 Author: John Wilson

{pyfaceau-1.3.3 → pyfaceau-1.3.4}/pyfaceau/config.py

@@ -16,9 +16,12 @@ CLNF_CONFIG = {
     'max_iterations': 10,
     'convergence_threshold': 0.005,  # Gold standard (stricter than 0.01)
     'sigma': 2.25,                   # C++ CECLM default (1.5 × 1.5 scale factor)
-    'use_eye_refinement': True,      # Enable hierarchical eye model refinement
+    'use_eye_refinement': True,      # Enabled: fixed transpose bug, now improves accuracy
     'convergence_profile': 'video',  # Enable template tracking + scale adaptation
     'detector': False,               # Disable built-in detector (pyfaceau handles)
+    'use_gpu': True,                 # Enable GPU acceleration (10-20x speedup)
+    'gpu_device': 'auto',            # GPU device: 'auto', 'mps', 'cuda', 'cpu'
+    'use_validator': False,          # Disable detection validator (68% of CLNF time)
 }
 
 # =============================================================================
@@ -67,11 +70,9 @@ AU_CONFIG = {
     'max_stored_frames': 3000,       # OpenFace default for re-prediction
 
     # AU-specific cutoff overrides
-    # Python raw predictions are systematically higher than C++ for certain AUs.
-    # These adjusted cutoffs compensate to match C++ behavior.
-    # See diagnose_raw_prediction_diff.py for derivation.
+    # NOTE: With the fix to include zeros in cutoff calculation (matching C++),
+    # most overrides are no longer needed. Only keep AU26_r which has unusual behavior.
     'cutoff_overrides': {
-        'AU20_r': 0.40,              # Original: 0.65 -> 0.9729 correlation (PASS)
         'AU26_r': 0.12,              # Original: 0.30 -> 0.9317 correlation (best achievable)
     },
 }

{pyfaceau-1.3.3 → pyfaceau-1.3.4}/pyfaceau/data/training_data_generator.py

@@ -130,6 +130,72 @@ class TrainingDataGenerator:
         # pyfhog 0.1.4+ outputs in OpenFace-compatible format (4464,)
         return hog.astype(np.float32)
 
+    def _crop_and_align_bbox(
+        self,
+        image: np.ndarray,
+        bbox: np.ndarray
+    ) -> tuple:
+        """
+        Crop face from image using bbox (matching NNCLNF inference alignment).
+
+        This creates the SAME alignment that NNCLNF uses at inference time,
+        ensuring training and inference see the same type of crops.
+
+        Args:
+            image: BGR image
+            bbox: Face bounding box [x, y, width, height]
+
+        Returns:
+            aligned_face: 112x112 BGR face image
+            warp_matrix: 2x3 affine transform matrix (for landmark transformation)
+        """
+        bbox_x, bbox_y, bbox_w, bbox_h = bbox
+
+        # Apply PyMTCNN bbox correction (matching NNCLNF)
+        bbox_x = bbox_x + bbox_w * 0.0625
+        bbox_y = bbox_y + bbox_h * 0.0625
+        bbox_w = bbox_w * 0.875
+        bbox_h = bbox_h * 0.875
+
+        size = max(bbox_w, bbox_h)
+        center_x = bbox_x + bbox_w / 2
+        center_y = bbox_y + bbox_h / 2
+
+        # Y offset correction (matching NNCLNF inference)
+        center_y -= size * 0.12
+
+        # Add padding (10% on each side)
+        padding = 0.1
+        size_with_pad = size * (1 + 2 * padding)
+
+        x1 = center_x - size_with_pad / 2
+        y1 = center_y - size_with_pad / 2
+        x2 = center_x + size_with_pad / 2
+        y2 = center_y + size_with_pad / 2
+
+        src_pts = np.array([
+            [x1, y1],
+            [x2, y1],
+            [x2, y2],
+        ], dtype=np.float32)
+
+        dst_pts = np.array([
+            [0, 0],
+            [112, 0],
+            [112, 112],
+        ], dtype=np.float32)
+
+        M = cv2.getAffineTransform(src_pts, dst_pts)
+
+        aligned_face = cv2.warpAffine(
+            image, M, (112, 112),
+            flags=cv2.INTER_LINEAR,
+            borderMode=cv2.BORDER_CONSTANT,
+            borderValue=(0, 0, 0)
+        )
+
+        return aligned_face, M
+
     def _predict_aus(self, hog_features: np.ndarray, geom_features: np.ndarray) -> np.ndarray:
         """Predict AU intensities from features."""
         full_vector = np.concatenate([hog_features, geom_features])
@@ -213,18 +279,10 @@ class TrainingDataGenerator:
                 print(f"    [DEBUG] CalcParams error: {e}")
             return None
 
-        # Face alignment - also get the warp matrix for landmark transformation
+        # Face alignment - use bbox-based alignment (matching NNCLNF inference)
+        # This ensures training and inference use the SAME alignment approach
         try:
-            tx, ty, rz = global_params[4], global_params[5], global_params[3]
-            aligned_face, warp_matrix = self._face_aligner.align_face_with_matrix(
-                image=frame,
-                landmarks_68=landmarks,
-                pose_tx=tx,
-                pose_ty=ty,
-                p_rz=rz,
-                apply_mask=True,
-                triangulation=self._triangulation
-            )
+            aligned_face, warp_matrix = self._crop_and_align_bbox(frame, bbox)
         except Exception as e:
             if self.config.verbose:
                 print(f"    [DEBUG] Face alignment error: {e}")

{pyfaceau-1.3.3 → pyfaceau-1.3.4}/pyfaceau/parallel_pipeline.py

@@ -217,7 +217,8 @@ class ParallelAUPipeline:
                         geom_features = frame_features['geom_features']
 
                         # Update running median (must be sequential)
-                        update_histogram = (idx % 2 == 1)
+                        # C++ increments frames_tracking BEFORE check, update on even frames
+                        update_histogram = (idx % 2 == 0)
                         self.main_pipeline.running_median.update(
                             hog_features,
                             geom_features,

{pyfaceau-1.3.3 → pyfaceau-1.3.4}/pyfaceau/pipeline.py

@@ -44,7 +44,7 @@ from pyfaceau.refinement.targeted_refiner import TargetedCLNFRefiner
 
 # Import Cython-optimized running median (with fallback)
 try:
-    from cython_histogram_median import DualHistogramMedianTrackerCython as DualHistogramMedianTracker
+    from pyfaceau.cython_histogram_median import DualHistogramMedianTrackerCython as DualHistogramMedianTracker
     USING_CYTHON = True
 except ImportError:
     from pyfaceau.features.histogram_median_tracker import DualHistogramMedianTracker
@@ -57,6 +57,9 @@ try:
 except ImportError:
     USING_BATCHED_PREDICTOR = False
 
+# NNCLNF (neural network replacement for CLNF) is defunct and archived
+# Use pyclnf with GPU acceleration instead for best accuracy + speed
+
 # Import online AU correction (C++ CorrectOnlineAUs equivalent)
 from pyfaceau.prediction.online_au_correction import OnlineAUCorrection
 
@@ -191,6 +194,7 @@ class FullPythonAUPipeline:
         use_calc_params: bool = True,
         track_faces: bool = True,
         use_batched_predictor: bool = True,
+        use_nnclnf: str = 'pyclnf',  # NNCLNF is defunct, always use pyclnf
         max_clnf_iterations: int = CLNF_CONFIG['max_iterations'],
         clnf_convergence_threshold: float = CLNF_CONFIG['convergence_threshold'],
         debug_mode: bool = False,
@@ -199,7 +203,7 @@ class FullPythonAUPipeline:
         """
         Initialize the full Python AU pipeline (OpenFace-compatible)
 
-        Architecture: PyMTCNN → CLNF → AU Prediction
+        Architecture: PyMTCNN → pyclnf CLNF → AU Prediction
         (matches OpenFace C++ 2.2 pipeline)
 
         Args:
@@ -211,6 +215,7 @@ class FullPythonAUPipeline:
             use_calc_params: DEPRECATED - pyclnf params are now used instead (default: True)
             track_faces: Use face tracking between frames (default: True)
             use_batched_predictor: Use optimized batched AU predictor (default: True)
+            use_nnclnf: DEPRECATED - always uses pyclnf (NNCLNF is defunct)
             max_clnf_iterations: Maximum CLNF optimization iterations (default: 10)
             clnf_convergence_threshold: CLNF convergence threshold in pixels (default: 0.01)
             debug_mode: Enable debug mode for diagnostics (default: False)
@@ -236,6 +241,7 @@ class FullPythonAUPipeline:
             'au_models_dir': au_models_dir,
             'triangulation_file': triangulation_file,
             'patch_expert_file': patch_expert_file,
+            'use_nnclnf': use_nnclnf,
             'max_clnf_iterations': max_clnf_iterations,
             'clnf_convergence_threshold': clnf_convergence_threshold,
         }
@@ -317,11 +323,12 @@ class FullPythonAUPipeline:
                 print(f"  Active backend: {backend_info}")
                 print("Face detector loaded\n")
 
-            # Component 2: Landmark Detection (CLNF - OpenFace approach via pyclnf)
+            # Component 2: Landmark Detection (pyclnf CLNF with GPU acceleration)
             if self.verbose:
                 print("[2/8] Loading CLNF landmark detector (pyclnf)...")
                 print(f"  Max iterations: {max_clnf_iterations}")
                 print(f"  Convergence threshold: {clnf_convergence_threshold} pixels")
+                print(f"  GPU enabled: {CLNF_CONFIG.get('use_gpu', False)}")
 
             # Lazy import to avoid circular import (pyfaceau ↔ pyclnf)
             from pyclnf import CLNF
@@ -333,8 +340,12 @@ class FullPythonAUPipeline:
                 detector=CLNF_CONFIG['detector'],  # Disable built-in PyMTCNN (pyfaceau handles detection)
                 use_eye_refinement=CLNF_CONFIG['use_eye_refinement'],  # Enable hierarchical eye model refinement
                 convergence_profile=CLNF_CONFIG['convergence_profile'],  # Enable video mode with template tracking + scale adaptation
-                sigma=CLNF_CONFIG['sigma']  # KDE kernel sigma matching C++ CECLM
+                sigma=CLNF_CONFIG['sigma'],  # KDE kernel sigma matching C++ CECLM
+                use_gpu=CLNF_CONFIG.get('use_gpu', False),  # GPU acceleration (10-20x speedup)
+                gpu_device=CLNF_CONFIG.get('gpu_device', 'auto'),  # GPU device selection
+                use_validator=CLNF_CONFIG.get('use_validator', True)  # Detection validator (disabled for speed)
             )
+
             if self.verbose:
                 print(f"CLNF detector loaded\n")
 
@@ -429,6 +440,18 @@ class FullPythonAUPipeline:
 
             self._components_initialized = True
 
+    @property
+    def using_nnclnf(self) -> bool:
+        """DEPRECATED: NNCLNF is defunct, always returns False."""
+        return False
+
+    @property
+    def landmark_detector_name(self) -> str:
+        """Get the name of the landmark detector being used."""
+        if not self._components_initialized:
+            return "not initialized"
+        return "pyclnf"
+
     def _initialize_landmarks_from_bbox(self, bbox):
         """
         Initialize 2D landmarks from PDM mean shape scaled to fit bbox.
@@ -893,7 +916,9 @@ class FullPythonAUPipeline:
             t0 = time.time() if debug_info is not None else None
             if self.verbose and frame_idx < 3:
                 print(f"[Frame {frame_idx}] Step 7: Updating running median...")
-            update_histogram = (frame_idx % 2 == 1)  # Every 2nd frame
+            # C++ increments frames_tracking BEFORE the check, so frame 0 → counter=1 → update
+            # To match: update on frames 0, 2, 4, 6... (even frames)
+            update_histogram = (frame_idx % 2 == 0)  # Match C++ timing
             self.running_median.update(hog_features, geom_features, update_histogram=update_histogram)
             running_median = self.running_median.get_combined_median()
             if self.verbose and frame_idx < 3:
@@ -1089,10 +1114,16 @@ class FullPythonAUPipeline:
                 if model_cutoff <= 0 or model_cutoff >= 1.0:
                     continue
 
-                # Fix 2: Match C++ - sort only VALID (non-zero) predictions
-                # C++ FaceAnalyser.cpp:656 uses au_good which excludes zeros
+                # Match C++ - include ALL values from successful frames
+                # C++ FaceAnalyser.cpp uses au_good which includes all values from frames
+                # where successes[frame]==true, INCLUDING zeros
                 au_values = df[au_col].values
-                valid_mask = au_values > 0.001  # Filter out zeros/near-zeros
+
+                # Filter by success flag if available, otherwise use all non-NaN values
+                if 'success' in df.columns:
+                    valid_mask = df['success'].values == 1
+                else:
+                    valid_mask = ~np.isnan(au_values)
                 valid_vals = au_values[valid_mask]
 
                 # Need enough valid values to compute meaningful percentile

{pyfaceau-1.3.3 → pyfaceau-1.3.4}/pyfaceau/prediction/au_predictor.py

@@ -302,7 +302,8 @@ class OpenFace22AUPredictor:
             geom_feat = self._extract_geometric_features(csv_data.iloc[i])
 
             # Update tracker (every 2nd frame)
-            update_histogram = (i % 2 == 1)
+            # C++ increments frames_tracking BEFORE check, update on even frames
+            update_histogram = (i % 2 == 0)
             median_tracker.update(hog_feat, geom_feat, update_histogram=update_histogram)
 
             # Store running median

{pyfaceau-1.3.3 → pyfaceau-1.3.4/pyfaceau.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyfaceau
-Version: 1.3.3
+Version: 1.3.4
 Summary: Pure Python OpenFace 2.2 AU extraction with CLNF landmark refinement
 Home-page: https://github.com/johnwilsoniv/face-analysis
 Author: John Wilson

{pyfaceau-1.3.3 → pyfaceau-1.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyfaceau"
-version = "1.3.3"
+version = "1.3.4"
 description = "Pure Python OpenFace 2.2 AU extraction with CLNF landmark refinement"
 readme = "README.md"
 requires-python = ">=3.10"