Update app.py

app.py

@@ -14,10 +14,10 @@ login(os.environ["HF_TOKEN"])
 
 # ———————————————————  CONFIG  ——————————————————— #
 SPACE_ID   = "melvinalves/protein_function_prediction"
-TOP_N      = 20      # top-20
+TOP_N      = 20
 THRESH     = 0.37
-CHUNK_PB   = 512      # janela ProtBERT
-CHUNK_ESM  = 1024     # janela ESM-2
+CHUNK_PB   = 512
+CHUNK_ESM  = 1024
 
 # repositórios HF
 FINETUNED_PB   = ("melvinalves/FineTune", "fineTunedProtbert")
@@ -36,14 +36,10 @@ def load_keras(name):
     """Carrega modelos Keras (MLPs e stacking)."""
     return load_model(download_file(f"models/{name}"), compile=False)
 
-# ---------- carregar tokenizer + encoder ----------
 @st.cache_resource
 def load_hf_encoder(repo_id, subfolder=None, base_tok=None):
     """
-    • repo_id   : repositório HF ou caminho local
-    • subfolder : subpasta (None se não houver)
-    • base_tok  : repo para o tokenizer (None => usa repo_id)
-    Converte tf_model.h5 → PyTorch on-the-fly (from_tf=True).
+    Carrega tokenizer + encoder HF (converte TF-weights p/ PyTorch on-the-fly).
     """
     if base_tok is None:
         base_tok = repo_id
@@ -56,17 +52,15 @@ def load_hf_encoder(repo_id, subfolder=None, base_tok=None):
     mdl.eval()
     return tok, mdl
 
-# ---------- extrair embedding ----------
 def embed_seq(model_ref, seq, chunk):
     """
-    • model_ref = string (modelo base) ou tuple(repo_id, subfolder) (fine-tuned)
-    Retorna embedding CLS médio (se a sequência for dividida em chunks).
+    Devolve embedding CLS médio (divide seq. longa em chunks se necessário).
     """
-    if isinstance(model_ref, tuple):                # ProtBERT fine-tuned
+    if isinstance(model_ref, tuple):                       # ProtBERT fine-tuned
         repo_id, subf = model_ref
         tok, mdl = load_hf_encoder(repo_id, subfolder=subf,
                                    base_tok="Rostlab/prot_bert")
-    else:                                           # modelo base (ESM-2)
+    else:                                                  # modelo base ESM-2
         tok, mdl = load_hf_encoder(model_ref)
 
     parts = [seq[i:i+chunk] for i in range(0, len(seq), chunk)]
@@ -80,9 +74,8 @@ def embed_seq(model_ref, seq, chunk):
 
 @st.cache_resource
 def load_go_info():
-    """Lê GO.obo e devolve dicionário id → (name, definition)."""
-    obo_path = download_file("data/go.obo")
-    dag = GODag(obo_path, optional_attrs=["defn"])
+    """Lê GO.obo e devolve {id: (name, definition bruta)}."""
+    dag = GODag(download_file("data/go.obo"), optional_attrs=["defn"])
     return {tid: (term.name, term.defn) for tid, term in dag.items()}
 
 GO_INFO = load_go_info()
@@ -100,72 +93,68 @@ GO       = mlb.classes_
 st.set_page_config(page_title="Predição de Funções Moleculares de Proteínas",
                    page_icon="🧬", layout="centered")
 
-# CSS: fundo branco e separador vertical
 st.markdown(
     """
     <style>
-        /* traço vertical entre colunas dentro dos expanders */
+        body, .stApp { background:#FFFFFF !important; }
+        .block-container { padding-top:1.5rem; }
+        textarea { font-size:0.9rem !important; }
         div[data-testid="column"]:first-child {
-            border-right:1px solid #000000;
-            padding-right:1rem !important;
+            border-right:1px solid #E0E0E0; padding-right:1rem !important;
         }
     </style>
     """,
     unsafe_allow_html=True
 )
 
-# Logo (logo.png na raiz do Space)
 if os.path.exists("logo.png"):
     st.image("logo.png", width=180)
 
 st.title("Predição de Funções Moleculares de Proteínas (GO:MF)")
 
-fasta_input = st.text_area("Insere uma ou mais sequências FASTA:", height=300)
-predict_clicked = st.button("Prever GO terms")
+fasta_input      = st.text_area("Insere uma ou mais sequências FASTA:", height=300)
+predict_clicked  = st.button("Prever GO terms")
 
-# ———————————————————  PARSE FASTA  ——————————————————— #
-def parse_fasta_multiple(fasta_str):
-    """
-    Devolve lista de (header, seq). Suporta bloco inicial sem '>'.
-    """
-    entries, parsed = fasta_str.strip().split(">"), []
-    for i, entry in enumerate(entries):
-        if not entry.strip():
+# ———————————————————  UTILITÁRIOS  ——————————————————— #
+def parse_fasta_multiple(text):
+    """Extrai [(header, seq)] de texto FASTA (bloco inicial sem '>' suportado)."""
+    out, blocks = [], text.strip().split(">")
+    for i, blk in enumerate(blocks):
+        if not blk.strip():
             continue
