Update app.py

app.py

@@ -1,82 +1,156 @@
 import os
+import sys
 import torch
 import gradio as gr
+import importlib
 from huggingface_hub import hf_hub_download, snapshot_download
-import sys
-
-def setup_cognitive_net():
-    """Setup cognitive_net module from HuggingFace"""
-    # Download repository content
-    repo_path = snapshot_download(repo_id="VLabTech/cognitive_net")
-    
-    # Add the repository path to Python path so we can import the package
-    if repo_path not in sys.path:
-        sys.path.insert(0, repo_path)
-    
-    # Import the package
-    from network import DynamicCognitiveNet
-    return DynamicCognitiveNet
+from typing import List, Union
+from pathlib import Path
 
-def predict(input_text):
-    """Process input and return prediction"""
-    try:
-        # Parse input
-        values = [float(x.strip()) for x in input_text.split(",")]
-        if len(values) != 5:
-            return f"Error: Masukkan tepat 5 nilai (dipisahkan koma). Anda memasukkan {len(values)} nilai."
-        
-        # Setup model
-        DynamicCognitiveNet = setup_cognitive_net()
-        model = DynamicCognitiveNet(input_size=5, output_size=2)
+class CognitiveNetApp:
+    def __init__(self):
+        self.model = None
+        self.model_class = None
         
-        # Load weights
-        checkpoint_path = hf_hub_download(
-            repo_id="VLabTech/cognitive_net",
-            filename="model.pt"
-        )
-        model.load_state_dict(torch.load(checkpoint_path))
-        model.eval()
+    def setup_environment(self) -> None:
+        """
+        Menyiapkan environment untuk cognitive_net.
+        Mendownload repository dan mengatur Python path.
+        """
+        repo_path = snapshot_download(repo_id="VLabTech/cognitive_net")
+        repo_path = Path(repo_path)
         
-        # Generate prediction
-        input_tensor = torch.tensor(values, dtype=torch.float32)
-        with torch.no_grad():
-            output = model(input_tensor)
-        
-        # Format output
-        result = f"Hasil Prediksi:\n"
-        result += f"Output 1: {output[0]:.4f}\n"
-        result += f"Output 2: {output[1]:.4f}"
+        if str(repo_path) not in sys.path:
+            sys.path.insert(0, str(repo_path))
+            
+        # Tambahkan parent directory juga ke Python path
+        parent_path = str(repo_path.parent)
+        if parent_path not in sys.path:
+            sys.path.insert(0, parent_path)
+            
+    def load_model(self) -> None:
+        """
+        Memuat model cognitive_net dan checkpoint-nya.
+        Raises:
+            ImportError: Jika modul tidak dapat diimport
+            RuntimeError: Jika terjadi kesalahan saat memuat model
+        """
+        try:
+            self.setup_environment()
+            
+            import cognitive_net
+            importlib.reload(cognitive_net)
+            from cognitive_net.network import DynamicCognitiveNet
+            
+            self.model_class = DynamicCognitiveNet
+            self.model = DynamicCognitiveNet(input_size=5, output_size=2)
+            
+            # Muat weights
+            checkpoint_path = hf_hub_download(
+                repo_id="VLabTech/cognitive_net",
+                filename="model.pt"
+            )
+            self.model.load_state_dict(torch.load(checkpoint_path))
+            self.model.eval()
+            
+        except ImportError as e:
+            raise ImportError(f"Gagal mengimport cognitive_net: {str(e)}")
+        except Exception as e:
+            raise RuntimeError(f"Gagal memuat model: {str(e)}")
+    
+    def parse_input(self, input_text: str) -> List[float]:
+        """
+        Mengurai input text menjadi list of floats.
         
-        return result
+        Args:
+            input_text: String berisi angka yang dipisahkan koma
+            
+        Returns:
+            List of float values
+            
+        Raises:
+            ValueError: Jika format input tidak valid
+        """
+        try:
+            values = [float(x.strip()) for x in input_text.split(",")]
+            if len(values) != 5:
+                raise ValueError(
+                    f"Dibutuhkan tepat 5 nilai (dipisahkan koma). "
+                    f"Anda memasukkan {len(values)} nilai."
+                )
+            return values
+        except ValueError as e:
+            raise ValueError(f"Format input tidak valid: {str(e)}")
+    
+    def predict(self, input_text: str) -> str:
+        """
+        Memproses input dan menghasilkan prediksi.
         
-    except ValueError:
-        return "Error: Pastikan semua input adalah angka valid"
-    except Exception as e:
-        return f"Error: {str(e)}"
+        Args:
+            input_text: String berisi 5 angka yang dipisahkan koma
+            
+        Returns:
+            String berisi hasil prediksi atau pesan error
+        """
+        try:
+            if self.model is None:
+                self.load_model()
+                
+            # Parse input
+            values = self.parse_input(input_text)
+            
+            # Generate prediction
+            input_tensor = torch.tensor(values, dtype=torch.float32)
+            with torch.no_grad():
+                output = self.model(input_tensor)
+            
+            # Format output
+            result = "Hasil Prediksi:\n"
+            result += f"Output 1: {output[0]:.4f}\n"
+            result += f"Output 2: {output[1]:.4f}"
+            
+            return result
+            
+        except ValueError as e:
+            return f"Error: {str(e)}"
+        except Exception as e:
+            return f"Error: {str(e)}\nTrace: {e.__traceback__}"
 
