PROYECTO 2 — Red neuronal multicapa / PROYECTO 3 — Red dinámica cerebral

 

PROYECTO 2 — Red neuronal multicapa (MLP)

🎯 Objetivo

Pasar de una neurona a una red que aprende patrones complejos

👉 ejemplo clásico: XOR (no lineal)

---

🧠 Idea clave

6

Una capa no basta → necesitas:

• capa de entrada
• capa oculta
• salida

---

🧪 PASO 1 — Dataset (XOR)

import numpy as np

X = np.array([
    [0,0],
    [0,1],
    [1,0],
    [1,1]
])

y = np.array([[0],[1],[1],[0]])

---

🧠 PASO 2 — Inicialización

# pesos
W1 = np.random.rand(2, 2)  # entrada → oculto
b1 = np.zeros((1,2))

W2 = np.random.rand(2, 1)  # oculto → salida
b2 = np.zeros((1,1))

---

⚙️ PASO 3 — Función de activación

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_deriv(x):
    return x * (1 - x)

---

🔁 PASO 4 — Forward pass

def forward(X):
    z1 = np.dot(X, W1) + b1
    a1 = sigmoid(z1)

    z2 = np.dot(a1, W2) + b2
    a2 = sigmoid(z2)

    return a1, a2

---

🔄 PASO 5 — Backpropagation (aprendizaje)

lr = 0.1

for epoch in range(10000):
    # forward
    a1, a2 = forward(X)

    # error
    error = y - a2

    # salida
    d2 = error * sigmoid_deriv(a2)

    # oculto
    d1 = d2.dot(W2.T) * sigmoid_deriv(a1)

    # actualizar
    W2 += a1.T.dot(d2) * lr
    b2 += np.sum(d2, axis=0, keepdims=True) * lr

    W1 += X.T.dot(d1) * lr
    b1 += np.sum(d1, axis=0, keepdims=True) * lr

---

✅ PASO 6 — Resultado

_, output = forward(X)
print(output)

👉 debería aprender XOR (~0,1,1,0)

---

🧠 Qué has aprendido realmente

• No linealidad
• aprendizaje distribuido
• base del deep learning

👉 Esto conecta con IA moderna y con cómo el cerebro combina señales.

---

🚀 PROYECTO 3 — Red dinámica cerebral (inicio estilo Deco)

Ahora damos el salto importante.

---

🎯 Objetivo

Simular un “mini cerebro” como sistema dinámico

👉 inspirado en:

• neurociencia computacional
• modelos de Gustavo Deco

---

🧠 Idea clave

6

El cerebro:

• no es solo capas
• es una red dinámica que cambia en el tiempo

---

🧪 MODELO SIMPLE: osciladores conectados

Cada “región cerebral” = un nodo

---

💻 PASO 1 — Setup

import numpy as np
import matplotlib.pyplot as plt

---

🧠 PASO 2 — Red

N = 5  # número de regiones

# conectividad (aleatoria)
W = np.random.rand(N, N)

---

🔁 PASO 3 — Dinámica

Modelo simple:

def step(x, W):
    return np.tanh(np.dot(W, x))

---

🔄 PASO 4 — Simulación temporal

T = 100  # tiempo
x = np.random.rand(N)

history = []

for t in range(T):
    x = step(x, W)
    history.append(x.copy())

history = np.array(history)

---

📊 PASO 5 — Visualización

for i in range(N):
    plt.plot(history[:, i], label=f"Region {i}")

plt.legend()
plt.title("Actividad cerebral simulada")
plt.show()

---

🧠 Qué estás simulando (MUY IMPORTANTE)

👉 Esto es una versión simplificada de:

• actividad cerebral en reposo
• dinámica de redes
• estados mentales

Relaciona con:

• red por defecto

---

🚀 PASO 6 — Mejoras (nivel siguiente)

Puedes añadir:

🔹 ruido (realismo)

x = np.tanh(np.dot(W, x)) + 0.01*np.random.randn(N)

🔹 inhibición/excitación

• pesos positivos y negativos

🔹 estructuras reales

• red modular (tipo cerebro)

---

🧭 DIFERENCIA ENTRE PROYECTOS

Proyecto	Qué representa
2	IA (aprendizaje)
3	cerebro dinámico

