final config

app.py

@@ -1,5 +1,6 @@
 import gradio as gr
 import tensorflow as tf
+from tensorflow.keras import layers, Model
 import keras
 import numpy as np
 import pandas as pd
@@ -15,52 +16,77 @@ encoder_model = None
 load_error = None
 
 
-class DenseCompat(tf.keras.layers.Dense):
-    @classmethod
-    def from_config(cls, config):
-        # Strip unsupported args from older Keras/TensorFlow builds.
-        config = dict(config)
-        config.pop("quantization_config", None)
-        return cls(**config)
+def build_model(input_dim=18241, latent_dim=32):
+    """
+    Rebuild the model architecture from scratch to avoid deserialization issues.
+    Architecture matches the training notebook exactly.
+    """
+    inputs = layers.Input(shape=(input_dim,))
+    
+    # Encoder
+    x = layers.Dense(512, activation="relu")(inputs)
+    x = layers.BatchNormalization()(x)
+    x = layers.Dropout(0.3)(x)
+    x = layers.Dense(128, activation="relu")(x)
+    latent = layers.Dense(latent_dim, name="latent")(x)
+    
+    # Decoder
+    x = layers.Dense(128, activation="relu")(latent)
+    x = layers.Dense(512, activation="relu")(x)
+    reconstruction = layers.Dense(input_dim, name="reconstruction")(x)
+    
+    # Age prediction head
+    age_pred = layers.Dense(1, name="age")(latent)
+    
+    model = Model(inputs=inputs, outputs=[reconstruction, age_pred])
+    return model
+
 
 def load_resources():
     global model, encoder_model, load_error
     load_error = None
+    
+    # Build model from architecture
+    model = build_model()
+    
+    # Try to load weights from saved file
     if os.path.exists(MODEL_PATH):
         try:
-            # Load the full multi-output model
-            model = keras.saving.load_model(
-                MODEL_PATH,
-                compile=False,
-                safe_mode=False,
-                custom_objects={
-                    "Dense": DenseCompat,
-                    "keras.layers.Dense": DenseCompat,
-                },
-            )
-        except Exception:
+            print(f"Loading weights from {MODEL_PATH}...")
+            # Try to load as keras model first to extract weights
             try:
-                model = tf.keras.models.load_model(
+                saved_model = keras.saving.load_model(
                     MODEL_PATH,
                     compile=False,
-                    custom_objects={
-                        "Dense": DenseCompat,
-                        "keras.layers.Dense": DenseCompat,
-                    },
+                    safe_mode=False,
                 )
-            except Exception as inner_e:
-                load_error = str(inner_e)
-                print(f"Error loading model: {inner_e}")
-                return
-
-        try:
-            latent_layer = model.get_layer("latent")
-            encoder_model = tf.keras.Model(inputs=model.input, outputs=latent_layer.output)
-            print("Model and Encoder extracted successfully.")
-        except Exception:
-            print("Warning: 'latent' layer not found. Only age prediction will be available.")
+                model.set_weights(saved_model.get_weights())
+                print("Weights loaded successfully from .keras file.")
+            except Exception:
+                # Fallback: try loading as h5 or other format
+                try:
+                    model.load_weights(MODEL_PATH)
+                    print("Weights loaded successfully.")
+                except Exception as e:
+                    load_error = f"Could not load weights: {e}"
+                    print(f"Warning: {load_error}")
+                    print("Model will run with random weights.")
+        except Exception as e:
+            load_error = f"Error loading weights: {e}"
+            print(f"Warning: {load_error}")
+            print("Model will run with random weights.")
     else:
-        load_error = f"Model file not found at {MODEL_PATH}"
+        load_error = f"Model file not found at {MODEL_PATH}. Model will run with random weights."
+        print(load_error)
+    
+    # Create encoder model
+    try:
+        latent_layer = model.get_layer("latent")
+        encoder_model = Model(inputs=model.input, outputs=latent_layer.output)
+        print("Encoder model created successfully.")
+    except Exception as e:
+        print(f"Warning: Could not create encoder model: {e}")
+
 
 # Initial load
 load_resources()