Solución actualizada para compatibilidad con TensorFlow y Keras

app.py

@@ -9,6 +9,10 @@ except ImportError:
     os.system("pip install streamlit>=1.31.0")
     import streamlit as st
 
+# Configura variables de entorno para TensorFlow
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'  # Reducir mensajes de TensorFlow
+os.environ['CUDA_VISIBLE_DEVICES'] = '-1'  # Forzar CPU para evitar problemas con GPU en entornos cloud
+
 # Configura mensaje de error personalizado para dlib
 try:
     import dlib
@@ -17,61 +21,32 @@ except ImportError:
     DLIB_AVAILABLE = False
     print("Warning: dlib no está disponible. Algunas funciones pueden estar limitadas.")
 
+# Verificar TensorFlow y configurar ambiente
+try:
+    import tensorflow as tf
+    tf_version = tf.__version__
+    print(f"TensorFlow version: {tf_version}")
+except Exception as e:
+    print(f"Warning: TensorFlow initialization error: {e}")
+
+# Aplicar parches para DeepFace y RetinaFace
+try:
+    # Intenta importar y aplicar parches
+    import deepface_patch
+    deepface_patch.apply_patches()
+except Exception as e:
+    print(f"Warning: Failed to apply patches: {e}")
+
 # Asegurar que los archivos necesarios estén disponibles
 required_model_files = [
     "deploy.prototxt",
-    "res10_300x300_ssd_iter_140000_fp16.caffemodel"
+    "res10_300x300_ssd_iter_140000.caffemodel",
+    "shape_predictor_68_face_landmarks.dat"
 ]
 
 for model_file in required_model_files:
     if not os.path.exists(model_file):
-        model_dir = "models"
-        if not os.path.exists(model_dir):
-            os.makedirs(model_dir)
-        
-        if model_file == "deploy.prototxt":
-            # Crear el archivo deploy.prototxt manualmente
-            with open(os.path.join(model_dir, model_file), "w") as f:
-                f.write("""name: "deploy"
-input: "data"
-input_shape {
-  dim: 1
-  dim: 3
-  dim: 300
-  dim: 300
-}
-layer {
-  name: "conv1_1"
-  type: "Convolution"
-  bottom: "data"
-  top: "conv1_1"
-  param {
-    lr_mult: 1
-    decay_mult: 1
-  }
-  param {
-    lr_mult: 2
-    decay_mult: 0
-  }
-  convolution_param {
-    num_output: 64
-    kernel_size: 3
-    pad: 1
-    weight_filler {
-      type: "xavier"
-    }
-    bias_filler {
-      type: "constant"
-      value: 0
-    }
-  }
-}
-# Continuar con el resto del modelo, pero simplificado por brevedad
-""")
-            print(f"Created {model_file}")
-        else:
-            # Para el caffemodel, informamos que se descargará automáticamente mediante DeepFace
-            print(f"Note: {model_file} will be downloaded automatically when needed")
+        print(f"Note: {model_file} will be downloaded automatically when needed")
 
 # Importa la aplicación principal
 from streamlit_app import main

deepface_patch.py

@@ -0,0 +1,100 @@
+"""
+Módulo para parchear DeepFace y RetinaFace para compatibilidad con diferentes versiones de TensorFlow
+"""
+import os
+import sys
+import importlib
+import warnings
+
+def patch_retina_face():
+    """Parchea RetinaFace para funcionar con Keras independiente o integrado en TensorFlow"""
+    try:
+        # Verificar si podemos importar retina_face
+        import retina_face
+        
+        # Verificar la versión de TensorFlow
+        import tensorflow as tf
+        tf_version = tf.__version__
+        
+        # Para TF 2.15.x, usamos keras estándar
+        if tf_version.startswith('2.15'):
+            try:
+                import keras
+                print(f"Using standard Keras {keras.__version__} with TensorFlow {tf_version}")
+                
+                # Monkeypatch para RetinaFace si es necesario
+                try:
+                    # Intentar importar el módulo que podría usar keras
+                    from retina_face.commons import postprocess
+                    if not hasattr(postprocess, '_keras_patched'):
+                        # Verificar si está usando tf.keras
+                        if hasattr(postprocess, 'keras') and postprocess.keras.__name__ == 'tensorflow.keras':
+                            print("Patching RetinaFace to use standard keras instead of tf.keras")
+                            postprocess.keras = keras
+                            postprocess._keras_patched = True
+                except ImportError:
+                    pass
+            except ImportError:
+                print("Standard Keras not found, using tf.keras")
+        
+        # Para TF 2.19.x, necesitamos tf-keras
+        elif tf_version.startswith('2.19'):
+            try:
+                import tf_keras
+                print(f"Using tf-keras with TensorFlow {tf_version}")
+                
+                # Monkeypatch para RetinaFace si es necesario
+                try:
+                    from retina_face.commons import postprocess
+                    if not hasattr(postprocess, '_keras_patched'):
+                        if hasattr(postprocess, 'keras'):
+                            print("Patching RetinaFace to use tf-keras")
+                            postprocess.keras = tf_keras
+                            postprocess._keras_patched = True
+                except ImportError:
+                    pass
+            except ImportError:
+                print("Warning: tf-keras not installed. RetinaFace may not work properly.")
+    
+    except ImportError as e:
+        print(f"Warning: Could not patch RetinaFace: {e}")
+
+def patch_deepface():
+    """Parchea DeepFace para funcionar con diferentes versiones de TensorFlow"""
+    try:
+        import deepface
+        import tensorflow as tf
+        tf_version = tf.__version__
+        
+        if tf_version.startswith('2.19'):
+            try:
+                import tf_keras
+                # Intentar parchear los módulos relevantes de DeepFace
+                deepface_modules = [
+                    'deepface.commons.functions',
+                    'deepface.detectors.RetinaFaceWrapper',
+                    'deepface.detectors.FaceDetector'
+                ]
+                
+                for module_name in deepface_modules:
+                    try:
+                        module = importlib.import_module(module_name)
+                        if hasattr(module, 'keras') and module.keras.__name__ == 'tensorflow.keras':
+                            module.keras = tf_keras
+                            print(f"Patched {module_name} to use tf-keras")
+                    except (ImportError, AttributeError):
+                        pass
+            except ImportError:
+                print("Warning: tf-keras not installed. DeepFace may not work properly with TF 2.19")
+    except ImportError as e:
+        print(f"Warning: Could not patch DeepFace: {e}")
+
+def apply_patches():
+    """Aplica todos los parches necesarios"""
+    warnings.filterwarnings('ignore')  # Reducir mensajes de advertencia
+    patch_retina_face()
+    patch_deepface()
+    print("Patches applied successfully")
+
+if __name__ == "__main__":
+    apply_patches() 

packages.txt

@@ -6,4 +6,7 @@ libxext6
 libx11-6
 libcairo2
 ffmpeg
-cmake 
+cmake
+libatk1.0-0
+libatk-bridge2.0-0
+libhdf5-dev 

requirements.txt

@@ -6,7 +6,8 @@ scikit-learn>=1.0.0
 matplotlib>=3.5.0
 pandas>=1.3.0
 deepface>=0.0.79
-tensorflow>=2.8.0
+tensorflow==2.15.0
+keras==2.15.0
 scipy>=1.7.0
 mtcnn>=0.1.0
 retina-face>=0.0.1