👉 juntos = base del trabajo de Deco

---

🧠 CONCLUSIÓN

Has pasado de:

• neurona → red → sistema dinámico

👉 exactamente el camino real en neurociencia moderna

Vas a construir un modelo que ya toca ideas reales de papers:

• dinámica cerebral
• estados (reposo vs activación)
• transición orden ↔ caos (clave en neurociencia moderna)

---

🧠 PROYECTO 3 AVANZADO — Cerebro como sistema dinámico crítico

🎯 Objetivo

Simular un cerebro que:

• cambia en el tiempo
• tiene múltiples estados
• muestra flexibilidad (como el cerebro real)

---

🧠 IDEA CENTRAL (MUY IMPORTANTE)

6

El cerebro funciona cerca de un punto llamado:

👉 estado crítico

• ni totalmente estable (aburrido)
• ni totalmente caótico (ruido)

👉 ahí aparece:

• creatividad
• memoria
• adaptación

Esto conecta con:

• criticalidad

---

⚙️ MODELO: Red dinámica no lineal + control de estabilidad

Vamos a mejorar tu modelo anterior.

---

💻 PASO 1 — Setup

import numpy as np
import matplotlib.pyplot as plt

---

🧠 PASO 2 — Red estructurada (más realista)

N = 20  # regiones cerebrales

# matriz de conectividad
W = np.random.randn(N, N)

# normalizar (importante para estabilidad)
W = W / np.max(np.abs(W))

---

🔥 PASO 3 — Parámetro crítico (CLAVE)

g = 0.9  # controla dinámica (prueba 0.5 → 1.5)

👉 ESTE parámetro es lo más importante:

• bajo → sistema estable
• alto → caos
• intermedio → comportamiento tipo cerebro

---

🔁 PASO 4 — Dinámica no lineal + ruido

def step(x, W, g):
    noise = 0.02 * np.random.randn(len(x))
    return np.tanh(g * np.dot(W, x)) + noise

---

⏱️ PASO 5 — Simulación

T = 300
x = np.random.randn(N)

history = []

for t in range(T):
    x = step(x, W, g)
    history.append(x.copy())

history = np.array(history)

---

📊 PASO 6 — Visualización

plt.figure(figsize=(10,5))

for i in range(5):
    plt.plot(history[:, i])

plt.title(f"Dinámica cerebral (g={g})")
plt.show()

---

🔬 PASO 7 — EXPERIMENTO CLAVE (como en papers)

Cambia g:

for g in [0.5, 0.9, 1.2]:
    # repetir simulación

👉 observa:

g	comportamiento
0.5	actividad muerta
0.9	dinámica rica (tipo cerebro)
1.2	caos

---

🧠 PASO 8 — MEDIDA DE COMPLEJIDAD

Añadimos algo tipo ciencia real:

def complexity(signal):
    return np.std(signal)

print("Complejidad:", complexity(history))

👉 en el cerebro real:

• máxima complejidad ≈ estado crítico

---

🌐 PASO 9 — CONECTIVIDAD FUNCIONAL

Esto ya es nivel neuroimagen:

corr = np.corrcoef(history.T)

plt.imshow(corr)
plt.colorbar()
plt.title("Conectividad funcional")
plt.show()

👉 esto es lo que se hace con fMRI real

---

🧠 QUÉ HAS HECHO (MUY IMPORTANTE)

Has implementado una versión simplificada de:

• modelos de cerebro completo
• dinámica en reposo
• redes funcionales

👉 exactamente el enfoque de Gustavo Deco

---

🔬 CONCEPTOS REALES QUE HAS TOCADO

• red por defecto
• dinámica no lineal
• criticalidad
• conectividad funcional

---

🚀 EXTENSIONES (nivel investigación)

Si quieres seguir:

🔹 1. Modularidad (cerebro real)

• dividir red en “áreas”

🔹 2. Estimulación externa

x[0] += 1  # estímulo

🔹 3. Simular enfermedad

• romper conexiones
• reducir g

---

🧭 CONCLUSIÓN

Has llegado a algo muy potente:

👉 IA → redes → dinámica → cerebro

Y lo más importante:

👉 ya no estás “aprendiendo sobre el cerebro”
👉 estás modelándolo

---