Upload 4 files

Dockerfile_B

@@ -0,0 +1,72 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# Dockerfile — Cerebro B — VibeEngine v10.0 (BitNet REAL — ik_llama.cpp)
+# Arquitectura: MATH(<2ms) + BitNet-2B-1.58bit (100%% inferencias) + FastAPI
+# Motor: ik_llama.cpp AVX512_VNNI_VBMI — compatible GGUF i2_s nativo
+# Gaussian+Donchian+ADX+SuperTrend+CHoCH
+# ═══════════════════════════════════════════════════════════════════════════════
+
+# ── Etapa 1: Descargar modelo BitNet 2B ──────────────────────────────────────
+FROM python:3.11-slim AS model-fetcher
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        ca-certificates wget \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN pip install --no-cache-dir huggingface_hub
+
+COPY download_model.py /tmp/download_model.py
+RUN python3 /tmp/download_model.py
+
+# ── Etapa 2: Runtime ─────────────────────────────────────────────────────────
+FROM python:3.11-slim AS runtime
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        curl ca-certificates libgomp1 libstdc++6 unzip wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# ik_llama.cpp precompilado — soporte GGUF i2_s nativo (BitNet ternario)
+# AVX512_VNNI_VBMI: óptimo para Intel Xeon Platinum de HF Spaces
+RUN wget -q --user-agent="Mozilla/5.0" -O /tmp/ik.zip \
+        "https://github.com/Thireus/ik_llama.cpp/releases/download/main-b4801-b275691/ik_llama-main-b4801-b275691-bin-ubuntu-x64-avx512_vnni_vbmi.zip" \
+    && mkdir -p /app && unzip -q /tmp/ik.zip -d /app && rm /tmp/ik.zip \
+    && BINARY=$(find /app -name "llama-server" -type f | head -1) \
+    && ln -sf "$BINARY" /usr/local/bin/llama-server && chmod +x "$BINARY"
+
+ENV PATH="/app:${PATH}"
+ENV LD_LIBRARY_PATH="/app:${LD_LIBRARY_PATH}"
+
+WORKDIR /app
+
+COPY --from=model-fetcher /models /models
+
+RUN pip install --no-cache-dir \
+        fastapi==0.111.0 \
+        "uvicorn[standard]==0.30.1" \
+        httpx==0.27.0 \
+        numpy==1.26.4 \
+        scipy==1.13.0 \
+
+# Variables de entorno — compatibles con start.sh y server.py
+ENV MODEL_PATH="/models/ggml-model-i2_s.gguf"
+ENV N_CTX=2048
+ENV N_THREADS=2
+ENV BITNET_PORT=8080
+ENV PORT=7860
+ENV CEREBRO_ID=B
+ENV BITNET_TIMEOUT=45.0
+ENV DONCHIAN_PERIOD=20
+ENV SUPERTREND_MULT=3.0
+ENV SUPERTREND_ATR=10
+ENV ADX_PERIOD=14
+ENV CACHE_TTL=45.0
+
+COPY SCRIPT_VibeEngine ./
+COPY start_B.sh ./start.sh
+RUN chmod +x start.sh
+
+EXPOSE 7860
+
+HEALTHCHECK --interval=30s --timeout=15s --start-period=300s --retries=5 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+CMD ["./start.sh"]

download_model.py

@@ -0,0 +1,32 @@
+"""
+download_model.py — Descarga ggml-model-i2_s.gguf (BitNet 2B)
+Compartido entre todos los Cerebros APEX (B, C, E, F, G, H).
+"""
+import os
+from huggingface_hub import hf_hub_download
+
+REPO  = "microsoft/bitnet-b1.58-2B-4T-gguf"
+FILE  = "ggml-model-i2_s.gguf"
+DEST  = "/models"
+
+def download():
+    os.makedirs(DEST, exist_ok=True)
+    out = os.path.join(DEST, FILE)
+    if os.path.exists(out) and os.path.getsize(out) > 100_000_000:
+        print(f"[FETCHER] Ya existe: {out} ({os.path.getsize(out)//1024//1024} MB)")
+        return
+
+    print(f"[FETCHER] Descargando {REPO}/{FILE}...")
+    try:
+        hf_hub_download(
+            repo_id=REPO, filename=FILE,
+            local_dir=DEST, local_dir_use_symlinks=False,
+        )
+        size_mb = os.path.getsize(out) // 1024 // 1024
+        print(f"[FETCHER] OK: {out} ({size_mb} MB)")
+    except Exception as e:
+        print(f"[FETCHER] ERROR: {e}")
+        raise
+
+if __name__ == "__main__":
+    download()

