Update app.py

app.py

@@ -6,28 +6,11 @@ from huggingface_hub import hf_hub_download
 import time
 import os
 
-# Registrar las funciones personalizadas
-from tensorflow.keras.saving import register_keras_serializable
-
-@register_keras_serializable()
-def fourier_transform(x):
-    fourier = tf.signal.fft2d(tf.cast(x, tf.complex64))
-    fourier = tf.complex(tf.math.real(fourier), tf.math.imag(fourier))
-    fourier = tf.abs(fourier)
-    return tf.concat([tf.math.real(fourier), tf.math.imag(fourier)], axis=-1)
-
-@register_keras_serializable()
-def inverse_fourier_transform(x):
-    real_part, imag_part = tf.split(x, num_or_size_splits=2, axis=-1)
-    complex_fourier = tf.complex(real_part, imag_part)
-    return tf.abs(tf.signal.ifft2d(complex_fourier))
-
 # Configuración de GPU para TensorFlow
 physical_devices = tf.config.list_physical_devices('GPU')
 if physical_devices:
     print("GPU disponible. Configurando...")
     try:
-        # Permitir crecimiento de memoria según sea necesario
         for gpu in physical_devices:
             tf.config.experimental.set_memory_growth(gpu, True)
         print("Configuración de GPU completada")