-        lines = entry.strip().splitlines()
-        if i > 0:  # bloco FASTA normal
-            header = lines[0].strip()
-            seq = "".join(lines[1:]).replace(" ", "").upper()
-        else:      # sequência sem '>'
-            header = f"Seq_{i+1}"
-            seq = "".join(lines).replace(" ", "").upper()
+        lines = blk.strip().splitlines()
+        if i > 0:
+            header, seq = lines[0].strip(), "".join(lines[1:]).replace(" ", "").upper()
+        else:
+            header, seq = f"Seq_{i+1}", "".join(lines).replace(" ", "").upper()
         if seq:
-            parsed.append((header, seq))
-    return parsed
+            out.append((header, seq))
+    return out
+
+def clean_definition(defin: str) -> str:
+    """Remove '\"', blocos [ ... ] e múltiplos espaços."""
+    defin = re.sub(r"\\[[^\\]]*\\]", "", defin or "")   # tira citações [...]
+    defin = defin.replace('"', "")                      # tira aspas
+    defin = re.sub(r"\\s{2,}", " ", defin)              # colapsa espaços
+    return defin.strip()
 
-# ———————————————————  LIGAÇÕES  ——————————————————— #
 def go_link(go_id, name=""):
-    """Link QuickGO."""
     url = f"https://www.ebi.ac.uk/QuickGO/term/{go_id}"
     return f"[{go_id} — {name}]({url})" if name else f"[{go_id}]({url})"
 
 # ———————————————————  MOSTRAR RESULTADOS  ——————————————————— #
 def mostrar(header, y_pred):
-    """Expander com botão UniProt e 2 colunas (≥0.37 | Top-20)."""
     pid      = header.split()[0]
     uniprot  = f"https://www.uniprot.org/uniprotkb/{pid}"
 
     with st.expander(header, expanded=True):
-        # botão UniProt
         st.markdown(
             f"""
             <div style="text-align:right;margin-bottom:0.5rem">
               <a href="{uniprot}" target="_blank">
                 <button style="background:#2b8cbe;border:none;border-radius:4px;
                                padding:0.35rem 0.8rem;color:#fff;font-size:0.9rem;
-                               cursor:pointer">
-                   Visitar UniProt
-                </button>
+                               cursor:pointer">Visitar UniProt</button>
               </a>
             </div>
             """,
@@ -174,26 +163,24 @@ def mostrar(header, y_pred):
 
         col1, col2 = st.columns(2)
 
-        # coluna 1 — GO terms acima do threshold
+        # --- coluna 1 : ≥ threshold
         with col1:
             st.markdown(f"**GO terms com prob ≥ {THRESH}**")
             hits = mlb.inverse_transform((y_pred >= THRESH).astype(int))[0]
             if hits:
                 for go_id in hits:
-                    name, defin = GO_INFO.get(go_id, ("— sem nome —", ""))
-                    # limpeza: remove [ … ], aspas e espaços extra
-                    defin = re.sub(r"\\[[^\\]]*\\]", "", defin or "")
-                    defin = defin.strip(' "')
+                    name, defin_raw = GO_INFO.get(go_id, ("— sem nome —", ""))
+                    defin = clean_definition(defin_raw)
                     st.markdown(f"- {go_link(go_id, name)}")
                     if defin:
                         st.caption(defin)
             else:
                 st.code("— nenhum —")
 
-        # coluna 2 — top-20
+        # --- coluna 2 : Top-20
         with col2:
             st.markdown(f"**Top {TOP_N} GO terms mais prováveis**")
-            for rank, idx in enumerate(np.argsort(-y_pred[0])[:TOP_N], start=1):
+            for rank, idx in enumerate(np.argsort(-y_pred[0])[:TOP_N], 1):
                 go_id = GO[idx]
                 name, _ = GO_INFO.get(go_id, ("", ""))
                 st.markdown(f"{rank}. {go_link(go_id, name)} : {y_pred[0][idx]:.4f}")
@@ -202,22 +189,19 @@ def mostrar(header, y_pred):
 if predict_clicked:
     for header, seq in parse_fasta_multiple(fasta_input):
         with st.spinner(f"A processar {header}… (pode demorar alguns minutos)"):
-            # embeddings
             emb_pb  = embed_seq(FINETUNED_PB,  seq, CHUNK_PB)
             emb_bfd = embed_seq(FINETUNED_BFD, seq, CHUNK_PB)
             emb_esm = embed_seq(BASE_ESM,       seq, CHUNK_ESM)
 
-            # predições
             y_pb  = mlp_pb.predict(emb_pb)
             y_bfd = mlp_bfd.predict(emb_bfd)
             y_esm = mlp_esm.predict(emb_esm)[:, :597]
 
-            # stacking
             y_ens = stacking.predict(np.concatenate([y_pb, y_bfd, y_esm], axis=1))
 
         mostrar(header, y_ens)
 
-# ———————————————————  LISTA COMPLETA DOS 597 TERMOS  ——————————————————— #
+# ———————————————————  LISTA COMPLETA (597)  ——————————————————— #
 with st.expander("Mostrar lista completa dos 597 GO terms possíveis", expanded=False):
     cols = st.columns(3)
     for i, go_id in enumerate(GO):