Upload 2 files

app.py

@@ -0,0 +1,304 @@
+
+# app.py — MG360 (24 ítems) · Gradio Space
+from dataclasses import dataclass
+from typing import List, Dict, Tuple
+from datetime import datetime
+from pathlib import Path
+import os, math, json, requests
+
+# ========== Núcleo MG360 (24 ítems) ==========
+@dataclass(frozen=True)
+class Item:
+    code: str
+    text: str
+    dimension: str  # "COG", "EMO", "REL", "EJE"
+    reverse: bool
+
+ITEMS: List[Item] = [
+    # Cognitiva (COG)
+    Item("COG1", "Antes de decidir, evalúo cómo una acción afecta a otras áreas.", "COG", False),
+    Item("COG2", "Anticipo escenarios y consecuencias más allá del corto plazo.", "COG", False),
+    Item("COG3", "Identifico patrones y relaciones entre procesos aparentemente aislados.", "COG", False),
+    Item("COG4", "Prefiero concentrarme solo en mi área aunque desconozca las demás.", "COG", True),
+    Item("COG5", "Decido principalmente según urgencias del día a día.", "COG", True),
+    Item("COG6", "Me cuesta ver el impacto sistémico de mis decisiones.", "COG", True),
+    # Emocional (EMO)
+    Item("EMO1", "Identifico emociones que influyen en mi trato con otros.", "EMO", False),
+    Item("EMO2", "Regulo mi respuesta emocional aun bajo presión.", "EMO", False),
+    Item("EMO3", "Practico la empatía para comprender perspectivas distintas.", "EMO", False),
+    Item("EMO4", "Suelo reprimir emociones para no mostrar debilidad.", "EMO", True),
+    Item("EMO5", "Cuando me frustro, reacciono de forma impulsiva.", "EMO", True),
+    Item("EMO6", "Evito hablar de emociones en el trabajo.", "EMO", True),
+    # Relacional (REL)
+    Item("REL1", "Busco acuerdos que integren intereses distintos.", "REL", False),
+    Item("REL2", "Comunico expectativas de forma clara y verifico entendimiento.", "REL", False),
+    Item("REL3", "Fomento colaboración efectiva entre áreas y niveles.", "REL", False),
+    Item("REL4", "Evito confrontar para no generar conflicto.", "REL", True),
+    Item("REL5", "Prefiero trabajar de forma individual para avanzar más rápido.", "REL", True),
+    Item("REL6", "Me cuesta adaptar mi comunicación según el interlocutor.", "REL", True),
+    # Ejecucional (EJE)
+    Item("EJE1", "Transformo errores en oportunidades de aprendizaje.", "EJE", False),
+    Item("EJE2", "Cumplo compromisos en tiempo forma de manera consistente.", "EJE", False),
+    Item("EJE3", "Itero procesos para mejorar resultados de forma continua.", "EJE", False),
+    Item("EJE4", "Cumplir metas es más importante que desarrollar a las personas.", "EJE", True),
+    Item("EJE5", "Me desanimo fácilmente cuando surgen obstáculos.", "EJE", True),
+    Item("EJE6", "Evito revisar resultados para no encontrar fallas.", "EJE", True),
+]
+
+DIMENSIONS = ["COG", "EMO", "REL", "EJE"]
+DIMENSION_LABELS = {
+    "COG": "Cognitiva",
+    "EMO": "Emocional",
+    "REL": "Relacional",
+    "EJE": "Ejecucional",
+}
+
+def invert_if_needed(value: float, reverse: bool) -> float:
+    return 6 - value if reverse else value
+
+def score_responses(responses: Dict[str, float]) -> Dict[str, float]:
+    dim_values = {d: [] for d in DIMENSIONS}
+    for code, v in responses.items():
+        # Validación 1..5
+        fv = float(v)
+        if not (1 <= fv <= 5):
+            raise ValueError(f"Respuesta fuera de 1-5 en {code}: {fv}")
+    # Cálculo
+    for it in ITEMS:
+        v = float(responses[it.code])
+        dim_values[it.dimension].append(invert_if_needed(v, it.reverse))
+    dim_avg = {d: sum(vals)/len(vals) for d, vals in dim_values.items()}
+    vals = list(dim_avg.values())
+    avg = sum(vals)/len(vals)
+    var = sum((x-avg)**2 for x in vals) / len(vals)
+    stdev = (var ** 0.5)
+    balance_360 = 1 - (stdev / avg) if avg > 0 else 0.0
+    return {**dim_avg, "BALANCE_360": balance_360}
+
+def dominant_axis(dim_scores: Dict[str, float]) -> Tuple[str, float]:
+    best_dim = max(DIMENSIONS, key=lambda d: dim_scores[d])
+    return best_dim, dim_scores[best_dim]
+
+def interpret(dim_scores: Dict[str, float]) -> Dict[str, str]:
+    bal = dim_scores["BALANCE_360"]
+    if bal > 0.85:
+        eq = "Mentalidad 360 desarrollada"
+    elif bal >= 0.70:
+        eq = "Parcialmente equilibrada"
+    else:
+        eq = "Tendencia a sesgo gerencial (un eje domina)"
+    best, val = dominant_axis(dim_scores)
+    perfiles = {
+        "COG": "Estratega analítico (Cognitivo)",
+        "EMO": "Líder empático (Emocional)",
+        "REL": "Conector colaborativo (Relacional)",
+        "EJE": "Gestor ejecutor (Ejecucional)",
+    }
+    return {"equilibrio": eq, "eje_dominante": f"{perfiles[best]} — {DIMENSION_LABELS[best]} ({val:.2f}/5)"}
+
+# ========== Radar limpio y simétrico ==========
+def radar_plot(dim_scores: Dict[str, float], title: str, out_png: str) -> str:
+    import numpy as np
+    import matplotlib.pyplot as plt
+
+    DIM_ORDER = ["COG", "EMO", "REL", "EJE"]
+    labels = [DIMENSION_LABELS[d] for d in DIM_ORDER]
+    vals   = [float(dim_scores[d]) for d in DIM_ORDER]
+
+    angles = np.linspace(0, 2*np.pi, len(labels), endpoint=False)
+    angles_cycle = np.concatenate([angles, [angles[0]]])
+    vals_cycle   = np.concatenate([vals,   [vals[0]]])
+
+    fig = plt.figure(figsize=(8, 8))
+    ax = plt.subplot(111, polar=True)
+    ax.set_facecolor("white")
+    fig.subplots_adjust(bottom=0.18)
+
+    ax.set_theta_offset(np.pi / 2)
+    ax.set_theta_direction(-1)
+
+    ax.set_xticks(angles)
+    ax.set_xticklabels(labels, fontsize=14, fontweight="bold")
+
+    ax.set_ylim(0, 5)
+    ax.set_yticks([1, 2, 3, 4, 5])
+    ax.set_yticklabels(["1", "2", "3", "4", "5"], fontsize=11)
+    ax.yaxis.grid(True, linewidth=0.8, alpha=0.6)
+    ax.xaxis.grid(True, linewidth=0.8, alpha=0.6)
+
+    ax.plot(angles_cycle, vals_cycle, linewidth=2.2)
+    ax.fill(angles_cycle, vals_cycle, alpha=0.18)
+
+    for ang, v in zip(angles, vals):
+        ax.plot([ang], [v], marker="o", markersize=6)
+        ax.text(ang, min(5, v + 0.22), f"{v:.2f}", ha="center", va="center", fontsize=11, fontweight="bold")
+
+    ax.set_title(title, fontsize=22, fontweight="bold", pad=18)
+    bal = float(dim_scores.get("BALANCE_360", 0.0))
+    dom = max(DIM_ORDER, key=lambda d: dim_scores[d])
+    subtitle = f"Balance 360: {bal:.3f} · Eje dominante: {DIMENSION_LABELS[dom]} ({dim_scores[dom]:.2f}/5)"
+    fig.text(0.5, 0.03, subtitle, ha="center", va="center", fontsize=11)
+
+    fig.tight_layout()
+    fig.savefig(out_png, dpi=240, bbox_inches="tight")
+    plt.close(fig)
+    return out_png
+
+# ========== Prompt + LLM (Phi, InferenceClient) ==========
+from huggingface_hub import InferenceClient
+
+HF_MODEL_ID = os.environ.get("HF_MODEL_ID", "microsoft/Phi-3.5-mini-instruct")
+HF_TOKEN    = os.environ.get("HF_TOKEN", None)  # define esto en "Settings → Variables & secrets" del Space
+
+def build_prompt(scores: Dict[str, float], inter: Dict[str, str]) -> str:
+    lines = [
+        "Eres un coach ejecutivo experto en ICB4 (People, Practice, Perspective).",
+        "Con base en el siguiente diagnóstico MG360 (1–5), genera un plan de desarrollo práctico, accionable y medible.",
+        "",
+        "Resultados por eje:",
+        f"- Cognitiva:  {scores['COG']:.2f}/5",
+        f"- Emocional:  {scores['EMO']:.2f}/5",
+        f"- Relacional: {scores['REL']:.2f}/5",
+        f"- Ejecucional:{scores['EJE']:.2f}/5",
+        f"- Balance 360: {scores['BALANCE_360']:.3f}",
+        f"- Interpretación: {inter['equilibrio']} | {inter['eje_dominante']}",
+        "",
+        "Instrucciones de salida:",
+        "1) Empieza con un resumen de 2–3 líneas del perfil.",
+        "2) Para cada eje (Cognitiva, Emocional, Relacional, Ejecucional):",
+        "   - Da 3 acciones SMART (específicas, medibles, con plazos).",
+        "   - Incluye 1 indicador sugerido y 1 hábito semanal.",
+        "3) Cierra con un plan de 30 días (semanas 1–4) y riesgos comunes.",
+    ]
+    return "\\n".join(lines)
+
+def generate_plan_with_phi(prompt: str) -> str:
+    # Sin token: devolvemos aviso (el usuario puede definir HF_TOKEN en Secrets)
+    if not HF_TOKEN:
+        return ("[Aviso] Falta HF_TOKEN. Configúralo como variable de entorno "
+                "en tu Space (Settings → Variables & secrets).")
+
+    # 1) Intento con InferenceClient
+    try:
+        client = InferenceClient(HF_MODEL_ID, token=HF_TOKEN, timeout=180)
+        out = client.text_generation(
+            prompt,
+            max_new_tokens=600,
+            do_sample=True,
+            temperature=0.7,
+            top_p=0.9,
+            repetition_penalty=1.05,
+            return_full_text=False,
+        )
+        return out.strip()
+    except Exception as e:
+        err1 = f"[InferenceClient] {type(e).__name__}: {e}"
+
+    # 2) Fallback vía REST
+    try:
+        url = f"https://api-inference.huggingface.co/models/{HF_MODEL_ID}"
+        headers = {"Authorization": f"Bearer {HF_TOKEN}"}
+        payload = {
+            "inputs": prompt,
+            "parameters": {
+                "max_new_tokens": 600,
+                "do_sample": True,
+                "temperature": 0.7,
+                "top_p": 0.9,
+                "repetition_penalty": 1.05,
+                "return_full_text": False
+            }
+        }
+        r = requests.post(url, headers=headers, json=payload, timeout=180)
+        if r.status_code == 503:
+            return (f"[HF 503] El modelo {HF_MODEL_ID} está cargando o sin recurso. "
+                    f"Detalle: {r.text}")
+        r.raise_for_status()
+        data = r.json()
+        if isinstance(data, list) and data and "generated_text" in data[0]:
+            return data[0]["generated_text"].strip()
+        if isinstance(data, dict) and "generated_text" in data:
+            return data["generated_text"].strip()
+        if isinstance(data, dict) and "error" in data:
+            return f"[HF error] {data.get('error')}"
+        return f"[HF respuesta inesperada] {json.dumps(data)[:400]}..."
+    except Exception as e2:
+        err2 = f"[REST] {type(e2).__name__}: {e2}"
+        return f"[Error al llamar al modelo {HF_MODEL_ID}]\\n{err1}\\n{err2}"
+
+# ========== Utilidades Gradio ==========
+def items_schema() -> List[Dict[str, str]]:
+    return [{"code": it.code, "text": it.text, "dimension": DIMENSION_LABELS[it.dimension], "reverse": it.reverse} for it in ITEMS]
+
+def _ensure_outdir() -> Path:
+    out_dir = Path("mg360_resultados"); out_dir.mkdir(parents=True, exist_ok=True); return out_dir
+
+def _evaluate_internal(res_vals: List[int]):
+    schema = items_schema()
+    responses = { schema[i]["code"]: int(res_vals[i]) for i in range(len(schema)) }
+    scores = score_responses(responses)
+    inter  = interpret(scores)
+
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+    out_dir = _ensure_outdir()
+    out_json = out_dir / f"mg360_reporte_{ts}.json"
+    out_png  = out_dir / f"mg360_radar_{ts}.png"
+    radar_plot(scores, "Perfil MG360 (1–5)", str(out_png))
+
+    with open(out_json, "w", encoding="utf-8") as f:
+        json.dump({"responses": responses, "scores": scores, "interpretation": inter}, f, ensure_ascii=False, indent=2)
+
+    # Texto de resultados
+    md = [
+        "**Resultados**",
+        *(f"- {DIMENSION_LABELS[d]}: {scores[d]:.2f}/5" for d in ["COG","EMO","REL","EJE"]),
+        f"- **BALANCE 360**: {scores['BALANCE_360']:.3f}",
+        "",
+        "**Interpretación**",
+        f"- Equilibrio: {inter['equilibrio']}",
+        f"- Eje dominante: {inter['eje_dominante']}",
+    ]
+
+    # Plan de desarrollo (IA)
+    plan_prompt = build_prompt(scores, inter)
+    plan_text   = generate_plan_with_phi(plan_prompt)
+
+    return str(out_png), "\\n".join(md), json.dumps({"responses": responses, "scores": scores, "interpretation": inter}, ensure_ascii=False, indent=2), plan_text
+
+# ========== App Gradio ==========
+import gradio as gr
+
+schema = items_schema()
+with gr.Blocks() as demo:
+    gr.Markdown("# Test MG360 (24 ítems) — Versión Avanzada + Plan IA")
+    gr.Markdown("**Escala 1–5:** 1=**Nunca**, 2=**Rara vez**, 3=**A veces**, 4=**Frecuente**, 5=**Siempre**.")
+
+    with gr.Accordion("Cuestionario (24 ítems)", open=True):
+        gr.Markdown("### Guía de escala: 1=**Nunca** · 2=**Rara vez** · 3=**A veces** · 4=**Frecuente** · 5=**Siempre**")
+        sliders = [
+            gr.Slider(1, 5, step=1, value=3,
+                label=f"{it['code']} — {it['text']} (1 Nunca · 2 Rara vez · 3 A veces · 4 Frecuente · 5 Siempre)")
+            for it in schema
+        ]
+
+    with gr.Row():
+        btn = gr.Button("Evaluar", scale=1)
+        model_id = gr.Textbox(value=HF_MODEL_ID, label="HF_MODEL_ID (opcional)", scale=3)
+    img = gr.Image(type="filepath", label="Radar 4D (1–5)")
+    md  = gr.Markdown()
+    js  = gr.Code(language="json", label="Reporte (JSON)")
+    plan= gr.Markdown(label="Plan de desarrollo (IA)")
+
+    def evaluate(*vals):
+        # Permitir override del modelo por UI (no persiste, solo en sesión)
+        global HF_MODEL_ID
+        vals=list(vals)
+        HF_MODEL_ID = vals.pop() or HF_MODEL_ID
+        return _evaluate_internal(vals)
+
+    inputs = sliders + [model_id]
+    btn.click(fn=evaluate, inputs=inputs, outputs=[img, md, js, plan])
+
+# Para ejecución local:
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=4.44.0
+huggingface_hub>=0.24.0
+numpy>=1.26.0
+matplotlib>=3.8.0
+requests>=2.31.0