Update app.py

app.py

@@ -1,146 +1,93 @@
-import gradio as gr
+# app.py
+import os
 import torch
-import numpy as np
-import plotly.graph_objects as go
-from huggingface_hub import snapshot_download
-from pathlib import Path
-import sys
-
-# 1. Setup Model dari Hugging Face Hub ----------------------------
-def setup_model():
-    REPO_ID = "VLabTech/cognitive_net"
-    LOCAL_DIR = "cognitive_net_pkg"
-    
-    # Download repo
-    snapshot_download(
-        repo_id=REPO_ID,
-        local_dir=LOCAL_DIR,
-        allow_patterns=["*.py", "*.txt"],
-        repo_type="model",
-        local_dir_use_symlinks=False
-    )
-    
-    # Tambahkan ke path Python
-    sys.path.insert(0, str(Path(LOCAL_DIR).absolute()))
-
-setup_model()
-
-# 2. Implementasi Model --------------------------------------------
-from cognitive_net.network import DynamicCognitiveNet
+import gradio as gr
+from huggingface_hub import hf_hub_download
+from cognitive_net import DynamicCognitiveNet, CognitiveMemory, CognitiveNode
 
-class CognitiveDemo:
+class ModelInterface:
     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):
+        self.model = self.load_model()
+        
+    def load_model(self):
+        """Load model dari HuggingFace Hub"""
         try:
-            X, y = self._parse_input(sequence_str)
+            # Inisialisasi model
+            model = DynamicCognitiveNet(input_size=5, output_size=2)
             
-            # Training loop
-            self.training_loss = []
-            self.emotion_states = []
+            # Download checkpoint
+            checkpoint_path = hf_hub_download(
+                repo_id="VLabTech/cognitive_net",
+                filename="model.pt"
+            )
             
-            for _ in range(epochs):
-                loss = self.net.train_step(X, y)
-                self.training_loss.append(loss)
-                self.emotion_states.append(self.net.emotional_state.item())
+            # Load weights
+            model.load_state_dict(torch.load(checkpoint_path))
+            model.eval()
+            return model
+        except Exception as e:
+            print(f"Error loading model: {e}")
+            return None
+
+    def predict(self, input_text):
+        """Proses input dan generate prediksi"""
+        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."
             
-            # Prediksi akhir
+            # Convert ke tensor
+            input_tensor = torch.tensor(values, dtype=torch.float32)
+            
+            # Generate prediksi
             with torch.no_grad():
-                pred = self.net(X)
+                output = self.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}"
             
-            return {
-                "prediction": f"{pred.item():.4f}",
-                "loss_plot": self._create_loss_plot(),
-                "emotion_plot": self._create_emotion_plot()
-            }
+            return result
+            
+        except ValueError:
+            return "Error: Pastikan semua input adalah angka valid"
         except Exception as e:
-            return {"error": str(e)}
-    
-    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=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
+            return f"Error: {str(e)}"
 
-# 3. Antarmuka Gradio ----------------------------------------------
-demo = CognitiveDemo()
+# Inisialisasi interface
+model_interface = ModelInterface()
 
-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
-    """)
+# Setup Gradio Interface
+demo = gr.Interface(
+    fn=model_interface.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
     
-    with gr.Row():
-        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")
+    Model ini menerima 5 input numerik dan menghasilkan 2 output numerik.
     
-    # 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"
-    )
+    ### Cara Penggunaan:
+    1. Masukkan 5 angka yang dipisahkan dengan koma
+    2. Klik Submit untuk melihat hasil prediksi
     
-    train_btn.click(
-        fn=demo.train,
-        inputs=[input_seq, epochs],
-        outputs=[output_pred, loss_plot, emotion_plot]
-    )
+    ### Format Input:
+    - Masukkan tepat 5 nilai numerik
+    - Pisahkan nilai dengan koma
+    - Gunakan titik untuk desimal
+    """,
+    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"]
+    ]
+)
 
-# 4. Jalankan Aplikasi ---------------------------------------------
 if __name__ == "__main__":
-    app.launch(debug=True)
+    demo.launch()