08_executive_conclusion__portfolio_packaging

from pathlib import Path
import json

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

pd.set_option("display.max_columns", 200)
pd.set_option("display.max_rows", 200)
pd.set_option("display.max_colwidth", 200)

PROJECT_ROOT = Path.cwd().resolve().parents[0]

ARTIFACTS_DIR = PROJECT_ROOT / "artifacts"
REPORTS_DIR = ARTIFACTS_DIR / "reports"
FIGURES_DIR = ARTIFACTS_DIR / "figures"

MODELS_DIR = PROJECT_ROOT / "models"
BASELINE_MODELS_DIR = MODELS_DIR / "baseline"
TRANSFORMER_MODELS_DIR = MODELS_DIR / "transformer"

DOCS_DIR = PROJECT_ROOT / "docs"

DOCS_DIR.mkdir(parents=True, exist_ok=True)

print("PROJECT_ROOT          :", PROJECT_ROOT)
print("REPORTS_DIR           :", REPORTS_DIR)
print("FIGURES_DIR           :", FIGURES_DIR)
print("BASELINE_MODELS_DIR   :", BASELINE_MODELS_DIR)
print("TRANSFORMER_MODELS_DIR:", TRANSFORMER_MODELS_DIR)
print("DOCS_DIR              :", DOCS_DIR)

baseline_metrics_path = REPORTS_DIR / "baseline_test_metrics.csv"
transformer_metrics_path = REPORTS_DIR / "transformer_test_metrics.csv"
delta_path = REPORTS_DIR / "baseline_vs_transformer_metric_deltas.csv"
class_comparison_path = REPORTS_DIR / "baseline_vs_transformer_class_comparison.csv"
recommendation_path = REPORTS_DIR / "deployment_recommendation_table.csv"
error_summary_path = REPORTS_DIR / "model_error_summary.csv"
transformer_pred_distribution_path = REPORTS_DIR / "transformer_prediction_distribution.csv"

baseline_metadata_path = BASELINE_MODELS_DIR / "baseline_metadata.json"
transformer_metadata_path = TRANSFORMER_MODELS_DIR / "transformer_metadata.json"

baseline_metrics_df = pd.read_csv(baseline_metrics_path)
transformer_metrics_df = pd.read_csv(transformer_metrics_path)
delta_df = pd.read_csv(delta_path)
class_comparison_df = pd.read_csv(class_comparison_path, index_col=0)
recommendation_df = pd.read_csv(recommendation_path)
error_summary_df = pd.read_csv(error_summary_path)
transformer_pred_distribution_df = pd.read_csv(transformer_pred_distribution_path)

with open(baseline_metadata_path, "r", encoding="utf-8") as f:
    baseline_metadata = json.load(f)

with open(transformer_metadata_path, "r", encoding="utf-8") as f:
    transformer_metadata = json.load(f)

print("baseline_metrics_df            :", baseline_metrics_df.shape)
print("transformer_metrics_df         :", transformer_metrics_df.shape)
print("delta_df                       :", delta_df.shape)
print("class_comparison_df            :", class_comparison_df.shape)
print("recommendation_df              :", recommendation_df.shape)
print("error_summary_df               :", error_summary_df.shape)
print("transformer_pred_distribution_df:", transformer_pred_distribution_df.shape)

project_summary_df = pd.DataFrame(
    [
        [
            "Problema de negócio",
            "Apoiar a triagem inteligente de perguntas e demandas textuais em contexto financeiro."
        ],
        [
            "Tarefa analítica principal",
            "Classificação textual multiclasses de perguntas financeiras."
        ],
        [
            "Dataset principal",
            "FAQ_BACEN em português, com perguntas, categorias e respostas."
        ],
        [
            "Abordagem metodológica",
            "CRISP-DM+ Lean com Ontologia, BLM e hipóteses semânticas."
        ],
        [
            "Modelos avaliados",
            "Baseline TF-IDF + Logistic Regression e Transformer."
        ],
        [
            "Deployment inicial proposto",
            "Baseline com inferência via API e logging de predições."
        ],
    ],
    columns=["dimensao", "descricao"]
)

project_summary_df

project_timeline_df = pd.DataFrame(
    [
        ["Notebook 01", "Business Understanding", "Definição do problema, objetivos, Ontologia e BLM"],
        ["Notebook 02", "Data Understanding", "Leitura do FAQ_BACEN, análise estrutural e exploração inicial"],
        ["Notebook 03", "Data Preparation", "Limpeza textual, padronização de labels e geração de silver/gold"],
        ["Notebook 04", "Modeling Baseline", "Treino e avaliação do baseline com TF-IDF + Logistic Regression"],
        ["Notebook 05", "Modeling Advanced", "Experimento com transformer para comparação com o baseline"],
        ["Notebook 06", "Evaluation & Business Interpretation", "Comparação, diagnóstico e decisão técnica"],
        ["Notebook 07", "Deployment & Monitoring", "Preparação para inferência, logging e API readiness"],
        ["Notebook 08", "Executive Conclusion", "Fechamento executivo e empacotamento para portfólio"],
    ],
    columns=["notebook", "etapa", "entrega_principal"]
)

project_timeline_df

plt.figure(figsize=(11, 5))
plt.bar(project_timeline_df["notebook"], np.arange(1, len(project_timeline_df) + 1))
plt.title("Linha do tempo lógica do projeto")
plt.xlabel("Notebook")
plt.ylabel("Ordem de execução")
plt.tight_layout()
plt.show()

