Upload 5 files

README.md

@@ -1,5 +1,5 @@
 ---
-title: DecodeChess-IA by Doctor Linux
+title: DecodeChess-IA with Graphs (Images) — Doctor Linux
 emoji: ♟️
 colorFrom: blue
 colorTo: green
@@ -9,5 +9,5 @@ app_file: app.py
 pinned: false
 ---
 
-# DecodeChess-IA — Doctor Linux
-Analizador de partidas con **Motor + Machine Learning**. Pega tu PGN y pulsa **Analizar con IA**.
+# DecodeChess-IA (gráficos en imagen)
+Esta versión renderiza los gráficos como **imágenes PNG** para máxima compatibilidad en Hugging Face Spaces.

app.py

@@ -14,15 +14,15 @@ from joblib import dump, load
 from sklearn.ensemble import RandomForestClassifier
 import chess, chess.pgn, chess.engine
 
-APP_TITLE = "DecodeChess-IA — Doctor Linux"
-ENGINE_CANDIDATES = [
-    "stockfish",
-    "/usr/bin/stockfish",
-    "/usr/games/stockfish",
-    "/bin/stockfish",
-    "/usr/local/bin/stockfish",
-]
+# Graficos como imagen
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
 
+APP_TITLE = "DecodeChess-IA — Doctor Linux (gráficos en imagen)"
+ENGINE_CANDIDATES = ["stockfish","/usr/bin/stockfish","/usr/games/stockfish","/bin/stockfish","/usr/local/bin/stockfish"]
+
+# ---------------- Motor ----------------
 def load_engine():
     path = shutil.which("stockfish")
     if path:
@@ -50,33 +50,31 @@ def score_cp(score_obj) -> float:
         return 100000.0 if m > 0 else -100000.0
     return float(pov.score(mate_score=100000))
 
+# ---------------- PGN & features ----------------
 def repair_pgn_text(text: str) -> str:
-    text = text.replace("\r\n", "\n").replace("\r", "\n")
+    text = text.replace("\r\n","\n").replace("\r","\n")
     if "[Event " not in text:
         head = ['[Event "?"]','[Site "?"]','[Date "????.??.??"]','[Round "?"]','[White "?"]','[Black "?"]','[Result "*"]','','']
         text = "\n".join(head) + text
-    text = re.sub(r'\[Ulnite','[White', text)
-    text = text.replace('[Result "I-0"]','[Result "1-0"]').replace('[Result "O-I"]','[Result "0-1"]').replace('[Result "I/2-I/2"]','[Result "1/2-1/2"]')
-    return text.strip() + "\n"
+    return text.strip()+"\n"
 
 PIECE_VALUES = {chess.PAWN:1, chess.KNIGHT:3, chess.BISHOP:3, chess.ROOK:5, chess.QUEEN:9}
 CENTER = [chess.D4, chess.E4, chess.D5, chess.E5]
 
 def material_eval(board: chess.Board):
-    s = 0
-    for pt, v in PIECE_VALUES.items():
-        s += len(board.pieces(pt, chess.WHITE))*v
-        s -= len(board.pieces(pt, chess.BLACK))*v
+    s=0
+    for pt,v in PIECE_VALUES.items():
+        s+=len(board.pieces(pt,chess.WHITE))*v
+        s-=len(board.pieces(pt,chess.BLACK))*v
     return s
 
-def mobility(board: chess.Board):
-    return board.legal_moves.count()
+def mobility(board: chess.Board): return board.legal_moves.count()
 
 def hanging_pieces(board: chess.Board, color=chess.WHITE):
-    c = 0
+    c=0
     for sq in chess.SquareSet(board.occupied_co[color]):
         if board.is_attacked_by(not color, sq) and not board.is_attacked_by(color, sq):
-            c += 1
+            c+=1
     return c
 
 def basic_features(board: chess.Board):