server_B.py

@@ -53,10 +53,9 @@ TELEMETRÍA: [B/MATH] ms | [B/LLM] ms | [B/TOTAL] ms
 """
 
 import os, json, re, time, threading, math, asyncio
-from concurrent.futures import ThreadPoolExecutor
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
-from llama_cpp import Llama
+import httpx  # BitNet v6.0 — ik_llama.cpp via HTTP
 
 # numpy obligatorio — implementación de indicadores vectorizada
 try:
@@ -71,31 +70,8 @@ app = FastAPI(title="Cerebro B — VibeEngine v10.0 NUMPY+LLM")
 # ── Config ────────────────────────────────────────────────────────────────────
 CEREBRO_ID   = "B"
 VERSION      = "10.0"
-MODEL_PATH   = os.environ.get("MODEL_PATH",  "/models/qwen2.5-1.5b-instruct-q4_k_m.gguf")
-N_CTX        = int(os.environ.get("N_CTX",       "128"))   # ultra-corto: 2-3 tokens salida
-N_THREADS    = int(os.environ.get("N_THREADS",    "2"))
-N_BATCH      = int(os.environ.get("N_BATCH",     "64"))
-CACHE_TTL    = float(os.environ.get("CACHE_TTL",  "45.0"))
-
-# Parámetros de indicadores (configurables)
-DONCHIAN_PERIOD  = int(os.environ.get("DONCHIAN_PERIOD",  "20"))
-SUPERTREND_MULT  = float(os.environ.get("SUPERTREND_MULT", "3.0"))
-SUPERTREND_ATR   = int(os.environ.get("SUPERTREND_ATR",   "10"))
-ADX_PERIOD       = int(os.environ.get("ADX_PERIOD",       "14"))
-
-print(f"[B] Cargando modelo: {MODEL_PATH}")
-print(f"[B] numpy={'✅' if _NP_OK else '⚠️ fallback'} | Indicadores vectorizados")
-llm = Llama(
-    model_path=MODEL_PATH,
-    n_ctx=N_CTX,
-    n_threads=N_THREADS,
-    n_batch=N_BATCH,
-    n_gpu_layers=0,
-    verbose=False,
-)
-_llm_lock = threading.Lock()
-executor   = ThreadPoolExecutor(max_workers=1)
-print(f"[B] ✅ VibeEngine v10.0 NUMPY+LLM — n_ctx={N_CTX}")
+
+
 
 # ── Cache ──────────────────────────────────────────────────────────────────────
 _B_CACHE: dict = {}
@@ -467,7 +443,7 @@ def _math_full_analysis(prompt: str, sym: str) -> dict:
 #  FASE LLM — Visto Bueno Final con sesgo BULL/BEAR/NEUTRAL
 # ══════════════════════════════════════════════════════════════════════════════
 
-def _llm_bias_final(math_data: dict, sym: str) -> dict:
+async def _llm_bias_final(math_data: dict, sym: str) -> dict:
     """
     El LLM actúa como Comité de Dirección Visual:
     Recibe el panel de control destilado por MATH y emite el sesgo final.
@@ -497,19 +473,11 @@ def _llm_bias_final(math_data: dict, sym: str) -> dict:
     )
 
     try:
