Upload app.py with huggingface_hub

app.py

@@ -0,0 +1,502 @@
+import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+from matplotlib.animation import FuncAnimation
+import networkx as nx
+import time
+import random
+import json
+from datetime import datetime
+import threading
+import queue
+
+class Neuron:
+    def __init__(self, neuron_id, x, y, z=0):
+        self.id = neuron_id
+        self.x = x
+        self.y = y
+        self.z = z
+        self.activation = random.random() * 0.1
+        self.specialization = random.choice([
+            "visual", "semantic", "temporal", "spatial", "abstract", 
+            "linguistic", "logical", "creative", "memory", "learning"
+        ])
+        self.knowledge = set()
+        self.connections = []
+        self.quantum_state = [random.random() for _ in range(4)]
+        self.learning_rate = 0.1 + random.random() * 0.9
+        self.age = 0
+        self.experience = 0
+        self.fitness = 0
+        self.energy = random.random()
+        self.bias = random.uniform(-0.1, 0.1)
+        self.weights = {}
+        self.memory = []
+
+class AdvancedNeuralNetwork:
+    def __init__(self):
+        self.neurons = []
+        self.connections = []
+        self.metrics = {
+            'loss': 1.0,
+            'efficiency': 0,
+            'convergence': 0,
+            'global_fitness': 0,
+            'learning_rate': 0.1,
+            'knowledge_growth': 0,
+            'reasoning_capability': 0
+        }
+        self.specializations = [
+            "visual", "semantic", "temporal", "spatial", "abstract",
+            "linguistic", "logical", "creative", "memory", "learning"
+        ]
+        self.initialize_network()
+        
+    def initialize_network(self, num_neurons=30):
+        """Inicializar la red neuronal con neuronas distribuidas"""
+        self.neurons = []
+        self.connections = []
+        
+        # Crear neuronas especializadas
+        for i in range(num_neurons):
+            x = random.uniform(0.1, 0.9)
+            y = random.uniform(0.1, 0.9)
+            neuron = Neuron(i, x, y)
+            self.neurons.append(neuron)
+        
+        # Crear conexiones iniciales
+        self.create_initial_connections()
+    
+    def create_initial_connections(self):
+        """Crear conexiones iniciales entre neuronas"""
+        for i, neuron1 in enumerate(self.neurons):
+            for j, neuron2 in enumerate(self.neurons[i+1:], i+1):
+                distance = self.calculate_distance(neuron1, neuron2)
+                if distance < 0.3 and random.random() < 0.3:
+                    weight = random.random()
+                    neuron1.connections.append(j)
+                    neuron2.connections.append(i)
+                    neuron1.weights[j] = weight
+                    neuron2.weights[i] = weight
+                    self.connections.append({'from': i, 'to': j, 'weight': weight})
+    
+    def calculate_distance(self, neuron1, neuron2):
+        """Calcular distancia euclidiana entre dos neuronas"""
+        dx = neuron1.x - neuron2.x
+        dy = neuron1.y - neuron2.y
+        dz = neuron1.z - neuron2.z
+        return np.sqrt(dx*dx + dy*dy + dz*dz)
+    
+    def sigmoid(self, x):
+        """Función de activación sigmoid"""
+        return 1 / (1 + np.exp(-np.clip(x, -500, 500)))
+    
+    def step(self):
+        """Ejecutar un paso de la simulación"""
+        # Actualizar activaciones
+        new_activations = []
+        
+        for j, neuron in enumerate(self.neurons):
+            input_sum = 0
+            for i, source_neuron in enumerate(self.neurons):
+                if i == j:
+                    continue
+                weight = source_neuron.weights.get(j, 0)
+                distance = self.calculate_distance(source_neuron, neuron)
+                attenuation = 1 / (1 + distance * 5)
+                input_sum += source_neuron.activation * weight * attenuation
+            
+            # Influencia cuántica
+            quantum_influence = (neuron.quantum_state[0] - 0.5) * 0.8
+            new_activation = self.sigmoid(input_sum + neuron.bias + quantum_influence)
+            new_activations.append(new_activation)
+        
+        # Aplicar nuevas activaciones con decay
+        for i, neuron in enumerate(self.neurons):
+            neuron.activation = new_activations[i] * 0.96
+            neuron.energy = neuron.activation
+            neuron.age += 0.01
+            neuron.experience += neuron.activation * 0.1
+            
+            # Actualizar estado cuántico
+            for j in range(4):
+                neuron.quantum_state[j] = np.sin(time.time() * 0.001 + j) * neuron.activation
+        
+        # Aprendizaje hebbiano
+        self.hebbian_learning()
+        
+        # Actualizar métricas
+        self.update_metrics()
+    
+    def hebbian_learning(self):
+        """Aplicar aprendizaje hebbiano"""
+        learning_rate = self.metrics['learning_rate'] * 0.01
+        
+        for neuron in self.neurons:
+            for connected_id in neuron.connections:
+                if connected_id < len(self.neurons):
+                    connected_neuron = self.neurons[connected_id]
+                    delta = learning_rate * neuron.activation * connected_neuron.activation
+                    current_weight = neuron.weights.get(connected_id, 0)
+                    neuron.weights[connected_id] = max(0, min(4, current_weight * 0.999 + delta))
+    
+    def update_metrics(self):
+        """Actualizar métricas de la red"""
+        active_neurons = sum(1 for n in self.neurons if n.activation > 0.1)
+        total_knowledge = sum(len(n.knowledge) for n in self.neurons)
+        total_energy = sum(n.activation for n in self.neurons)
+        max_energy = len(self.neurons)
+        
+        self.metrics['efficiency'] = active_neurons / len(self.neurons) if self.neurons else 0
+        self.metrics['knowledge_growth'] = total_knowledge
+        self.metrics['global_fitness'] = total_energy / max_energy if max_energy > 0 else 0
+        self.metrics['convergence'] = min(self.metrics['efficiency'] * self.metrics['global_fitness'], 1)
+        self.metrics['reasoning_capability'] = len([n for n in self.neurons 
+                                                  if n.specialization == "logical" and n.activation > 0.3]) / 10
+    
+    def add_neuron(self):
+        """Añadir una nueva neurona a la red"""
+        new_id = len(self.neurons)
+        x = random.uniform(0.1, 0.9)
+        y = random.uniform(0.1, 0.9)
+        new_neuron = Neuron(new_id, x, y)
+        
+        # Conectar con neuronas cercanas
+        for existing_neuron in self.neurons:
+            distance = self.calculate_distance(new_neuron, existing_neuron)
+            if distance < 0.3:
+                weight = np.exp(-distance / 0.4) * (0.5 + random.random() * 0.9)
+                new_neuron.weights[existing_neuron.id] = weight
+                existing_neuron.weights[new_id] = weight
+                new_neuron.connections.append(existing_neuron.id)
+                existing_neuron.connections.append(new_id)
+        
+        self.neurons.append(new_neuron)
+    
+    def remove_neuron(self):
+        """Eliminar una neurona de la red"""
+        if len(self.neurons) <= 5:
+            return
+        
+        removed = self.neurons.pop()
+        # Limpiar conexiones
+        for neuron in self.neurons:
+            if removed.id in neuron.weights:
+                del neuron.weights[removed.id]
+            if removed.id in neuron.connections:
+                neuron.connections.remove(removed.id)
+        
+        # Actualizar conexiones
+        self.connections = [conn for conn in self.connections 
+                          if conn['from'] != removed.id and conn['to'] != removed.id]
+    
+    def teach_concept(self, concept):
+        """Enseñar un concepto a la red"""
+        learning_neurons = [n for n in self.neurons if n.specialization == "learning"]
+        if learning_neurons:
+            best_learner = max(learning_neurons, key=lambda n: n.activation)
+            best_learner.knowledge.add(concept)
+            best_learner.activation += 0.5
+            best_learner.memory.append({
+                'pattern': concept,
+                'timestamp': time.time(),
+                'strength': 1.0
+            })
+            
+            # Propagar conocimiento
+            for connected_id in best_learner.connections:
+                if connected_id < len(self.neurons) and random.random() < 0.3:
+                    connected_neuron = self.neurons[connected_id]
+                    connected_neuron.knowledge.add(concept)
+                    connected_neuron.activation += 0.2
+    
+    def reset(self):
+        """Reiniciar la red neuronal"""
+        self.initialize_network()
+
+# Instancia global de la red neuronal
+global_network = AdvancedNeuralNetwork()
+
+def create_network_visualization():
+    """Crear visualización de la red neuronal"""
+    fig, ax = plt.subplots(figsize=(12, 8))
+    ax.set_xlim(0, 1)
+    ax.set_ylim(0, 1)
+    ax.set_aspect('equal')
+    ax.set_facecolor('#0f172a')
+    fig.patch.set_facecolor('#0f172a')
+    
+    # Colores por especialización
+    colors = {
+        'visual': '#ef4444', 'semantic': '#22c55e', 'temporal': '#3b82f6',
+        'spatial': '#eab308', 'abstract': '#a855f7', 'linguistic': '#06b6d4',
+        'logical': '#f97316', 'creative': '#84cc16', 'memory': '#f59e0b',
+        'learning': '#ec4899'
+    }
+    
+    # Dibujar conexiones
+    for conn in global_network.connections:
+        from_neuron = global_network.neurons[conn['from']]
+        to_neuron = global_network.neurons[conn['to']]
+        ax.plot([from_neuron.x, to_neuron.x], [from_neuron.y, to_neuron.y], 
+                'b-', alpha=0.3, linewidth=0.5)
+    
+    # Dibujar neuronas
+    for neuron in global_network.neurons:
+        size = 50 + neuron.activation * 300
+        color = colors.get(neuron.specialization, '#ffffff')
+        alpha = 0.3 + neuron.activation * 0.7
+        
+        circle = plt.Circle((neuron.x, neuron.y), 0.02, 
+                          color=color, alpha=alpha, zorder=10)
+        ax.add_patch(circle)
+        
+        # Mostrar ID para neuronas muy activas
+        if neuron.activation > 0.7:
+            ax.text(neuron.x, neuron.y + 0.03, str(neuron.id), 
+                   ha='center', va='bottom', color='white', fontsize=8)
+        
+        # Efecto de conocimiento
+        if neuron.knowledge:
+            knowledge_circle = plt.Circle((neuron.x, neuron.y), 0.025, 
+                                        fill=False, edgecolor='#22c55e', 
+                                        linewidth=2, alpha=0.6, zorder=11)
+            ax.add_patch(knowledge_circle)
+    
+    ax.set_title('Red Neuronal IA Avanzada - Visualización en Tiempo Real', 
+                color='white', fontsize=16, pad=20)
+    ax.set_xlabel('')
+    ax.set_ylabel('')
+    ax.tick_params(colors='white')
+    
+    # Leyenda
+    legend_elements = []
+    for spec, color in colors.items():
+        legend_elements.append(plt.Line2D([0], [0], marker='o', color='w', 
+                                        markerfacecolor=color, markersize=8, 
+                                        label=spec.capitalize()))
+    
+    ax.legend(handles=legend_elements, loc='upper left', bbox_to_anchor=(1, 1),
+             facecolor='#1e293b', edgecolor='#475569', labelcolor='white')
+    
+    plt.tight_layout()
+    return fig
+
+def step_simulation():
+    """Ejecutar un paso de la simulación"""
+    global_network.step()
+    return create_network_visualization(), get_metrics_display()
+
+def get_metrics_display():
+    """Obtener display de métricas"""
+    metrics = global_network.metrics
+    return f"""
+    ## 📊 Métricas de la Red Neuronal
+    
+    - **Eficiencia**: {metrics['efficiency']:.1%}
+    - **Convergencia**: {metrics['convergence']:.1%}
+    - **Fitness Global**: {metrics['global_fitness']:.1%}
+    - **Neuronas**: {len(global_network.neurons)}
+    - **Conexiones**: {len(global_network.connections)}
+    - **Conocimiento Total**: {metrics['knowledge_growth']}
+    - **Capacidad de Razonamiento**: {metrics['reasoning_capability']:.1%}
+    """
+
+def teach_concept_to_network(concept):
+    """Enseñar concepto a la red"""
+    if concept.strip():
+        global_network.teach_concept(concept.strip())
+        return (create_network_visualization(), 
+                get_metrics_display(),
+                f"✅ Concepto '{concept}' enseñado exitosamente a la red",
+                "")
+    return create_network_visualization(), get_metrics_display(), "❌ Por favor ingresa un concepto válido", concept
+
+def add_neuron_to_network():
+    """Añadir neurona a la red"""
+    global_network.add_neuron()
+    return create_network_visualization(), get_metrics_display(), "➕ Nueva neurona añadida"
+
+def remove_neuron_from_network():
+    """Remover neurona de la red"""
+    global_network.remove_neuron()
+    return create_network_visualization(), get_metrics_display(), "➖ Neurona eliminada"
+
+def reset_network():
+    """Reiniciar la red"""
+    global_network.reset()
+    return create_network_visualization(), get_metrics_display(), "🔄 Red neuronal reiniciada"
+
+def auto_simulation_steps():
+    """Ejecutar múltiples pasos automáticamente"""
+    for _ in range(5):
+        global_network.step()
+        time.sleep(0.1)
+    return create_network_visualization(), get_metrics_display()
+
+# Crear la interfaz Gradio
+def create_gradio_interface():
+    with gr.Blocks(
+        theme=gr.themes.Soft(
+            primary_hue="blue",
+            secondary_hue="slate",
+            neutral_hue="slate",
+        ).set(
+            body_background_fill="#0f172a",
+            block_background_fill="#1e293b",
+            block_border_color="#475569",
+            input_background_fill="#334155",
+            button_primary_background_fill="#3b82f6",
+            button_primary_text_color="white",
+        ),
+        css="""
+        .gradio-container {
+            background: linear-gradient(135deg, #0f172a 0%, #1e3a8a 50%, #0f172a 100%);
+            min-height: 100vh;
+        }
+        .gr-button {
+            border-radius: 8px;
+            font-weight: 600;
+        }
+        .gr-panel {
+            border-radius: 12px;
+            border: 1px solid #475569;
+        }
+        """,
+        title="🧠 NEBULA - Red Neuronal IA Avanzada"
+    ) as iface:
+        
+        gr.HTML("""
+        <div style="text-align: center; padding: 20px;">
+            <h1 style="color: white; font-size: 3rem; margin-bottom: 10px;">
+                🧠 NEBULA - Red Neuronal IA Avanzada ⚡
+            </h1>
+            <p style="color: #cbd5e1; font-size: 1.2rem;">
+                Simulación interactiva con aprendizaje automático y supervisión por IA
+            </p>
+            <p style="color: #94a3b8; font-size: 1rem; margin-top: 10px;">
+                Una demostración avanzada de redes neuronales con especialización funcional y aprendizaje adaptativo
+            </p>
+        </div>
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                plot_output = gr.Plot(
+                    value=create_network_visualization(),
+                    label="🌐 Visualización de Red Neuronal",
+                    show_label=True
+                )
+                
+                with gr.Row():
+                    step_btn = gr.Button("🔄 Paso Manual", variant="primary")
+                    auto_btn = gr.Button("⚡ 5 Pasos Auto", variant="secondary")
+                    reset_btn = gr.Button("🔄 Reiniciar", variant="stop")
+                
+                with gr.Row():
+                    add_neuron_btn = gr.Button("➕ Añadir Neurona")
+                    remove_neuron_btn = gr.Button("➖ Remover Neurona")
+            
+            with gr.Column(scale=1):
+                metrics_display = gr.Markdown(
+                    value=get_metrics_display(),
+                    label="📊 Métricas en Tiempo Real"
+                )
+                
+                with gr.Group():
+                    gr.HTML("<h3 style='color: white; text-align: center;'>📚 Enseñanza Manual</h3>")
+                    concept_input = gr.Textbox(
+                        placeholder="Enseña un concepto a la red...",
+                        label="💡 Concepto",
+                        lines=2
+                    )
+                    teach_btn = gr.Button("🎯 Enseñar Concepto", variant="primary")
+                    status_output = gr.Textbox(
+                        label="Estado",
+                        interactive=False,
+                        lines=2
+                    )
+        
+        # Información adicional
+        with gr.Row():
+            with gr.Column():
+                gr.HTML("""
+                <div style="background: #1e293b; padding: 20px; border-radius: 12px; margin-top: 20px; border: 1px solid #475569;">
+                    <h3 style="color: white; margin-bottom: 15px;">🔬 Especializaciones Neuronales</h3>
+                    <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 10px;">
+                        <div style="color: #ef4444;">🔴 Visual - Procesamiento visual</div>
+                        <div style="color: #22c55e;">🟢 Semántica - Significado y conceptos</div>
+                        <div style="color: #3b82f6;">🔵 Temporal - Secuencias temporales</div>
+                        <div style="color: #eab308;">🟡 Espacial - Relaciones espaciales</div>
+                        <div style="color: #a855f7;">🟣 Abstracta - Pensamiento abstracto</div>
+                        <div style="color: #06b6d4;">🔷 Lingüística - Procesamiento de lenguaje</div>
+                        <div style="color: #f97316;">🟠 Lógica - Razonamiento lógico</div>
+                        <div style="color: #84cc16;">🟢 Creativa - Generación creativa</div>
+                        <div style="color: #f59e0b;">🟨 Memoria - Almacenamiento</div>
+                        <div style="color: #ec4899;">🟡 Aprendizaje - Adquisición de conocimiento</div>
+                    </div>
+                </div>
+                """)
+        
+        # Event handlers
+        step_btn.click(
+            step_simulation,
+            outputs=[plot_output, metrics_display]
+        )
+        
+        auto_btn.click(
+            auto_simulation_steps,
+            outputs=[plot_output, metrics_display]
+        )
+        
+        teach_btn.click(
+            teach_concept_to_network,
+            inputs=[concept_input],
+            outputs=[plot_output, metrics_display, status_output, concept_input]
+        )
+        
+        concept_input.submit(
+            teach_concept_to_network,
+            inputs=[concept_input],
+            outputs=[plot_output, metrics_display, status_output, concept_input]
+        )
+        
+        add_neuron_btn.click(
+            add_neuron_to_network,
+            outputs=[plot_output, metrics_display, status_output]
+        )
+        
+        remove_neuron_btn.click(
+            remove_neuron_from_network,
+            outputs=[plot_output, metrics_display, status_output]
+        )
+        
+        reset_btn.click(
+            reset_network,
+            outputs=[plot_output, metrics_display, status_output]
+        )
+        
+        # Footer
+        gr.HTML("""
+        <div style="text-align: center; padding: 20px; margin-top: 30px; border-top: 1px solid #475569;">
+            <p style="color: #94a3b8;">
+                🚀 Desarrollado por <strong>Agnuxo</strong> | 
+                💡 Simulación avanzada de redes neuronales con IA supervisada
+            </p>
+            <p style="color: #64748b; font-size: 0.9rem;">
+                Esta demostración muestra conceptos de neurociencia computacional, 
+                aprendizaje automático y sistemas adaptativos complejos.
+            </p>
+        </div>
+        """)
+    
+    return iface
+
+if __name__ == "__main__":
+    iface = create_gradio_interface()
+    iface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )