Update app.py

app.py

@@ -6,13 +6,11 @@ import pickle
 import io
 import sys
 import torch
-import torch
 import subprocess
 
 # Paths to the predefined images folder
 RAW_PATH = os.path.join("images", "raw")
 EMBEDDINGS_PATH = os.path.join("images", "embeddings")
-GENERATED_PATH = os.path.join("images", "generated")
 
 # Specific values for percentage and complexity
 percentage_values = [10, 30, 50, 70, 100]
@@ -32,68 +30,21 @@ class PrintCapture(io.StringIO):
         return ''.join(self.output)
 
 # Function to load and display predefined images based on user selection
-#def display_predefined_images(percentage_idx, complexity_idx):
-#    percentage = percentage_values[percentage_idx]
-#    complexity = complexity_values[complexity_idx]
-#    raw_image_path = os.path.join(RAW_PATH, f"percentage_{percentage}_complexity_{complexity}.png")
-#    embeddings_image_path = os.path.join(EMBEDDINGS_PATH, f"percentage_{percentage}_complexity_{complexity}.png")
-    
-#    raw_image = Image.open(raw_image_path)
-#    embeddings_image = Image.open(embeddings_image_path)
-    
-#    return raw_image, embeddings_image
-
 def display_predefined_images(percentage_idx, complexity_idx):
-    # Map the slider index to the actual value
     percentage = percentage_values[percentage_idx]
     complexity = complexity_values[complexity_idx]
-    
-    # Generate the paths to the images
     raw_image_path = os.path.join(RAW_PATH, f"percentage_{percentage}_complexity_{complexity}.png")
     embeddings_image_path = os.path.join(EMBEDDINGS_PATH, f"percentage_{percentage}_complexity_{complexity}.png")
     
-    # Check if the images exist
-    if not os.path.exists(raw_image_path):
-        return None, None  # Or handle the error appropriately
-    if not os.path.exists(embeddings_image_path):
-        return None, None  # Or handle the error appropriately
-
-    # Load images using PIL
     raw_image = Image.open(raw_image_path)
     embeddings_image = Image.open(embeddings_image_path)
     
-    # Return the loaded images
     return raw_image, embeddings_image
-    
-
-# Function to load the pre-trained model from your cloned repository
-def load_custom_model():
-    from lwm_model import LWM  # Assuming the model is defined in lwm_model.py
-    model = LWM()  # Modify this according to your model initialization
-    model.eval()
-    return model
-
-import importlib.util
-
-# Function to dynamically load a Python module from a given file path
-def load_module_from_path(module_name, file_path):
-    spec = importlib.util.spec_from_file_location(module_name, file_path)
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    return module
-
-import sys
-import os
-import subprocess
-import pickle
-import importlib.util
 
-# Function to dynamically load a Python module from a given file path
-def load_module_from_path(module_name, file_path):
-    spec = importlib.util.spec_from_file_location(module_name, file_path)
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    return module
+# Function to create random images for LoS/NLoS classification results
+def create_random_image(size=(300, 300)):
+    random_image = np.random.rand(*size, 3) * 255
+    return Image.fromarray(random_image.astype('uint8'))
 
 # Function to process the uploaded .p file and perform inference using the custom model
 def process_p_file(uploaded_file, percentage_idx, complexity_idx):
@@ -113,57 +64,15 @@ def process_p_file(uploaded_file, percentage_idx, complexity_idx):
         if os.path.exists(model_repo_dir):
             os.chdir(model_repo_dir)
             print(f"Changed working directory to {os.getcwd()}")
-            print(f"Directory content: {os.listdir(os.getcwd())}")  # Debugging: Check repo content
         else:
             print(f"Directory {model_repo_dir} does not exist.")
             return
 
-        # Step 3: Dynamically load lwm_model.py, input_preprocess.py, and inference.py
-        lwm_model_path = os.path.join(os.getcwd(), 'lwm_model.py')
-        input_preprocess_path = os.path.join(os.getcwd(), 'input_preprocess.py')
-        inference_path = os.path.join(os.getcwd(), 'inference.py')
-
-        print(lwm_model_path)
-        print(input_preprocess_path)
-        print(inference_path)
-        
-        # Load lwm_model
-        if os.path.exists(lwm_model_path):
-            lwm_model = load_module_from_path("lwm_model", lwm_model_path)
-        else:
-            return f"Error: lwm_model.py not found at {lwm_model_path}"
-
-        # Load input_preprocess
-        if os.path.exists(input_preprocess_path):
-            input_preprocess = load_module_from_path("input_preprocess", input_preprocess_path)
-        else:
-            return f"Error: input_preprocess.py not found at {input_preprocess_path}"
-
-        # Load inference
-        if os.path.exists(inference_path):
-            inference = load_module_from_path("inference", inference_path)
-        else:
-            return f"Error: inference.py not found at {inference_path}"
-
-        # Step 4: Load the model from lwm_model module
-        device = 'cpu'
-        print(f"Loading the LWM model on {device}...")
-        model = lwm_model.LWM.from_pretrained(device=device)
-
-        # Step 5: Tokenize the data using the tokenizer from input_preprocess
-        with open(uploaded_file.name, 'rb') as f:
-            manual_data = pickle.load(f)
-
-        preprocessed_chs = input_preprocess.tokenizer(manual_data=manual_data)
+        # Simulate processing and generating random images
+        raw_image = create_random_image()
+        embeddings_image = create_random_image()
 
-        # Step 6: Perform inference using the functions from inference.py
-        output_emb = inference.lwm_inference(preprocessed_chs, 'channel_emb', model)
-        output_raw = inference.create_raw_dataset(preprocessed_chs, device)
-
-        print(f"Output Embeddings Shape: {output_emb.shape}")
-        print(f"Output Raw Shape: {output_raw.shape}")
-
-        return output_emb, output_raw, capture.get_output()
+        return raw_image, embeddings_image, capture.get_output()
 
     except Exception as e:
         return str(e), str(e), capture.get_output()
@@ -171,13 +80,12 @@ def process_p_file(uploaded_file, percentage_idx, complexity_idx):
     finally:
         sys.stdout = sys.__stdout__  # Reset print statements
 
-
 # Function to handle logic based on whether a file is uploaded or not
 def los_nlos_classification(file, percentage_idx, complexity_idx):
     if file is not None:
         return process_p_file(file, percentage_idx, complexity_idx)
     else:
-        return display_predefined_images(percentage_idx, complexity_idx), None
+        return create_random_image(), create_random_image(), None
 
 # Define the Gradio interface
 with gr.Blocks(css="""