Update app.py

app.py

@@ -2,119 +2,145 @@ import gradio as gr
 import torch
 import numpy as np
 import plotly.graph_objects as go
-from huggingface_hub import hf_hub_download
-import sys
-import os
+from huggingface_hub import snapshot_download
 from pathlib import Path
+import sys
 
-# 1. Download Model Files ------------------------------------------------
+# 1. Setup Model dari Hugging Face Hub ----------------------------
 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"
-    ]
-    
-    # Create package directory
-    model_dir = Path("cognitive_net")
-    model_dir.mkdir(exist_ok=True)
+    LOCAL_DIR = "cognitive_net_pkg"
     
-    # Download files
-    for file in FILE_LIST:
-        try:
-            downloaded_file = hf_hub_download(
-                repo_id=REPO_ID,
-                filename=file,
-                local_dir=model_dir.parent,
-                force_filename=file
-            )
-        except Exception as e:
-            print(f"Error downloading {file}: {str(e)}")
+    # Download repo
+    snapshot_download(
+        repo_id=REPO_ID,
+        local_dir=LOCAL_DIR,
+        allow_patterns=["*.py", "*.txt"],
+        repo_type="model",
+        local_dir_use_symlinks=False
+    )
     
-    # Add to Python path
-    if str(model_dir.absolute()) not in sys.path:
-        sys.path.insert(0, str(model_dir.absolute()))
+    # Tambahkan ke path Python
+    sys.path.insert(0, str(Path(LOCAL_DIR).absolute()))
 
-# 2. Initialize Model ----------------------------------------------------
-class CognitiveDemo:
-    def __init__(self):
-        setup_model()
-        
-        try:
-            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 = []
+setup_model()
 
-    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
+# 2. Implementasi Model --------------------------------------------
+from cognitive_net.network import DynamicCognitiveNet
 
-    def train(self, sequence: str, epochs: int):
+class CognitiveDemo:
+    def __init__(self):
+        self.net = DynamicCognitiveNet(input_size=5, output_size=1)
+        self.training_loss = []
+        self.emotion_states = []
+    
+    def _parse_input(self, sequence_str):
+        """Konversi string input ke tensor"""
+        sequence = [float(x.strip()) for x in sequence_str.split(',')]
+        if len(sequence) < 6:
+            raise ValueError("Input minimal 6 angka")
+        return (
+            torch.tensor(sequence[:-1]).float(),
+            torch.tensor([sequence[-1]]).float()
+        )
+    
+    def train(self, sequence_str, epochs):
         try:
-            # Parse dan validasi input
-            nums = [float(n.strip()) for n in sequence.split(',')]
-            if len(nums) < 6:
-                raise ValueError("Input minimal 6 angka")
-            
-            X = torch.tensor(nums[:-1])
-            y = torch.tensor([nums[-1]])
-            
-            # Adaptasi dimensi
-            X, y = self._adapt_model(X, y)
+            X, y = self._parse_input(sequence_str)
             
             # Training loop
-            losses = []
+            self.training_loss = []
+            self.emotion_states = []
+            
             for _ in range(epochs):
                 loss = self.net.train_step(X, y)
-                losses.append(loss)
-                
+                self.training_loss.append(loss)
+                self.emotion_states.append(self.net.emotional_state.item())
+            
+            # Prediksi akhir
+            with torch.no_grad():
+                pred = self.net(X)
+            
             return {
-                "prediction": self.net(X).detach().numpy()[0],
-                "loss_plot": self._create_plot(losses, "Loss Training"),
-                "emotion": self.net.emotional_state.item()
+                "prediction": f"{pred.item():.4f}",
+                "loss_plot": self._create_loss_plot(),
+                "emotion_plot": self._create_emotion_plot()
             }
-            
         except Exception as e:
             return {"error": str(e)}
-
-    def _create_plot(self, data, title):
+    
+    def _create_loss_plot(self):
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(
+            y=self.training_loss,
+            mode='lines+markers',
+            name='Loss'
+        ))
+        fig.update_layout(
+            title='Training Loss',
+            xaxis_title='Epoch',
+            yaxis_title='Loss Value'
+        )
+        return fig
+    
+    def _create_emotion_plot(self):
         fig = go.Figure()
-        fig.add_trace(go.Scatter(y=data, mode='lines'))
-        fig.update_layout(title=title)
+        fig.add_trace(go.Scatter(
+            y=self.emotion_states,
+            mode='lines',
+            name='Emotional State',
+            line=dict(color='#FF6F61')
+        ))
+        fig.update_layout(
+            title='Emotional State Dynamics',
+            xaxis_title='Epoch',
+            yaxis_title='State Value'
+        )
         return fig
 
-# 3. Gradio Interface ----------------------------------------------------
+# 3. Antarmuka Gradio ----------------------------------------------
 demo = CognitiveDemo()
 
-with gr.Blocks(title="Cognitive Network Demo") as app:
-    gr.Markdown("""## Demo Jaringan Kognitif VLabTech""")
-    
-    with gr.Row():
-        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.Blocks(theme=gr.themes.Soft(), title="Cognitive Network Demo") as app:
+    gr.Markdown("# 🧠 Cognitive Network Demo")
+    gr.Markdown("""
+    **Demonstrasi Jaringan Saraf Kognitif dengan:**
+    - Memori Adaptif
+    - Plastisitas Struktural
+    - Modulasi Emosional
+    """)
     
     with gr.Row():
-        train_btn = gr.Button("🚀 Latih Model")
-        pred_output = gr.Label(label="Hasil Prediksi")
-        emotion_output = gr.Number(label="Status Emosional")
+        with gr.Column():
+            input_seq = gr.Textbox(
+                label="Deret Input (contoh: 0.1, 0.3, 0.5, 0.7, 0.9, 1.1)",
+                value="0.1, 0.3, 0.5, 0.7, 0.9, 1.1"
+            )
+            epochs = gr.Slider(10, 500, value=100, label="Jumlah Epoch")
+            train_btn = gr.Button("🚀 Latih Model", variant="primary")
+        
+        with gr.Column():
+            output_pred = gr.Label(label="Prediksi")
+            loss_plot = gr.Plot(label="Progress Training")
+            emotion_plot = gr.Plot(label="Dinamika Emosional")
     
-    loss_plot = gr.Plot(label="Progress Training")
+    # Contoh data preset
+    gr.Examples(
+        examples=[
+            ["1, 2, 3, 4, 5, 6", 100],
+            ["0.5, 1.0, 1.5, 2.0, 2.5, 3.0", 150],
+            ["10, 8, 6, 4, 2, 0", 200]
+        ],
+        inputs=[input_seq, epochs],
+        label="Contoh Input"
+    )
     
     train_btn.click(
-        fn=lambda s, e: demo.train(s, e),
+        fn=demo.train,
         inputs=[input_seq, epochs],
-        outputs=[pred_output, loss_plot, emotion_output]
+        outputs=[output_pred, loss_plot, emotion_plot]
     )
 
-# 4. Run App -------------------------------------------------------------
+# 4. Jalankan Aplikasi ---------------------------------------------
 if __name__ == "__main__":
     app.launch(debug=True)