baseline_metrics = baseline_metrics_df.iloc[0].to_dict()
transformer_metrics = transformer_metrics_df.iloc[0].to_dict()

final_metrics_comparison_df = pd.DataFrame(
    [
        {"model": "baseline_tfidf_logreg", **baseline_metrics},
        {"model": "transformer_bertimbau", **transformer_metrics},
    ]
)

final_metrics_comparison_df

final_metrics_comparison_df.style.format(
    {
        "accuracy": "{:.4f}",
        "macro_f1": "{:.4f}",
        "weighted_f1": "{:.4f}",
        "macro_precision": "{:.4f}",
        "macro_recall": "{:.4f}",
    }
)

delta_df.style.format(
    {
        "baseline": "{:.4f}",
        "transformer": "{:.4f}",
        "delta_transformer_minus_baseline": "{:+.4f}",
    }
)

plt.figure(figsize=(9, 5))
plt.bar(delta_df["metric"], delta_df["delta_transformer_minus_baseline"])
plt.axhline(0, linewidth=1)
plt.title("Delta do transformer em relação ao baseline")
plt.xlabel("Métrica")
plt.ylabel("Transformer - Baseline")
plt.tight_layout()
plt.show()

transformer_pred_distribution_df.head(20)

transformer_diagnosis_df = pd.DataFrame(
    [
        ["Classes previstas pelo transformer no teste", int(transformer_pred_distribution_df.shape[0])],
        ["Classe dominante prevista", transformer_pred_distribution_df.iloc[0]["pred_label"]],
        ["Ocorrências da classe dominante", int(transformer_pred_distribution_df.iloc[0]["count"])],
        ["Status interpretativo", "Colapso para classe dominante"],
    ],
    columns=["dimensao", "valor"]
)

transformer_diagnosis_df

recommendation_df

portfolio_value_df = pd.DataFrame(
    [
        [
            "Valor técnico",
            "Demonstra comparação entre baseline e transformer com decisão orientada por evidência."
        ],
        [
            "Valor metodológico",
            "Mostra pipeline completo de NLP com CRISP-DM+ , Ontologia, BLM e camadas bronze/silver/gold."
        ],
        [
            "Valor operacional",
            "Entrega readiness para deployment com logging, monitoramento inicial e desenho de API."
        ],
        [
            "Valor de negócio",
            "Apoia triagem inteligente de perguntas financeiras com foco em simplicidade, rastreabilidade e governança."
        ],
    ],
    columns=["dimensao", "descricao"]
)

portfolio_value_df

executive_summary_text = """
Projeto de NLP aplicado ao domínio financeiro para classificação multiclasses de perguntas e demandas textuais.
A solução foi estruturada com CRISP-DM+, incluindo Ontologia, BLM, preparação em camadas e comparação entre baseline e transformer.
O baseline TF-IDF + Logistic Regression apresentou melhor desempenho e foi escolhido para o deployment inicial.
O experimento transformer foi mantido como trilha futura de evolução, após diagnóstico de colapso para classe dominante na formulação atual.
""".strip()

print(executive_summary_text)

portfolio_highlights_df = pd.DataFrame(
    [
        ["Dataset em português do domínio financeiro"],
        ["Uso de Ontologia e BLM na Etapa 0"],
        ["Pipeline bronze / silver / gold"],
        ["Baseline forte com TF-IDF + Logistic Regression"],
        ["Experimento com transformer e diagnóstico técnico honesto"],
        ["Comparação orientada por Macro F1"],
        ["Decisão técnica baseada em evidência"],
        ["Preparação para deployment com logging e API readiness"],
    ],
    columns=["highlight"]
)

portfolio_highlights_df

next_steps_df = pd.DataFrame(
    [
        ["Implementar API FastAPI executável com endpoint /predict"],
        ["Adicionar healthcheck e model-info"],
        ["Evoluir logging para camada mais robusta"],
        ["Executar nova rodada transformer com target reagrupado"],
        ["Criar dashboard simples de monitoramento"],
    ],
    columns=["proximo_passo"]
)

next_steps_df

executive_summary_path = DOCS_DIR / "executive_summary.txt"
portfolio_highlights_path = REPORTS_DIR / "portfolio_highlights.csv"
next_steps_path = REPORTS_DIR / "project_next_steps.csv"
portfolio_value_path = REPORTS_DIR / "portfolio_value_table.csv"
project_timeline_path = REPORTS_DIR / "project_timeline_table.csv"
project_summary_path = REPORTS_DIR / "project_summary_table.csv"

with open(executive_summary_path, "w", encoding="utf-8") as f:
    f.write(executive_summary_text)

portfolio_highlights_df.to_csv(portfolio_highlights_path, index=False)
next_steps_df.to_csv(next_steps_path, index=False)
portfolio_value_df.to_csv(portfolio_value_path, index=False)
project_timeline_df.to_csv(project_timeline_path, index=False)
project_summary_df.to_csv(project_summary_path, index=False)

print("Artefatos executivos salvos com sucesso:")
print(executive_summary_path)
print(portfolio_highlights_path)
print(next_steps_path)
print(portfolio_value_path)
print(project_timeline_path)
print(project_summary_path)

#!uv pip install nbconvert -U -q
!jupyter nbconvert --to html --template-file my-template-html-v10.tpl 08_executive_conclusion__portfolio_packaging.ipynb