Update app.py

app.py

@@ -36,6 +36,21 @@ if physical_devices:
 else:
     print("No se detectó GPU. El procesamiento será más lento.")
 
+# IMPORTANTE: Habilitar deserialización insegura para capas Lambda
+try:
+    # Para TensorFlow 2.11+
+    if hasattr(tf.keras.config, 'enable_unsafe_deserialization'):
+        tf.keras.config.enable_unsafe_deserialization()
+        print("Deserialización insegura habilitada mediante tf.keras.config")
+    # Para versiones antiguas, intentar Keras directamente
+    elif hasattr(tf.keras.utils, 'enable_unsafe_deserialization'):
+        tf.keras.utils.enable_unsafe_deserialization()
+        print("Deserialización insegura habilitada mediante tf.keras.utils")
+    else:
+        print("No se pudo habilitar la deserialización insegura automáticamente")
+except Exception as e:
+    print(f"Error al configurar deserialización: {e}")
+
 # Descargar modelo desde Hugging Face (con caché)
 cache_dir = os.path.join(os.path.expanduser("~"), ".cache", "huggingface")
 model_path = hf_hub_download(
@@ -45,11 +60,41 @@ model_path = hf_hub_download(
 )
 print(f"Modelo cargado desde: {model_path}")
 
-# Cargar el modelo una sola vez
-model = tf.keras.models.load_model(model_path)
+# Cargar el modelo con desactivación de safety
+try:
+    # Intentar cargar con custom_objects para las funciones personalizadas
+    model = tf.keras.models.load_model(
+        model_path,
+        custom_objects={
+            'fourier_transform': fourier_transform,
+            'inverse_fourier_transform': inverse_fourier_transform
+        },
+        compile=False  # No compilar el modelo para inferencia más rápida
+    )
+    print("Modelo cargado correctamente")
+except Exception as e:
+    print(f"Error al cargar el modelo: {e}")
+    # Alternativa fallback para versiones más recientes de TF
+    try:
+        options = tf.saved_model.LoadOptions(
+            experimental_io_device='/job:localhost'
+        )
+        model = tf.keras.models.load_model(
+            model_path,
+            custom_objects={
+                'fourier_transform': fourier_transform,
+                'inverse_fourier_transform': inverse_fourier_transform
+            },
+            compile=False,
+            options=options
+        )
+        print("Modelo cargado con opciones alternativas")
+    except Exception as e2:
+        print(f"Error al cargar el modelo con opciones alternativas: {e2}")
+        raise Exception("No se pudo cargar el modelo")
 
 # Crear versión optimizada para inferencia
-@tf.function(jit_compile=True)
+@tf.function
 def predict_optimized(input_tensor):
     return model(input_tensor, training=False)
 
@@ -126,8 +171,9 @@ def Denoiser(imagen):
         # Medir el tiempo de la predicción
         start_time = time.time()
         
-        # Predecir con el autoencoder utilizando la función optimizada
-        reconstructed = predict_optimized(noisy_image_input).numpy()[0]
+        # Predecir con el autoencoder
+        # Usar llamada directa en lugar de predict() para más velocidad
+        reconstructed = model(noisy_image_input, training=False).numpy()[0]
         
         prediction_time = time.time() - start_time
         
@@ -147,14 +193,6 @@ def Denoiser(imagen):
         print(f"Error en el procesamiento: {e}")
         return None, None
 
-# Ejemplo para precalentamiento (warm-up) del modelo
-try:
-    dummy_input = np.zeros((1, 256, 256, 3), dtype=np.float32)
-    _ = predict_optimized(dummy_input)
-    print("Modelo precalentado con éxito")
-except Exception as e:
-    print(f"Error en precalentamiento: {e}")
-
 # Crear interfaz en Gradio
 demo = gr.Interface(
     fn=Denoiser,