instinto 0.2.0__tar.gz

instinto-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ElEscribanoSilente
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

instinto-0.2.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: instinto
+Version: 0.2.0
+Summary: Red neuronal zero-deps para videojuegos: neuroevolucion, imitacion, JIT por codegen y save de una linea.
+Author: esraderey
+License: MIT
+Project-URL: Homepage, https://github.com/ElEscribanoSilente/instinto
+Keywords: neural-network,neuroevolution,gamedev,zero-dependencies,genetic-algorithm
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# instinto
+
+[![CI](https://github.com/ElEscribanoSilente/instinto/actions/workflows/ci.yml/badge.svg)](https://github.com/ElEscribanoSilente/instinto/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/instinto)](https://pypi.org/project/instinto/)
+[![Python](https://img.shields.io/pypi/pyversions/instinto)](https://pypi.org/project/instinto/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Red neuronal **zero-deps** para videojuegos. Un archivo, solo stdlib.
+
+- **`Brain`** — MLP denso con pesos planos. `think()` / `act()`.
+- **Neuroevolución** — `Population` con elitismo, torneo y **sigma autoadaptativo**
+  (regla 1/5 de Rechenberg): explora fuerte al inicio, refina solo al final.
+- **Imitación** — `learn()` con backprop (SGD + momentum). Graba al jugador, entrena al NPC.
+- **JIT por codegen** — `compile()` genera el forward desenrollado vía `exec`:
+  **3–6× más rápido**, ~120k inferencias/seg en CPython puro.
+- **Save de una línea** — `save()` → float16 + zlib + base85. Un cerebro 2-6-2
+  son ~116 chars: pégalo en el JSON de tu partida guardada.
+- **Determinista** — misma seed, misma evolución. Replays reproducibles.
+
+## Instalar
+
+```
+pip install instinto        # o copia instinto.py a tu proyecto
+```
+
+## 60 segundos
+
+```python
+from instinto import Brain, Population
+
+# inferencia
+npc = Brain(n_in=4, hidden=[8], n_out=3, out="softmax", seed=42)
+accion = npc.act([dx, dy, vida, peligro], explore=0.05)   # 0|1|2
+
+# neuroevolución: el fitness ES tu juego
+pop = Population(60, n_in=4, hidden=[8], n_out=3, out="softmax", seed=7)
+for gen in range(100):
+    for brain in pop:
+        brain.fitness = jugar_partida(brain)     # tu función
+    stats = pop.evolve()                          # {'gen','best','mean','sigma'}
+mejor = pop.best
+
+# imitación: aprende del jugador
+datos = [(estado, accion_del_jugador), ...]       # índice de clase si softmax
+npc.learn(datos, epochs=300, lr=0.5)
+
+# producción
+mejor.compile()                                   # JIT (se invalida solo al mutar)
+blob = mejor.save()                               # str de una línea
+npc2 = Brain.load(blob)
+```
+
+## Demo
+
+```
+python demo_caza.py    # agentes evolucionan a cazar comida, render ASCII
+```
+
+## API
+
+| | |
+|---|---|
+| `Brain(n_in, hidden, n_out, act, out, seed)` | acts: `tanh sigmoid relu linear` (+`softmax` en salida) |
+| `.think(x) -> list` / `.act(x, explore) -> int` | inferencia / argmax con ε-greedy |
+| `.learn(samples, epochs, lr, momentum, batch, reset)` | backprop; devuelve loss (½·MSE o CE) |
+| `.mutate(rate, power)` / `.cross(other)` / `.clone()` | operadores evolutivos |
+| `.compile()` / `.save(compact)` / `Brain.load(s)` | JIT / persistencia |
+| `Population(size, ..., elite, tournament, mut_rate, sigma, noisy_fitness)` | iterable de Brains |
+| `.evolve() -> stats` / `.best` | siguiente generación / hall of fame |
+
+Sin numpy. Sin configs. Sin clases que heredar. Python ≥ 3.8.

instinto-0.2.0/README.md

@@ -0,0 +1,71 @@
+# instinto
+
+[![CI](https://github.com/ElEscribanoSilente/instinto/actions/workflows/ci.yml/badge.svg)](https://github.com/ElEscribanoSilente/instinto/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/instinto)](https://pypi.org/project/instinto/)
+[![Python](https://img.shields.io/pypi/pyversions/instinto)](https://pypi.org/project/instinto/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Red neuronal **zero-deps** para videojuegos. Un archivo, solo stdlib.
+
+- **`Brain`** — MLP denso con pesos planos. `think()` / `act()`.
+- **Neuroevolución** — `Population` con elitismo, torneo y **sigma autoadaptativo**
+  (regla 1/5 de Rechenberg): explora fuerte al inicio, refina solo al final.
+- **Imitación** — `learn()` con backprop (SGD + momentum). Graba al jugador, entrena al NPC.
+- **JIT por codegen** — `compile()` genera el forward desenrollado vía `exec`:
+  **3–6× más rápido**, ~120k inferencias/seg en CPython puro.
+- **Save de una línea** — `save()` → float16 + zlib + base85. Un cerebro 2-6-2
+  son ~116 chars: pégalo en el JSON de tu partida guardada.
+- **Determinista** — misma seed, misma evolución. Replays reproducibles.
+
+## Instalar
+
+```
+pip install instinto        # o copia instinto.py a tu proyecto
+```
+
+## 60 segundos
+
+```python
+from instinto import Brain, Population
+
+# inferencia
+npc = Brain(n_in=4, hidden=[8], n_out=3, out="softmax", seed=42)
+accion = npc.act([dx, dy, vida, peligro], explore=0.05)   # 0|1|2
+
+# neuroevolución: el fitness ES tu juego
+pop = Population(60, n_in=4, hidden=[8], n_out=3, out="softmax", seed=7)
+for gen in range(100):
+    for brain in pop:
+        brain.fitness = jugar_partida(brain)     # tu función
+    stats = pop.evolve()                          # {'gen','best','mean','sigma'}
+mejor = pop.best
+
+# imitación: aprende del jugador
+datos = [(estado, accion_del_jugador), ...]       # índice de clase si softmax
+npc.learn(datos, epochs=300, lr=0.5)
+
+# producción
+mejor.compile()                                   # JIT (se invalida solo al mutar)
+blob = mejor.save()                               # str de una línea
+npc2 = Brain.load(blob)
+```
+
+## Demo
+
+```
+python demo_caza.py    # agentes evolucionan a cazar comida, render ASCII
+```
+
+## API
+
+| | |
+|---|---|
+| `Brain(n_in, hidden, n_out, act, out, seed)` | acts: `tanh sigmoid relu linear` (+`softmax` en salida) |
+| `.think(x) -> list` / `.act(x, explore) -> int` | inferencia / argmax con ε-greedy |
+| `.learn(samples, epochs, lr, momentum, batch, reset)` | backprop; devuelve loss (½·MSE o CE) |
+| `.mutate(rate, power)` / `.cross(other)` / `.clone()` | operadores evolutivos |
+| `.compile()` / `.save(compact)` / `Brain.load(s)` | JIT / persistencia |
+| `Population(size, ..., elite, tournament, mut_rate, sigma, noisy_fitness)` | iterable de Brains |
+| `.evolve() -> stats` / `.best` | siguiente generación / hall of fame |
+
+Sin numpy. Sin configs. Sin clases que heredar. Python ≥ 3.8.

instinto-0.2.0/instinto.egg-info/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: instinto
+Version: 0.2.0
+Summary: Red neuronal zero-deps para videojuegos: neuroevolucion, imitacion, JIT por codegen y save de una linea.
+Author: esraderey
+License: MIT
+Project-URL: Homepage, https://github.com/ElEscribanoSilente/instinto
+Keywords: neural-network,neuroevolution,gamedev,zero-dependencies,genetic-algorithm
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# instinto
+
+[![CI](https://github.com/ElEscribanoSilente/instinto/actions/workflows/ci.yml/badge.svg)](https://github.com/ElEscribanoSilente/instinto/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/instinto)](https://pypi.org/project/instinto/)
+[![Python](https://img.shields.io/pypi/pyversions/instinto)](https://pypi.org/project/instinto/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Red neuronal **zero-deps** para videojuegos. Un archivo, solo stdlib.
+
+- **`Brain`** — MLP denso con pesos planos. `think()` / `act()`.
+- **Neuroevolución** — `Population` con elitismo, torneo y **sigma autoadaptativo**
+  (regla 1/5 de Rechenberg): explora fuerte al inicio, refina solo al final.
+- **Imitación** — `learn()` con backprop (SGD + momentum). Graba al jugador, entrena al NPC.
+- **JIT por codegen** — `compile()` genera el forward desenrollado vía `exec`:
+  **3–6× más rápido**, ~120k inferencias/seg en CPython puro.
+- **Save de una línea** — `save()` → float16 + zlib + base85. Un cerebro 2-6-2
+  son ~116 chars: pégalo en el JSON de tu partida guardada.
+- **Determinista** — misma seed, misma evolución. Replays reproducibles.
+
+## Instalar
+
+```
+pip install instinto        # o copia instinto.py a tu proyecto
+```
+
+## 60 segundos
+
+```python
+from instinto import Brain, Population
+
+# inferencia
+npc = Brain(n_in=4, hidden=[8], n_out=3, out="softmax", seed=42)
+accion = npc.act([dx, dy, vida, peligro], explore=0.05)   # 0|1|2
+
+# neuroevolución: el fitness ES tu juego
+pop = Population(60, n_in=4, hidden=[8], n_out=3, out="softmax", seed=7)
+for gen in range(100):
+    for brain in pop:
+        brain.fitness = jugar_partida(brain)     # tu función
+    stats = pop.evolve()                          # {'gen','best','mean','sigma'}
+mejor = pop.best
+
+# imitación: aprende del jugador
+datos = [(estado, accion_del_jugador), ...]       # índice de clase si softmax
+npc.learn(datos, epochs=300, lr=0.5)
+
+# producción
+mejor.compile()                                   # JIT (se invalida solo al mutar)
+blob = mejor.save()                               # str de una línea
+npc2 = Brain.load(blob)
+```
+
+## Demo
+
+```
+python demo_caza.py    # agentes evolucionan a cazar comida, render ASCII
+```
+
+## API
+
+| | |
+|---|---|
+| `Brain(n_in, hidden, n_out, act, out, seed)` | acts: `tanh sigmoid relu linear` (+`softmax` en salida) |
+| `.think(x) -> list` / `.act(x, explore) -> int` | inferencia / argmax con ε-greedy |
+| `.learn(samples, epochs, lr, momentum, batch, reset)` | backprop; devuelve loss (½·MSE o CE) |
+| `.mutate(rate, power)` / `.cross(other)` / `.clone()` | operadores evolutivos |
+| `.compile()` / `.save(compact)` / `Brain.load(s)` | JIT / persistencia |
+| `Population(size, ..., elite, tournament, mut_rate, sigma, noisy_fitness)` | iterable de Brains |
+| `.evolve() -> stats` / `.best` | siguiente generación / hall of fame |
+
+Sin numpy. Sin configs. Sin clases que heredar. Python ≥ 3.8.

instinto-0.2.0/instinto.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+LICENSE
+README.md
+instinto.py
+pyproject.toml
+instinto.egg-info/PKG-INFO
+instinto.egg-info/SOURCES.txt
+instinto.egg-info/dependency_links.txt
+instinto.egg-info/top_level.txt

instinto-0.2.0/instinto.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

instinto-0.2.0/instinto.egg-info/top_level.txt

@@ -0,0 +1 @@
+instinto

instinto-0.2.0/instinto.py

@@ -0,0 +1,445 @@
+"""instinto — red neuronal zero-deps para videojuegos.
+
+MLP denso con pesos planos. Tres vías de entrenamiento: backprop (imitar),
+neuroevolución (Population, sigma adaptativo regla 1/5) y mutación manual.
+JIT por codegen (compile), serialización de una línea (save/load).
+Solo stdlib. Determinista por seed.
+"""
+from __future__ import annotations
+
+import base64
+import math
+import random
+import struct
+import zlib
+from array import array
+
+__version__ = "0.2.0"
+__all__ = ["Brain", "Population"]
+
+_F16_MAX = 65504.0
+_HIDDEN_ACTS = ("tanh", "sigmoid", "relu", "linear")
+_OUT_ACTS = _HIDDEN_ACTS + ("softmax",)
+_MAGIC = "in1"
+
+
+def _sig(x: float) -> float:
+    if x >= 0.0:
+        z = math.exp(-x)
+        return 1.0 / (1.0 + z)
+    z = math.exp(x)
+    return z / (1.0 + z)
+
+
+def _apply(name: str, v: list) -> list:
+    if name == "tanh":
+        return [math.tanh(x) for x in v]
+    if name == "relu":
+        return [x if x > 0.0 else 0.0 for x in v]
+    if name == "sigmoid":
+        return [_sig(x) for x in v]
+    if name == "linear":
+        return v
+    # softmax estable
+    m = max(v)
+    e = [math.exp(x - m) for x in v]
+    s = sum(e)
+    return [x / s for x in e]
+
+
+def _dact(name: str, y: float) -> float:
+    """Derivada en función de la salida y."""
+    if name == "tanh":
+        return 1.0 - y * y
+    if name == "sigmoid":
+        return y * (1.0 - y)
+    if name == "relu":
+        return 1.0 if y > 0.0 else 0.0
+    return 1.0  # linear
+
+
+class Brain:
+    """MLP denso. arch=[n_in, *hidden, n_out], pesos planos por capa.
+
+    W[k][j*n_in + i]: peso entrada i → neurona j de la capa k.
+    """
+
+    __slots__ = ("arch", "acts", "W", "B", "fitness", "_rng", "_fwd",
+                 "_vW", "_vB", "_pfit")
+
+    def __init__(self, n_in: int, hidden=(), n_out: int = 1,
+                 act: str = "tanh", out: str = "tanh", seed=None):
+        if n_in < 1 or n_out < 1 or any(h < 1 for h in hidden):
+            raise ValueError("dimensiones >= 1")
+        if act not in _HIDDEN_ACTS:
+            raise ValueError(f"act oculta debe ser una de {_HIDDEN_ACTS}")
+        if out not in _OUT_ACTS:
+            raise ValueError(f"act de salida debe ser una de {_OUT_ACTS}")
+        self.arch = [n_in, *hidden, n_out]
+        self.acts = [act] * (len(self.arch) - 2) + [out]
+        self._rng = random.Random(seed)
+        self.W, self.B = [], []
+        for k in range(len(self.arch) - 1):
+            fi, fo = self.arch[k], self.arch[k + 1]
+            lim = math.sqrt(6.0 / (fi + fo))  # Xavier
+            self.W.append(array("d", (self._rng.uniform(-lim, lim)
+                                      for _ in range(fi * fo))))
+            self.B.append(array("d", (0.0 for _ in range(fo))))
+        self.fitness = None
+        self._pfit = None   # fitness del mejor padre (regla 1/5)
+        self._fwd = None    # forward JIT
+        self._vW = self._vB = None  # velocidades momentum
+
+    # ------------------------------------------------------------- inferencia
+    def think(self, x) -> list:
+        """Forward. x: secuencia de floats de tamaño arch[0]."""
+        f = self._fwd
+        if f is not None:
+            return f(x)
+        a = x
+        arch, W, B, acts = self.arch, self.W, self.B, self.acts
+        for k in range(len(W)):
+            Wk, Bk, n_in = W[k], B[k], arch[k]
+            pre = []
+            for j in range(arch[k + 1]):
+                s = Bk[j]
+                base = j * n_in
+                for i in range(n_in):
+                    s += Wk[base + i] * a[i]
+                pre.append(s)
+            a = _apply(acts[k], pre)
+        return a
+
+    def act(self, x, explore: float = 0.0) -> int:
+        """Índice de acción (argmax). explore: prob. de acción aleatoria."""
+        if explore > 0.0 and self._rng.random() < explore:
+            return self._rng.randrange(self.arch[-1])
+        y = self.think(x)
+        return max(range(len(y)), key=y.__getitem__)
+
+    # ------------------------------------------------------------ aprendizaje
+    def learn(self, samples, epochs: int = 500, lr: float = 0.1,
+              momentum: float = 0.0, batch: int | None = None,
+              shuffle: bool = True, reset: bool = True) -> float:
+        """Backprop SGD+momentum. samples: [(x, target)]. Devuelve loss final.
+
+        target: lista de floats; escalar si n_out==1; índice de clase si softmax.
+        Loss MSE: 1/2 * sum((y-t)^2) por muestra (el 1/2 hace que el gradiente
+        sea (y-t)*act'); cross-entropy si la salida es softmax.
+        reset: si True (def.) cada llamada arranca con momentum a cero; ponlo en
+        False para continuar entrenando conservando el estado del optimizador.
+        """
+        self._fwd = None
+        soft = self.acts[-1] == "softmax"
+        n_out = self.arch[-1]
+        data = []
+        for x, t in samples:
+            if soft and isinstance(t, int):
+                oh = [0.0] * n_out
+                oh[t] = 1.0
+                t = oh
+            elif not isinstance(t, (list, tuple)):
+                t = [float(t)]
+            data.append((list(map(float, x)), list(map(float, t))))
+        if reset or self._vW is None:
+            self._vW = [array("d", bytes(8 * len(w))) for w in self.W]
+            self._vB = [array("d", bytes(8 * len(b))) for b in self.B]
+        bsz = len(data) if not batch else batch
+        L = len(self.W)
+        loss = 0.0
+        for _ in range(epochs):
+            if shuffle:
+                self._rng.shuffle(data)
+            loss = 0.0
+            for off in range(0, len(data), bsz):
+                chunk = data[off:off + bsz]
+                gW = [array("d", bytes(8 * len(w))) for w in self.W]
+                gB = [array("d", bytes(8 * len(b))) for b in self.B]
+                for x, t in chunk:
+                    A = self._trace(x)
+                    y = A[-1]
+                    if soft:
+                        loss += -sum(tj * math.log(yj + 1e-12)
+                                     for tj, yj in zip(t, y))
+                        delta = [yj - tj for yj, tj in zip(y, t)]
+                    else:
+                        loss += 0.5 * sum((yj - tj) ** 2 for yj, tj in zip(y, t))
+                        an = self.acts[-1]
+                        delta = [(yj - tj) * _dact(an, yj)
+                                 for yj, tj in zip(y, t)]
+                    for k in range(L - 1, -1, -1):
+                        prev, n_in = A[k], self.arch[k]
+                        Gk, Bk = gW[k], gB[k]
+                        for j, dj in enumerate(delta):
+                            base = j * n_in
+                            for i in range(n_in):
+                                Gk[base + i] += dj * prev[i]
+                            Bk[j] += dj
+                        if k:
+                            Wk, an = self.W[k], self.acts[k - 1]
+                            delta = [
+                                _dact(an, prev[i])
+                                * sum(Wk[j * n_in + i] * delta[j]
+                                      for j in range(len(delta)))
+                                for i in range(n_in)
+                            ]
+                    # fin muestra
+                inv = lr / len(chunk)
+                for k in range(L):
+                    vW, vB, Wk, Bk = self._vW[k], self._vB[k], self.W[k], self.B[k]
+                    Gk, Gb = gW[k], gB[k]
+                    for i in range(len(Wk)):
+                        vW[i] = momentum * vW[i] - inv * Gk[i]
+                        Wk[i] += vW[i]
+                    for j in range(len(Bk)):
+                        vB[j] = momentum * vB[j] - inv * Gb[j]
+                        Bk[j] += vB[j]
+            loss /= len(data)
+        return loss
+
+    def _trace(self, x) -> list:
+        """Forward guardando activaciones de cada capa (para backprop)."""
+        A = [x]
+        a = x
+        for k in range(len(self.W)):
+            Wk, Bk, n_in = self.W[k], self.B[k], self.arch[k]
+            pre = []
+            for j in range(self.arch[k + 1]):
+                s = Bk[j]
+                base = j * n_in
+                for i in range(n_in):
+                    s += Wk[base + i] * a[i]
+                pre.append(s)
+            a = _apply(self.acts[k], pre)
+            A.append(a)
+        return A
+
+    # -------------------------------------------------------------- evolución
+    def mutate(self, rate: float = 0.1, power: float = 0.5, rng=None) -> "Brain":
+        """Perturbación gaussiana: cada peso con prob. rate suma N(0, power)."""
+        r = rng or self._rng
+        self._fwd = None
+        for arr in (*self.W, *self.B):
+            for i in range(len(arr)):
+                if r.random() < rate:
+                    arr[i] += r.gauss(0.0, power)
+        return self
+
+    def cross(self, other: "Brain", rng=None) -> "Brain":
+        """Cruce uniforme gen a gen. Requiere arquitecturas idénticas."""
+        if self.arch != other.arch or self.acts != other.acts:
+            raise ValueError("arquitecturas incompatibles para cross")
+        r = rng or self._rng
+        child = self.clone()
+        child.fitness = child._pfit = None
+        for ca, oa in zip((*child.W, *child.B), (*other.W, *other.B)):
+            for i in range(len(ca)):
+                if r.random() < 0.5:
+                    ca[i] = oa[i]
+        return child
+
+    def clone(self) -> "Brain":
+        """Copia profunda (réplica exacta de pesos y estado RNG)."""
+        c = object.__new__(Brain)
+        c.arch, c.acts = list(self.arch), list(self.acts)
+        c.W = [array("d", w) for w in self.W]
+        c.B = [array("d", b) for b in self.B]
+        c.fitness, c._pfit = self.fitness, self._pfit
+        c._fwd = None
+        c._vW = c._vB = None
+        c._rng = random.Random()
+        c._rng.setstate(self._rng.getstate())
+        return c
+
+    def reseed(self, seed) -> "Brain":
+        self._rng.seed(seed)
+        return self
+
+    # ------------------------------------------------------------------- JIT
+    def compile(self, max_params: int = 8000) -> "Brain":
+        """Genera forward desenrollado vía exec (3-6x más rápido). Se
+        invalida solo tras mutate/learn/load; recompilar si hace falta."""
+        if self.n_params > max_params:
+            raise ValueError(f"demasiados parámetros para JIT (> {max_params})")
+        if not all(math.isfinite(v) for arr in (*self.W, *self.B) for v in arr):
+            raise ValueError("pesos no finitos (inf/nan): el entrenamiento "
+                             "divergió, no se puede compilar")
+        src = ["def _f(x):"]
+        prev = [f"x[{i}]" for i in range(self.arch[0])]
+        tmp = 0
+        for k in range(len(self.W)):
+            Wk, Bk, n_in, act = self.W[k], self.B[k], self.arch[k], self.acts[k]
+            exprs = []
+            for j in range(self.arch[k + 1]):
+                base = j * n_in
+                e = repr(Bk[j]) + "".join(
+                    f" + {Wk[base + i]!r}*{prev[i]}" for i in range(n_in))
+                exprs.append(e)
+            cur = []
+            if act == "softmax":
+                ts = []
+                for e in exprs:
+                    t = f"t{tmp}"; tmp += 1
+                    src.append(f"    {t} = {e}")
+                    ts.append(t)
+                src.append(f"    m = max({', '.join(ts)})")
+                es = []
+                for t in ts:
+                    src.append(f"    e{t} = _exp({t} - m)")
+                    es.append(f"e{t}")
+                src.append(f"    s = {' + '.join(es)}")
+                cur = [f"{e}/s" for e in es]
+            else:
+                wrap = {"tanh": "_tanh({})", "sigmoid": "_sig({})",
+                        "linear": "{}"}.get(act)
+                for e in exprs:
+                    t = f"t{tmp}"; tmp += 1
+                    if act == "relu":
+                        src.append(f"    {t} = {e}")
+                        src.append(f"    {t} = {t} if {t} > 0.0 else 0.0")
+                    else:
+                        src.append(f"    {t} = {wrap.format(e)}")
+                    cur.append(t)
+            prev = cur
+        src.append(f"    return [{', '.join(prev)}]")
+        ns = {"_tanh": math.tanh, "_exp": math.exp, "_sig": _sig}
+        exec("\n".join(src), ns)  # noqa: S102 — fuente generada localmente
+        self._fwd = ns["_f"]
+        return self
+
+    # ----------------------------------------------------------- persistencia
+    def save(self, compact: bool = True) -> str:
+        """Serializa a una línea: 'in1|fmt|arch|acts|blob'. compact=float16."""
+        fmt = "e" if compact else "f"
+        flat = []
+        for k in range(len(self.W)):
+            flat.extend(self.W[k])
+            flat.extend(self.B[k])
+        if compact:
+            flat = [max(-_F16_MAX, min(_F16_MAX, v)) for v in flat]
+        raw = struct.pack(f"<{len(flat)}{fmt}", *flat)
+        blob = base64.b85encode(zlib.compress(raw, 9)).decode("ascii")
+        return "|".join((_MAGIC, fmt, ",".join(map(str, self.arch)),
+                         ",".join(self.acts), blob))
+
+    @classmethod
+    def load(cls, data: str) -> "Brain":
+        try:
+            magic, fmt, arch_s, acts_s, blob = data.strip().split("|", 4)
+            if magic != _MAGIC or fmt not in "ef":
+                raise ValueError
+            arch = [int(v) for v in arch_s.split(",")]
+            acts = acts_s.split(",")
+            raw = zlib.decompress(base64.b85decode(blob))
+            size = struct.calcsize(fmt)
+            flat = struct.unpack(f"<{len(raw) // size}{fmt}", raw)
+        except (ValueError, zlib.error, struct.error) as e:
+            raise ValueError("blob de Brain inválido") from e
+        need = sum(arch[k] * arch[k + 1] + arch[k + 1]
+                   for k in range(len(arch) - 1))
+        if len(arch) < 2 or len(flat) != need:
+            raise ValueError("blob de Brain inválido: tamaño no coincide")
+        b = cls(arch[0], arch[1:-1], arch[-1],
+                act=acts[0] if len(acts) > 1 else "tanh", out=acts[-1])
+        pos = 0
+        for k in range(len(b.W)):
+            nw, nb = len(b.W[k]), len(b.B[k])
+            b.W[k] = array("d", flat[pos:pos + nw]); pos += nw
+            b.B[k] = array("d", flat[pos:pos + nb]); pos += nb
+        return b
+
+    # ------------------------------------------------------------------ varios
+    @property
+    def n_params(self) -> int:
+        return sum(len(w) for w in self.W) + sum(len(b) for b in self.B)
+
+    def __repr__(self):
+        a = "-".join(map(str, self.arch))
+        f = f", fit={self.fitness:.4g}" if self.fitness is not None else ""
+        return f"Brain({a} {self.acts[0]}/{self.acts[-1]}, {self.n_params}p{f})"
+
+
+class Population:
+    """Neuroevolución: elitismo + torneo + cruce uniforme + mutación gaussiana
+    con sigma autoadaptativo (regla 1/5 de Rechenberg).
+
+    noisy_fitness: si el fitness es ruidoso o no estacionario (p. ej. el entorno
+    cambia cada generación), ponlo en True para que `best` siga al campeón de la
+    generación actual —re-medido y comparable— en vez de congelar un fitness con
+    suerte de una generación pasada (el genoma campeón se conserva igual vía
+    elitismo). Con fitness determinista déjalo en False: mejor de todos los tiempos."""
+
+    def __init__(self, size: int, n_in: int, hidden=(), n_out: int = 1,
+                 act: str = "tanh", out: str = "tanh", seed=None,
+                 elite: float = 0.1, tournament: int = 3,
+                 mut_rate: float = 0.15, sigma: float = 0.5,
+                 noisy_fitness: bool = False):
+        if size < 4:
+            raise ValueError("size >= 4")
+        self._rng = random.Random(seed)
+        self.brains = [Brain(n_in, hidden, n_out, act, out,
+                             seed=self._rng.getrandbits(64))
+                       for _ in range(size)]
+        self.size, self.elite, self.tournament = size, elite, tournament
+        self.mut_rate, self.sigma = mut_rate, sigma
+        self.noisy_fitness = noisy_fitness
+        self.generation = 0
+        self.best: Brain | None = None  # hall of fame (clon congelado)
+
+    def __iter__(self):
+        return iter(self.brains)
+
+    def __len__(self):
+        return self.size
+
+    def __getitem__(self, i):
+        return self.brains[i]
+
+    def evolve(self) -> dict:
+        """Consume los .fitness asignados y produce la siguiente generación.
+
+        Devuelve {'gen', 'best', 'mean', 'sigma'}.
+        """
+        if any(b.fitness is None for b in self.brains):
+            raise RuntimeError("asigna .fitness a todos los Brain antes de evolve()")
+        # regla 1/5: ajustar sigma según éxito de los hijos de la gen anterior
+        scored = [(b.fitness, b._pfit) for b in self.brains if b._pfit is not None]
+        if scored:
+            ok = sum(f > p for f, p in scored) / len(scored)
+            self.sigma *= 1.22 if ok > 0.2 else 1 / 1.22
+            self.sigma = min(2.0, max(1e-3, self.sigma))
+        ranked = sorted(self.brains, key=lambda b: b.fitness, reverse=True)
+        # hall of fame: con fitness estacionario, el mejor de todos los tiempos;
+        # con noisy_fitness, el top de la gen actual (re-medido, comparable).
+        if self.noisy_fitness or self.best is None \
+                or ranked[0].fitness > self.best.fitness:
+            self.best = ranked[0].clone()
+        rng = self._rng
+        n_elite = max(1, int(self.elite * self.size))
+        nxt = []
+        for b in ranked[:n_elite]:
+            e = b.clone()
+            e.fitness = e._pfit = None
+            e.reseed(rng.getrandbits(64))
+            nxt.append(e)
+        while len(nxt) < self.size:
+            p1 = max(rng.sample(ranked, self.tournament),
+                     key=lambda b: b.fitness)
+            p2 = max(rng.sample(ranked, self.tournament),
+                     key=lambda b: b.fitness)
+            child = p1.cross(p2, rng=rng).mutate(self.mut_rate, self.sigma,
+                                                 rng=rng)
+            child._pfit = max(p1.fitness, p2.fitness)
+            child.reseed(rng.getrandbits(64))
+            nxt.append(child)
+        stats = {"gen": self.generation,
+                 "best": ranked[0].fitness,
+                 "mean": sum(b.fitness for b in self.brains) / self.size,
+                 "sigma": self.sigma}
+        self.brains = nxt
+        self.generation += 1
+        return stats
+
+    def __repr__(self):
+        hof = f", best={self.best.fitness:.4g}" if self.best else ""
+        return f"Population({self.size} brains, gen {self.generation}{hof})"

instinto-0.2.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "instinto"
+version = "0.2.0"
+description = "Red neuronal zero-deps para videojuegos: neuroevolucion, imitacion, JIT por codegen y save de una linea."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "esraderey" }]
+keywords = ["neural-network", "neuroevolution", "gamedev", "zero-dependencies", "genetic-algorithm"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Games/Entertainment",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.urls]
+Homepage = "https://github.com/ElEscribanoSilente/instinto"
+
+[tool.setuptools]
+py-modules = ["instinto"]

instinto-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+