-# Setup Gradio Interface
-demo = gr.Interface(
-    fn=predict,
-    inputs=gr.Textbox(
-        label="Input Values",
-        placeholder="Masukkan 5 nilai numerik (pisahkan dengan koma). Contoh: 1.0, 2.0, 3.0, 4.0, 5.0"
-    ),
-    outputs=gr.Textbox(label="Hasil Prediksi"),
-    title="Cognitive Network Demo",
-    description="""
-    ## Cognitive Network Inference Demo
+def create_demo() -> gr.Interface:
+    """
+    Membuat dan mengkonfigurasi Gradio interface.
     
-    Model ini menerima 5 input numerik dan menghasilkan 2 output numerik menggunakan
-    arsitektur Cognitive Network yang terinspirasi dari cara kerja otak biologis.
+    Returns:
+        Gradio Interface object
+    """
+    app = CognitiveNetApp()
+    
+    demo = gr.Interface(
+        fn=app.predict,
+        inputs=gr.Textbox(
+            label="Input Values",
+            placeholder="Masukkan 5 nilai numerik (pisahkan dengan koma). "
+                       "Contoh: 1.0, 2.0, 3.0, 4.0, 5.0"
+        ),
+        outputs=gr.Textbox(label="Hasil Prediksi"),
+        title="Cognitive Network Demo",
+        description="""
+        ## Cognitive Network Inference Demo
+        
+        Model ini menerima 5 input numerik dan menghasilkan 2 output numerik menggunakan
+        arsitektur Cognitive Network yang terinspirasi dari cara kerja otak biologis.
+        
+        Model source: https://huggingface.co/VLabTech/cognitive_net
+        """,
+        examples=[
+            ["1.0, 2.0, 3.0, 4.0, 5.0"],
+            ["0.5, -1.0, 2.5, 1.5, -0.5"],
+            ["0.1, 0.2, 0.3, 0.4, 0.5"]
+        ]
+    )
     
-    Model source: https://huggingface.co/VLabTech/cognitive_net
-    """,
-    examples=[
-        ["1.0, 2.0, 3.0, 4.0, 5.0"],
-        ["0.5, -1.0, 2.5, 1.5, -0.5"],
-        ["0.1, 0.2, 0.3, 0.4, 0.5"]
-    ]
-)
+    return demo
 
 if __name__ == "__main__":
+    demo = create_demo()
     demo.launch()