Update app.py

app.py

@@ -3,159 +3,118 @@ import torch
 import numpy as np
 import plotly.graph_objects as go
 from huggingface_hub import hf_hub_download
-from pathlib import Path
 import sys
 import os
+from pathlib import Path
 
-# Download model files from hub
-def download_model_files():
-    files = ['memory.py', 'node.py', 'network.py', '__init__.py']
-    repo_id = "VLabTech/cognitive_net"
+# 1. Download Model Files ------------------------------------------------
+def setup_model():
+    REPO_ID = "VLabTech/cognitive_net"
+    FILE_LIST = [
+        "cognitive_net/__init__.py",
+        "cognitive_net/memory.py",
+        "cognitive_net/node.py", 
+        "cognitive_net/network.py"
+    ]
     
-    model_dir = Path('cognitive_net')
+    # Create package directory
+    model_dir = Path("cognitive_net")
     model_dir.mkdir(exist_ok=True)
     
-    for file in files:
+    # Download files
+    for file in FILE_LIST:
         try:
-            hf_hub_download(
-                repo_id=repo_id,
+            downloaded_file = hf_hub_download(
+                repo_id=REPO_ID,
                 filename=file,
-                local_dir=model_dir
+                local_dir=model_dir.parent,
+                force_filename=file
             )
         except Exception as e:
             print(f"Error downloading {file}: {str(e)}")
-
-    # Add model directory to Python path
+    
+    # Add to Python path
     if str(model_dir.absolute()) not in sys.path:
-        sys.path.append(str(model_dir.absolute()))
+        sys.path.insert(0, str(model_dir.absolute()))
 
-# Download files and setup path
-download_model_files()
-
-# Now import the model
-try:
-    from cognitive_net import DynamicCognitiveNet
-except ImportError as e:
-    print(f"Error importing model: {str(e)}")
-    raise
-
-class ModelDemo:
+# 2. Initialize Model ----------------------------------------------------
+class CognitiveDemo:
     def __init__(self):
-        self.net = DynamicCognitiveNet(input_size=5, output_size=1)
-        self.training_history = []
-        self.emotional_history = []
+        setup_model()
         
-    def train_sequence(self, sequence_str, epochs):
-        """Train model on input sequence and return visualizations"""
         try:
-            # Parse input sequence
-            sequence = [float(x.strip()) for x in sequence_str.split(',')]
-            if len(sequence) < 6:
-                return "Error: Please input at least 6 numbers", None, None
+            from cognitive_net import DynamicCognitiveNet
+            self.net = DynamicCognitiveNet(input_size=5, output_size=1)
+            self.net.optimizer = torch.optim.AdamW(self.net.parameters(), lr=0.001)
+        except ImportError as e:
+            raise RuntimeError(f"Gagal memuat model: {str(e)}")
+        
+        self.training_history = []
+
+    def _adapt_model(self, X: torch.Tensor, y: torch.Tensor):
+        """Penyesuaian dimensi tensor untuk arsitektur kognitif"""
+        X = X.view(-1, 1)  # Bentuk (seq_len, 1)
+        y = y.view(1)      # Bentuk (1,)
+        return X, y
+
+    def train(self, sequence: str, epochs: int):
+        try:
+            # Parse dan validasi input
+            nums = [float(n.strip()) for n in sequence.split(',')]
+            if len(nums) < 6:
+                raise ValueError("Input minimal 6 angka")
             
-            # Prepare training data
-            X = torch.tensor(sequence[:-1]).float()
-            y = torch.tensor([sequence[-1]]).float()
+            X = torch.tensor(nums[:-1])
+            y = torch.tensor([nums[-1]])
+            
+            # Adaptasi dimensi
+            X, y = self._adapt_model(X, y)
             
             # Training loop
             losses = []
-            emotions = []
-            for epoch in range(epochs):
+            for _ in range(epochs):
                 loss = self.net.train_step(X, y)
                 losses.append(loss)
-                emotions.append(self.net.emotional_state.item())
-            
-            # Create loss plot
-            loss_fig = go.Figure()
-            loss_fig.add_trace(go.Scatter(y=losses, name='Loss'))
-            loss_fig.update_layout(title='Training Loss', 
-                                 xaxis_title='Epoch',
-                                 yaxis_title='Loss')
-            
-            # Create emotion plot
-            emotion_fig = go.Figure()
-            emotion_fig.add_trace(go.Scatter(y=emotions, name='Emotional State'))
-            emotion_fig.update_layout(title='Emotional State', 
-                                    xaxis_title='Epoch',
-                                    yaxis_title='Value')
-            
-            # Make prediction
-            with torch.no_grad():
-                pred = self.net(X)
-                result = f"Prediction: {pred.item():.4f} (Target: {y.item():.4f})"
-            
-            return result, loss_fig, emotion_fig
+                
+            return {
+                "prediction": self.net(X).detach().numpy()[0],
+                "loss_plot": self._create_plot(losses, "Loss Training"),
+                "emotion": self.net.emotional_state.item()
+            }
             
         except Exception as e:
-            return f"Error: {str(e)}", None, None
-    
-    def visualize_memory(self):
-        """Visualize memory importance weights"""
-        memories = []
-        importances = []
-        
-        for mem in self.net.nodes['input_0'].memory.memory_queue:
-            memories.append(mem['context'].numpy())
-            importances.append(mem['importance'].item())
-            
-        if not memories:
-            return "No memories stored yet"
-            
+            return {"error": str(e)}
+
+    def _create_plot(self, data, title):
         fig = go.Figure()
-        fig.add_trace(go.Bar(y=importances))
-        fig.update_layout(title='Memory Importance',
-                         xaxis_title='Memory Index',
-                         yaxis_title='Importance')
+        fig.add_trace(go.Scatter(y=data, mode='lines'))
+        fig.update_layout(title=title)
         return fig
 
-# Initialize demo
-demo = ModelDemo()
+# 3. Gradio Interface ----------------------------------------------------
+demo = CognitiveDemo()
 
-# Create Gradio interface
-with gr.Blocks(title="Cognitive Network Demo") as iface:
-    gr.Markdown("""
-    # Cognitive Network Interactive Demo
-    
-    This demo shows a neural network with:
-    - Dynamic memories
-    - Emotional modulation
-    - Adaptive structure
-    
-    Enter a sequence of numbers (comma-separated) to train the model to predict the next number.
-    
-    Model: [VLabTech/cognitive_net](https://huggingface.co/VLabTech/cognitive_net)
-    """)
+with gr.Blocks(title="Cognitive Network Demo") as app:
+    gr.Markdown("""## Demo Jaringan Kognitif VLabTech""")
     
     with gr.Row():
-        with gr.Column():
-            input_seq = gr.Textbox(label="Input Sequence (comma-separated)", 
-                                 value="1, 2, 3, 4, 5, 6")
-            epochs = gr.Slider(minimum=10, maximum=500, value=100, 
-                             step=10, label="Training Epochs")
-            train_btn = gr.Button("Train Model")
-        
-        result_text = gr.Textbox(label="Prediction Result")
+        input_seq = gr.Textbox(label="Deret Input (contoh: 0.1, 0.5, 1.0,...)", 
+                             value="0.1, 0.3, 0.5, 0.7, 0.9, 1.1")
+        epochs = gr.Slider(10, 500, value=100, label="Jumlah Epoch")
     
     with gr.Row():
-        loss_plot = gr.Plot(label="Training Loss")
-        emotion_plot = gr.Plot(label="Emotional State")
+        train_btn = gr.Button("🚀 Latih Model")
+        pred_output = gr.Label(label="Hasil Prediksi")
+        emotion_output = gr.Number(label="Status Emosional")
     
-    with gr.Row():
-        memory_btn = gr.Button("Visualize Memory")
-        memory_plot = gr.Plot(label="Memory Importance")
+    loss_plot = gr.Plot(label="Progress Training")
     
-    # Connect components
     train_btn.click(
-        fn=demo.train_sequence,
+        fn=lambda s, e: demo.train(s, e),
         inputs=[input_seq, epochs],
-        outputs=[result_text, loss_plot, emotion_plot]
-    )
-    
-    memory_btn.click(
-        fn=demo.visualize_memory,
-        inputs=None,
-        outputs=memory_plot
+        outputs=[pred_output, loss_plot, emotion_output]
     )
 
-# Launch app
-iface.launch()
+# 4. Run App -------------------------------------------------------------
+if __name__ == "__main__":
+    app.launch(debug=True)