@@ -36,67 +19,79 @@ 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(
-    repo_id="Bmo411/DenoisingAutoencoder", 
-    filename="autoencoder_complete_model_Fourier.keras",
-    cache_dir=cache_dir
-)
-print(f"Modelo cargado desde: {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
-def predict_optimized(input_tensor):
-    return model(input_tensor, training=False)
+# Definir funciones personalizadas para las transformadas de Fourier
+def fourier_transform(x):
+    fourier = tf.signal.fft2d(tf.cast(x, tf.complex64))
+    fourier = tf.complex(tf.math.real(fourier), tf.math.imag(fourier))
+    fourier = tf.abs(fourier)
+    return tf.concat([tf.math.real(fourier), tf.math.imag(fourier)], axis=-1)
+
+def inverse_fourier_transform(x):
+    real_part, imag_part = tf.split(x, num_or_size_splits=2, axis=-1)
+    complex_fourier = tf.complex(real_part, imag_part)
+    return tf.abs(tf.signal.ifft2d(complex_fourier))
+
+# Construir modelo manualmente
+def build_autoencoder(input_shape=(256, 256, 3)):
+    """Reconstruir el modelo autoencoder manualmente"""
+    
+    # Definir entradas
+    inputs = tf.keras.layers.Input(shape=input_shape)
+    
+    # Aplicar transformada de Fourier (opcional)
+    # x = tf.keras.layers.Lambda(fourier_transform)(inputs)
+    x = inputs  # Skip Fourier transform for now
+    
+    # Encoder
+    x = tf.keras.layers.Conv2D(32, (3, 3), activation='relu', padding='same')(x)
+    x = tf.keras.layers.MaxPooling2D((2, 2), padding='same')(x)
+    x = tf.keras.layers.Conv2D(64, (3, 3), activation='relu', padding='same')(x)
+    x = tf.keras.layers.MaxPooling2D((2, 2), padding='same')(x)
+    x = tf.keras.layers.Conv2D(128, (3, 3), activation='relu', padding='same')(x)
+    encoded = tf.keras.layers.MaxPooling2D((2, 2), padding='same')(x)
+    
+    # Decoder
+    x = tf.keras.layers.Conv2D(128, (3, 3), activation='relu', padding='same')(encoded)
+    x = tf.keras.layers.UpSampling2D((2, 2))(x)
+    x = tf.keras.layers.Conv2D(64, (3, 3), activation='relu', padding='same')(x)
+    x = tf.keras.layers.UpSampling2D((2, 2))(x)
+    x = tf.keras.layers.Conv2D(32, (3, 3), activation='relu', padding='same')(x)
+    x = tf.keras.layers.UpSampling2D((2, 2))(x)
+    
+    # Output
+    # x = tf.keras.layers.Lambda(inverse_fourier_transform)(x)  # Skip inverse transform
+    outputs = tf.keras.layers.Conv2D(3, (3, 3), activation='sigmoid', padding='same')(x)
+    
+    # Crear modelo
+    model = tf.keras.models.Model(inputs, outputs)
+    
+    return model
+
+# Opción alternativa: Crear un modelo simplificado
+def build_simple_autoencoder(input_shape=(256, 256, 3)):
+    """Crear un autoencoder simple (sin Fourier)"""
+    
+    inputs = tf.keras.layers.Input(shape=input_shape)
+    
+    # Encoder
+    x = tf.keras.layers.Conv2D(32, (3, 3), activation='relu', padding='same')(inputs)
+    x = tf.keras.layers.MaxPooling2D((2, 2), padding='same')(x)
+    x = tf.keras.layers.Conv2D(64, (3, 3), activation='relu', padding='same')(x)
+    x = tf.keras.layers.MaxPooling2D((2, 2), padding='same')(x)
+    
+    # Decoder
+    x = tf.keras.layers.Conv2D(64, (3, 3), activation='relu', padding='same')(x)
+    x = tf.keras.layers.UpSampling2D((2, 2))(x)
+    x = tf.keras.layers.Conv2D(32, (3, 3), activation='relu', padding='same')(x)
+    x = tf.keras.layers.UpSampling2D((2, 2))(x)
+    
+    # Output
+    outputs = tf.keras.layers.Conv2D(3, (3, 3), activation='sigmoid', padding='same')(x)
+    
+    # Crear modelo
+    model = tf.keras.models.Model(inputs, outputs)
+    
+    return model
 
 # Funciones de preprocesamiento optimizadas
 def degrade_image(image, downscale_factor=4):
@@ -143,12 +138,13 @@ def preprocess_image(image, std_dev=0.1, downscale_factor=4, target_size=(256, 2
 
     return noisy_img
 
-# Variable para medir el tiempo total de la primera ejecución
-first_run = True
+print("Crear modelo simplificado...")
+model = build_simple_autoencoder()
+print("Modelo creado correctamente")
 
+# Función de denoising
 def Denoiser(imagen):
     """Aplica el modelo autoencoder para eliminar ruido de la imagen."""
-    global first_run
     
     # Verificar que la imagen no sea None
     if imagen is None:
@@ -171,17 +167,12 @@ def Denoiser(imagen):
         # Medir el tiempo de la predicción
         start_time = time.time()
         
-        # Predecir con el autoencoder
-        # Usar llamada directa en lugar de predict() para más velocidad
+        # Para la primera versión usamos el modelo simple sin Fourier
+        # Esto resolverá el problema de lambda layers
         reconstructed = model(noisy_image_input, training=False).numpy()[0]
         
         prediction_time = time.time() - start_time
-        
-        if first_run:
-            print(f"Primera ejecución: {prediction_time:.2f} segundos")
-            first_run = False
-        else:
-            print(f"Tiempo de predicción: {prediction_time:.2f} segundos")
+        print(f"Tiempo de predicción: {prediction_time:.2f} segundos")
         
         # Asegurarse de que las imágenes estén en el rango [0, 255]
         noisy_image = np.uint8(noisy_image * 255)
@@ -202,7 +193,8 @@ demo = gr.Interface(
         gr.Image(type="numpy", label="Imagen Restaurada")
     ],
     title="Autoencoder para Denoising",
-    description="Este modelo de autoencoder reduce el ruido en imágenes. Sube una imagen y el modelo generará una versión restaurada.",
+    description="""Este modelo de autoencoder reduce el ruido en imágenes. Sube una imagen para ver el resultado.
+                  Nota: Esta es una versión simplificada que no utiliza el modelo pre-entrenado debido a limitaciones técnicas.""",
     examples=[
         "https://raw.githubusercontent.com/gradio-app/gradio/main/demo/english_htr/images/Create%20a%20free%20Gradio%20account%20to%20access%20our%20most%20powerful%20features.jpeg"
     ],