Update app.py

app.py

@@ -1,29 +1,24 @@
+# Set environment variables **before** importing libraries
 import os
-# Set environment variables BEFORE importing torch
-os.environ['CUDA_VISIBLE_DEVICES'] = '-1'  # Force CPU-only mode
-os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'  # Disable oneDNN custom operations
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'  # Suppress TensorFlow warnings
+os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'  # Disable oneDNN custom ops
+os.environ['PYTHONHASHSEED'] = '0'        # Ensure reproducibility
+os.environ['PYTORCH_NO_CUDA_MEMORY_CACHING'] = '1'  # Reduce RNG reliance
 
-# Ensure entropy source is available
-try:
-    # Try to initialize Python's RNG with system entropy
-    random_bytes = os.urandom(16)
-except Exception:
-    # Fallback to less secure method if system entropy fails
-    import time
-    os.environ['PYTHONHASHSEED'] = str(time.time())
-
-import gradio as gr
-import tensorflow as tf
+# Set deterministic behavior for PyTorch
+import torch
 import numpy as np
-from PIL import Image
-import json
+import tensorflow as tf
 
-# Suppress TensorFlow warnings
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
-tf.get_logger().setLevel('ERROR')
+# Fix: Set seeds **before** model initialization
+torch.manual_seed(42)
+torch.use_deterministic_algorithms(True)
+np.random.seed(42)
+tf.random.set_seed(42)
 
-# DEFER TORCH IMPORT UNTIL AFTER ENVIRONMENT SETUP
-import torch
+# Import remaining libraries
+import json
+from PIL import Image
 from torch_geometric.data import Data
 from torch_geometric.nn import GCNConv, global_mean_pool
 import torch.nn.functional as F
@@ -45,33 +40,45 @@ class GNN(torch.nn.Module):
         x = global_mean_pool(x, batch)
         return self.fc(x)
 
-# Model paths
+# Load models
 cnn_model_path = "final_cnn_model.h5"
 improved_model_path = "improved_model.h5"
 gnn_model_path = "higgs_gnn_model_cpu.pth"
 
-# Initialize models as None (will lazy-load later)
+# Initialize models as None
 cnn_model = None
 improved_model = None
 gnn_model = None
 
-# Prediction functions
+# Load models with error handling
+try:
+    cnn_model = tf.keras.models.load_model(cnn_model_path)
+    print(f"CNN model loaded successfully from {cnn_model_path}")
+except Exception as e:
+    print(f"Error loading CNN model: {e}")
+
+try:
+    improved_model = tf.keras.models.load_model(improved_model_path)
+    print(f"Improved model loaded successfully from {improved_model_path}")
+except Exception as e:
+    print(f"Error loading Improved model: {e}")
+
+try:
+    gnn_model = GNN()
+    gnn_model.load_state_dict(torch.load(gnn_model_path, map_location='cpu'))
+    gnn_model.eval()
+except Exception as e:
+    print(f"Error loading GNN model: {e}")
+
+# Prediction functions (unchanged from original)
 def predict_image(image):
-    global cnn_model
     if image is None:
         return "Error: No image provided"
     if cnn_model is None:
-        try:
-            print("Loading CNN model...")
-            cnn_model = tf.keras.models.load_model(cnn_model_path)
-            print("CNN model loaded successfully")
-        except Exception as e:
-            return f"Error loading CNN model: {e}"
+        return "Error: CNN model failed to load. Please check the model file."
     try:
-        # Convert to grayscale and resize to (25, 25)
         image = image.convert("L").resize((25, 25))
         image_array = np.array(image) / 255.0
-        # Reshape to (1, 25, 25, 1) for the new model
         image_array = np.expand_dims(image_array, axis=(0, -1))
         prediction = cnn_model.predict(image_array)[0][0]
         label = "Signal" if prediction > 0.5 else "Background"
@@ -80,67 +87,44 @@ def predict_image(image):
         return f"Error processing image: {str(e)}"
 
 def predict_numerical(data):
-    global improved_model
     if not data:
         return "Error: No numerical data provided"
     if improved_model is None:
-        try:
-            print("Loading Improved model...")
-            improved_model = tf.keras.models.load_model(improved_model_path)
-            print("Improved model loaded successfully")
-        except Exception as e:
-            return f"Error loading Improved model: {e}"
+        return "Error: Improved model failed to load. Please check the model file."
     try:
-        # Convert comma-separated input to numpy array and reshape to (1, n_features)
         input_data = np.array([float(x) for x in data.split(",")], dtype=np.float32)
-        # Check if the number of features matches the model's expected input
         expected_features = improved_model.input_shape[1]
         if len(input_data) != expected_features:
-            return f"Error: Expected {expected_features} features, got {len(input_data)}. Provide correct number of comma-separated values."
+            return f"Error: Expected {expected_features} features, got {len(input_data)}."
         input_data = input_data.reshape(1, expected_features)
-        # Predict using the improved model
         prediction = improved_model.predict(input_data)
-        # Get the class with the highest probability
         predicted_class = np.argmax(prediction, axis=1)[0]
-        # Get the probability of the predicted class
         confidence = prediction[0][predicted_class]
         return f"Improved Model Prediction: Class {predicted_class} (Confidence: {confidence:.4f})"
     except Exception as e:
         return f"Error processing numerical data: {str(e)}"
 
 def predict_graph(graph_json):
-    global gnn_model
     if not graph_json:
         return "Error: No graph JSON provided"
     if gnn_model is None:
-        try:
-            print("Loading GNN model...")
-            gnn_model = GNN()
-            gnn_model.load_state_dict(torch.load(gnn_model_path, map_location='cpu'))
-            gnn_model.eval()
-            print("GNN model loaded successfully")
-        except Exception as e:
-            return f"Error loading GNN model: {e}"
+        return "Error: GNN model failed to load"
     try:
         graph_data = json.loads(graph_json)
-        
-        # Convert to PyG Data format
         x = torch.tensor(graph_data['x'], dtype=torch.float32)
         edge_index = torch.tensor(graph_data['edge_index'], dtype=torch.long)
-        
-        # Create a batch with single graph
         data = Data(x=x, edge_index=edge_index)
         data.batch = torch.zeros(data.num_nodes, dtype=torch.long)
-        
         with torch.no_grad():
             out = gnn_model(data)
             prob = F.softmax(out, dim=1)[0][1].item()
-        
         return f"GNN Prediction: Signal Probability = {prob:.4f}"
     except Exception as e:
         return f"Error processing graph: {str(e)}"
 
 # Gradio Interface
+import gradio as gr
+
 with gr.Blocks(title="Multi-Model Gradio Interface") as demo:
     gr.Markdown("## Multi-Model Prediction Interface")