-        with _llm_lock:
-            raw_out = llm(
-                llm_prompt,
-                max_tokens=28,
-                temperature=0.05,
-                top_p=0.95,
-                top_k=5,
-                stop=["<|im_end|>", "\n\n", "<|im_start|>"],
-                echo=False,
-                repeat_penalty=1.0,
-            )
+        result = await _bitnet_infer(llm_prompt)
+        raw_out_text = result.get("raw", "")
+
         llm_ms = (time.perf_counter() - t0_llm) * 1000
-        raw    = "{" + raw_out["choices"][0]["text"]
+        raw    = "{" + raw_out_text
 
         m = re.search(r'\{[^{}]*"bias"\s*:\s*"(BULL|BEAR|NEUTRAL)"[^{}]*\}', raw, re.IGNORECASE)
         if m:
@@ -549,7 +517,7 @@ def _llm_bias_final(math_data: dict, sym: str) -> dict:
 #  Solo se omite en modo cached o si el análisis es trivialmente claro.
 # ══════════════════════════════════════════════════════════════════════════════
 
-def _run_inference(agent: str, prompt: str) -> dict:
+async def _run_inference(agent: str, prompt: str) -> dict:
     t0_total = time.perf_counter()
     sym = _parse_symbol(prompt)
 
@@ -584,7 +552,7 @@ def _run_inference(agent: str, prompt: str) -> dict:
         print(f"[B/MATH-CLEAR] {sym}: bias={bias} (signal claro, skip LLM) | {math_ms:.1f}ms")
     else:
         # Zona ambigua → invocar LLM
-        llm_data = _llm_bias_final(math_data, sym)
+        llm_data = await _llm_bias_final(math_data, sym)
         bias     = llm_data["llm_bias"]
         llm_ms   = llm_data["_llm_ms"]
 
@@ -624,7 +592,7 @@ def root():
         "status":  "online",
         "cerebro": CEREBRO_ID,
         "version": VERSION,
-        "model":   MODEL_PATH.split("/")[-1],
+        "model": "BitNet-b1.58-2B-4T-i2_s (ik_llama.cpp)", "bitnet_server": BITNET_BASE,
         "agents":  ["VibeEngine"],
         "features": [
             "Gaussian Noise Filter (numpy convolution)",

start_B.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+set -e
+MODEL_PATH="${MODEL_PATH:-/models/ggml-model-i2_s.gguf}"
+BITNET_PORT="${BITNET_PORT:-8080}"
+N_CTX="${N_CTX:-2048}"
+N_THREADS="${N_THREADS:-2}"
+PORT="${PORT:-7860}"
+
+echo "[START] Cerebro VibeEngine v10.0 (BitNet REAL)"
+[ ! -f "$MODEL_PATH" ] && echo "[START] FATAL: modelo no encontrado" && exit 1
+echo "[START] Modelo: $(du -h $MODEL_PATH | cut -f1)"
+
+BITNET_LOG="/tmp/bitnet.log"
+> "$BITNET_LOG"
+
+llama-server \
+    --model "$MODEL_PATH" --host 127.0.0.1 --port "$BITNET_PORT" \
+    --ctx-size "$N_CTX" --threads "$N_THREADS" --gpu-layers 0 \
+    2>&1 | tee "$BITNET_LOG" | sed 's/^/[BITNET] /' &
+LLAMA_PID=$!
+
+MAX_WAIT=240; ELAPSED=0
+while [ $ELAPSED -lt $MAX_WAIT ]; do
+    ! kill -0 $LLAMA_PID 2>/dev/null && echo "[START] FATAL: llama-server murió" && tail -20 "$BITNET_LOG" && exit 1
+    curl -sf "http://127.0.0.1:${BITNET_PORT}/health" > /dev/null 2>&1 && break
+    sleep 5; ELAPSED=$((ELAPSED+5))
+    [ $((ELAPSED%30)) -eq 0 ] && echo "[START] ${ELAPSED}/${MAX_WAIT}s cargando..."
+done
+[ $ELAPSED -ge $MAX_WAIT ] && echo "[START] FATAL: timeout" && exit 1
+echo "[START] BitNet ONLINE — iniciando FastAPI..."
+
+exec uvicorn server_B:app --host 0.0.0.0 --port "$PORT" --workers 1 --log-level info