@@ -95,74 +93,81 @@ FEATURE_ORDER = ["turn_white","mat_cp","mobility","hanging_w","hanging_b","cente
 
 def delta_to_label(delta_cp: float) -> str:
     drop = -delta_cp
-    if drop < 20:   return "Best"
-    if drop < 60:   return "Good"
-    if drop < 120:  return "Inaccuracy"
-    if drop < 300:  return "Mistake"
+    if drop < 20: return "Best"
+    if drop < 60: return "Good"
+    if drop < 120: return "Inaccuracy"
+    if drop < 300: return "Mistake"
     return "Blunder"
 
-def generate_training(engine, games=16, plies_per_game=30, time_per=0.05):
-    rows = []
+# ---------------- Entrenamiento rápido ----------------
+def generate_training(engine, games=14, plies_per_game=24, time_per=0.05):
+    rows=[]
     for _ in range(games):
         board = chess.Board()
         for _ in range(plies_per_game):
-            if board.is_game_over():
-                break
+            if board.is_game_over(): break
             info_b = engine.analyse(board, chess.engine.Limit(time=time_per))
             eval_b = score_cp(info_b["score"])
             legal = list(board.legal_moves)
-            if not legal:
-                break
+            if not legal: break
             move = random.choice(legal)
-            feats = basic_features(board)
-            feats["eval_before_cp"] = eval_b
+            feats = basic_features(board); feats["eval_before_cp"]=eval_b
             board.push(move)
             info_a = engine.analyse(board, chess.engine.Limit(time=time_per))
             eval_a = score_cp(info_a["score"])
             delta = eval_a - eval_b if feats["turn_white"] else -(eval_a - eval_b)
-            row = {k: feats.get(k, 0.0) for k in FEATURE_ORDER}
-            row["delta_cp"] = delta
-            row["label"] = delta_to_label(delta)
+            row = {k: feats.get(k,0.0) for k in FEATURE_ORDER}
+            row["delta_cp"]=delta; row["label"]=delta_to_label(delta)
             rows.append(row)
     return pd.DataFrame(rows)
 
 def train_model_if_needed():
     if os.path.exists("model_rf.joblib"):
-        try:
-            return load("model_rf.joblib")
-        except Exception:
-            pass
+        try: return load("model_rf.joblib")
+        except Exception: pass
     eng = load_engine()
-    try:
-        df = generate_training(eng, games=16, plies_per_game=28, time_per=0.05)
-    finally:
-        eng.quit()
-    X = df[FEATURE_ORDER].astype(float)
-    y = df["label"]
+    try: df = generate_training(eng)
+    finally: eng.quit()
+    X = df[FEATURE_ORDER].astype(float); y=df["label"]
     clf = RandomForestClassifier(n_estimators=120, random_state=42, n_jobs=-1)
-    clf.fit(X, y)
-    dump(clf, "model_rf.joblib")
-    return clf
+    clf.fit(X,y); dump(clf,"model_rf.joblib"); return clf
 
+# ---------------- Explicaciones ----------------
 def explain(label, delta_cp, in_check, hanging_w, hanging_b):
-    tips = []
-    if label == "Blunder":
-        tips.append("Error grave; posible táctica inmediata o pieza colgando.")
-    elif label == "Mistake":
-        tips.append("Movimiento impreciso que cede ventaja notable.")
-    elif label == "Inaccuracy":
-        tips.append("Había alternativas más fuertes según el motor.")
-    elif label == "Good":
-        tips.append("Jugada sólida; mantiene la evaluación.")
-    else:
-        tips.append("Excelente jugada; muy precisa.")
-    if in_check:
-        tips.append("El rey estaba en jaque o vulnerable.")
-    if hanging_w or hanging_b:
-        tips.append("Detecto pieza(s) atacadas sin defensa.")
+    tips=[]
+    if label=="Blunder": tips.append("Error grave; posible táctica o pieza colgando.")
+    elif label=="Mistake": tips.append("Cede ventaja significativa.")
+    elif label=="Inaccuracy": tips.append("Había opciones mejores.")
+    elif label=="Good": tips.append("Jugada sólida.")
+    else: tips.append("Excelente jugada.")
+    if in_check: tips.append("Rey bajo ataque.")
+    if hanging_w or hanging_b: tips.append("Piezas atacadas sin defensa.")
     tips.append(f"Δ={round(delta_cp,1)} cp.")
     return " ".join(tips)
 
+# ---------------- Gráficos (guardar como imagen) ----------------
+def save_eval_plot(eval_series, title):
+    fig, ax = plt.subplots(figsize=(10,4))
+    if not eval_series:
+        ax.text(0.5,0.5,"Sin datos",ha="center",va="center",transform=ax.transAxes); ax.axis("off")
+    else:
+        xs = list(range(1,len(eval_series)+1))
+        ax.plot(xs, eval_series, linewidth=2)
+        ax.axhline(0, linestyle="--", linewidth=1)
+        ax.set_xlabel("Ply"); ax.set_ylabel("Centipawns"); ax.set_title(title); ax.grid(True, alpha=0.3)
+    fig.tight_layout()
+    out = "eval.png"; fig.savefig(out, dpi=120); plt.close(fig); return out
+
+def save_errbars(labels):
+    fig, ax = plt.subplots(figsize=(6,4))
+    cats = ["Best","Good","Inaccuracy","Mistake","Blunder"]
+    counts = [sum(1 for l in labels if l==c) for c in cats]
+    ax.bar(cats, counts); ax.set_ylabel("Cantidad"); ax.set_title("Distribución por categoría ML")
+    for i,v in enumerate(counts): ax.text(i, v + (max(counts)*0.04 if counts else 0.2), str(v), ha="center", va="bottom")
+    fig.tight_layout()
+    out = "errors.png"; fig.savefig(out, dpi=120); plt.close(fig); return out
+
+# ---------------- Análisis PGN ----------------
 def analyze_pgn(pgn_text: str, time_per_move=0.2):
     pgn_text = repair_pgn_text(pgn_text)
     f = StringIO(pgn_text)
@@ -170,77 +175,82 @@ def analyze_pgn(pgn_text: str, time_per_move=0.2):
     while game is not None and sum(1 for _ in game.mainline_moves()) == 0:
         game = chess.pgn.read_game(f)
     if game is None:
-        return None, None, "PGN vacío o inválido."
+        return None, None, None, None, "PGN vacío o inválido."
+
     engine = load_engine()
     model = train_model_if_needed()
     board = game.board()
-    rows = []
+    rows=[]; eval_series=[]; labels=[]
+
     exporter = chess.pgn.StringExporter(headers=True, comments=True, variations=False)
-    node = game
-    ply = 0
+    node = game; ply=0
     while node.variations:
         move = node.variation(0).move
         turn_white = board.turn
-        info_b = engine.analyse(board, chess.engine.Limit(time=time_per_move))
-        eval_b = score_cp(info_b["score"])
-        feats = basic_features(board)
-        feats["eval_before_cp"] = eval_b
-        X = np.array([[feats.get(k, 0.0) for k in FEATURE_ORDER]], dtype=float)
+        info_b = engine.analyse(board, chess.engine.Limit(time=time_per_move)); eval_b = score_cp(info_b["score"])
+        feats = basic_features(board); feats["eval_before_cp"]=eval_b
+        import numpy as np
+        X = np.array([[feats.get(k,0.0) for k in FEATURE_ORDER]], dtype=float)
         label = model.predict(X)[0]
-        best_move = info_b.get("pv", [move])[0]
-        best_san = board.san(best_move) if best_move else ""
-        played_san = board.san(move)
-        board.push(move)
-        info_a = engine.analyse(board, chess.engine.Limit(time=time_per_move))
-        eval_a = score_cp(info_a["score"])
+
+        best_move = info_b.get("pv",[move])[0]; best_san = board.san(best_move) if best_move else ""
+        played_san = board.san(move); board.push(move)
+
+        info_a = engine.analyse(board, chess.engine.Limit(time=time_per_move)); eval_a = score_cp(info_a["score"])
         delta = eval_a - eval_b if turn_white else -(eval_a - eval_b)
+
+        labels.append(label); eval_series.append(eval_a)
         text = explain(label, delta, feats["in_check"], feats["hanging_w"], feats["hanging_b"])
-        node = node.variation(0)
-        node.comment = f"[{label}] Δ={round(delta,1)} | Mejor: {best_san}. {text}"
-        ply += 1
-        rows.append({
-            "ply": ply,
-            "turn": "White" if turn_white else "Black",
-            "played": played_san,
-            "best": best_san,
-            "eval_before_cp": round(eval_b,1),
-            "eval_after_cp": round(eval_a,1),
-            "delta_cp": round(delta,1),
-            "ml_label": label,
-            "explanation": text,
-        })
+        node = node.variation(0); node.comment = f"[{label}] Δ={round(delta,1)} | Mejor: {best_san}. {text}"
+        ply+=1
+        rows.append({"ply":ply,"turn":"White" if turn_white else "Black","played":played_san,"best":best_san,
+                     "eval_before_cp":round(eval_b,1),"eval_after_cp":round(eval_a,1),"delta_cp":round(delta,1),
+                     "ml_label":label,"explanation":text})
     engine.quit()
+
     annotated = game.accept(exporter)
-    import pandas as pd
     df = pd.DataFrame(rows)
-    md = ["### Principales errores", "| Ply | Turno | Jugada | Δcp | ML |", "|---:|:---:|:---|---:|:---|"]
+    md = ["### Principales errores","| Ply | Turno | Jugada | Δcp | ML |","|---:|:---:|:---|---:|:---|"]
     for r in sorted(rows, key=lambda r: r["delta_cp"])[:10]:
         md.append(f"| {r['ply']} | {r['turn']} | {r['played']} | {r['delta_cp']} | {r['ml_label']} |")
-    return annotated, "\n".join(md), df.to_csv(index=False)
+    summary_md = "\n".join(md)
 
+    eval_img = save_eval_plot(eval_series, f"Evaluación — {game.headers.get('White','?')} vs {game.headers.get('Black','?')}")
+    errs_img = save_errbars(labels)
+
+    return annotated, summary_md, df.to_csv(index=False), eval_img, errs_img
+
+# ---------------- UI ----------------
 with gr.Blocks(title=APP_TITLE) as demo:
-    gr.Markdown(f"# {APP_TITLE}\nMotor + Machine Learning en acción 🧠♟️\nSube o pega tu partida PGN para analizarla.")
+    gr.Markdown(f"# {APP_TITLE}\n**Motor + ML con visualizaciones** (renderizadas como imágenes)\n- Gráfico de evaluación\n- Gráfico de categorías\n- PGN anotado y CSV")
+
     eg = gr.Examples(
-        examples=[[
-            "[Event \"Demo\"]\n[Site \"?\"]\n[Date \"2024.??.??\"]\n[Round \"?\"]\n[White \"Alice\"]\n[Black \"Bob\"]\n[Result \"1-0\"]\n\n1. e4 e5 2. Nf3 Nc6 3. Bb5 a6 4. Ba4 Nf6 5. O-O Be7 6. Re1 b5 7. Bb3 O-O 8. c3 d5 9. exd5 Nxd5 10. Nxe5 Nxe5 11. Rxe5 c6 12. d4 Bd6 13. Re1 Qh4 14. g3 Qh3 15. Qf3 Bg4 16. Qg2 Rae8 17. Be3 Qh5 18. Nd2 Bh3 19. Qf3 Bg4 20. Qg2 f5 21. Bxd5+ cxd5 22. Qxd5+ Kh8 23. Qxd6 f4 24. Bxf4 Bf3 25. Rxe8 Rxe8 26. Be5 Qh3 27. Nxf3 Qf5 28. Qc6 Rf8 29. Qb7 Qg6 30. Nh4 Qc2 31. Qxg7# 1-0"
-        ]],
+        examples=[["[Event \"Demo\"]\n[Site \"?\"]\n[Date \"2024.??.??\"]\n[Round \"?\"]\n[White \"Alice\"]\n[Black \"Bob\"]\n[Result \"1-0\"]\n\n1. e4 e5 2. Nf3 Nc6 3. Bb5 a6 4. Ba4 Nf6 5. O-O Be7 6. Re1 b5 7. Bb3 O-O 8. c3 d5 9. exd5 Nxd5 10. Nxe5 Nxe5 11. Rxe5 c6 12. d4 Bd6 13. Re1 Qh4 14. g3 Qh3 15. Qf3 Bg4 16. Qg2 Rae8 17. Be3 Qh5 18. Nd2 Bh3 19. Qf3 Bg4 20. Qg2 f5 21. Bxd5+ cxd5 22. Qxd5+ Kh8 23. Qxd6 f4 24. Bxf4 Bf3 25. Rxe8 Rxe8 26. Be5 Qh3 27. Nxf3 Qf5 28. Qc6 Rf8 29. Qb7 Qg6 30. Nh4 Qc2 31. Qxg7# 1-0"]],
         inputs=[gr.Textbox(visible=False)],
     )
+
     pgn_in = gr.Textbox(lines=18, label="PGN (pega tu partida aquí)")
     run = gr.Button("Analizar con IA")
+
+    with gr.Row():
+        eval_img = gr.Image(label="Evaluación (imagen)", interactive=False)
+        errs_img = gr.Image(label="Errores (imagen)", interactive=False)
+
     annotated_out = gr.Textbox(lines=10, label="PGN anotado")
     summary_out = gr.Markdown(label="Resumen IA")
     files_out = gr.Files(label="Descargas (PGN + CSV)")
+
     def _analyze(pgn_text):
         try:
-            annotated, md, csv_text = analyze_pgn(pgn_text)
+            annotated, md, csv_text, eval_png, errs_png = analyze_pgn(pgn_text)
             open("anotado.pgn","w",encoding="utf-8").write(annotated if annotated else "")
             open("jugadas.csv","w",encoding="utf-8").write(csv_text if csv_text else "")
-            return annotated, md, ["anotado.pgn","jugadas.csv"]
+            return eval_png, errs_png, annotated, md, ["anotado.pgn","jugadas.csv"]
         except Exception as e:
             tb = traceback.format_exc(limit=2)
-            return f"Error: {e}\n{tb}", "", []
-    run.click(_analyze, inputs=[pgn_in], outputs=[annotated_out, summary_out, files_out])
+            return None, None, f"Error: {e}\n{tb}", "", []
+
+    run.click(_analyze, inputs=[pgn_in], outputs=[eval_img, errs_img, annotated_out, summary_out, files_out])
 
 if __name__ == "__main__":
     try:

requirements.txt

@@ -4,3 +4,4 @@ numpy>=1.26
 pandas>=2.2
 scikit-learn>=1.3
 joblib>=1.4
+matplotlib>=3.8