Diseño de binders proteicos con BindCraft2: ¿cómo generar y puntuar binders específicos de diana?

Diseñar un binder proteico que reconozca una diana con alta afinidad y alta especificidad es una necesidad central en biología y medicina, y hacerlo a partir de una estructura diana sola, sin largas rondas de optimización experimental, eliminaría un cuello de botella importante. Identificar candidatos de alta afinidad sigue siendo un cuello de botella porque el diseño de binders normalmente requiere generar y cribar virtualmente miles de diseños para recuperar unos pocos aciertos prometedores [5]. Esto significa que cualquier pipeline que pueda elevar la fracción de diseños generados computacionalmente que resultan unirse en el laboratorio húmedo tiene valor práctico directo: hay que sintetizar y probar menos diseños, lo que ahorra tiempo y coste de reactivos.

Dos familias de enfoques computacionales abordan este problema. Los enfoques basados en estructura, como RFDiffusion y AlphaProteo, pueden generar esqueletos de binder condicionados a una estructura diana [5]. Una familia separada, los métodos basados en alucinación, optimiza una estructura directamente dentro de una red de predicción de estructura en lugar de muestrear de un modelo generativo de esqueletos. BindCraft es un método de diseño de binders basado en alucinación que aprovecha la red AlphaFold2 [5]. Esta distinción importa para un constructor porque determina qué software y qué pesos se necesitan: un método de alucinación necesita un predictor de estructura diferenciable y un bucle de optimización basado en gradiente, mientras que un método de difusión de esqueletos necesita un modelo de difusión entrenado más un paso separado de diseño de secuencia.

La cuestión de qué tan buenos son realmente estos binders una vez sintetizados es separada de cómo funciona el pipeline, y la evidencia sobre este punto es desigual entre artículos. BindCraft ha reportado tasas de éxito experimental que van del 10% al 100% [7], que es un rango amplio que depende en gran medida de la clase de diana. Las puntuaciones de confianza de modelos de predicción de estructura, particularmente pTM de interfaz (ipTM), correlacionan con la fuerza de unión [5], pero la correlación de métricas de confianza como pLDDT, ipTM e ipAE con resultados experimentales de unión se ha validado solo en conjuntos de datos limitados y sigue siendo poco entendida entre dianas y regímenes de diseño [6]. Por lo tanto, un constructor no debería tratar ningún número de confianza individual como prueba de unión, solo como un filtro que ha mostrado cierta correlación en algunos entornos.

Debido a esta brecha entre la confianza in silico y el resultado de laboratorio húmedo, los esfuerzos de benchmark y las mejoras de funciones de puntuación se han convertido en áreas activas de trabajo junto con los propios pipelines generativos. BindEnergyCraft se construyó específicamente para dar una señal de optimización más densa y más informativa que ipTM [5], y ProtDBench se construyó para dar un protocolo de evaluación estandarizado con múltiples verificadores para comparar binders generados [6]. Juntos, estos dos hilos, mejores objetivos de optimización y mejores benchmarks, son lo que un desarrollador necesita entender antes de decidir qué pipeline y qué función de puntuación adoptar para una diana dada.

BindCraft es un pipeline de código abierto y automatizado para el diseño de binders proteicos de novo [7]. Aprovecha los pesos de AlphaFold2 para generar binders proteicos a partir de estructuras diana [7]. Esto significa que el usuario no entrena un modelo nuevo: en su lugar, el pipeline ejecuta un procedimiento de optimización dentro del grafo de cómputo existente de AlphaFold2, tratando partes de la entrada (la secuencia o estructura del binder) como variables libres y todo lo demás (la estructura diana) como fijo.

El pipeline se ha aplicado ampliamente. BindCraft se aplicó a receptores de superficie celular, alérgenos comunes, proteínas diseñadas de novo y nucleasas multidominio como CRISPR-Cas9 [7]. En varias de estas aplicaciones, se mostró que los binders diseñados tienen efectos funcionales más allá de la simple unión. Se reportó que binders diseñados reducen la unión de IgE al alérgeno de abedul, modulan la actividad de edición génica de Cas9, reducen la citotoxicidad de una enterotoxina bacteriana de origen alimentario y redirigen cápsides de virus adenoasociado para la entrega génica dirigida [7]. En una demostración, BindCraft generó binders con afinidad nanomolar sin cribado de alto rendimiento ni optimización experimental, incluso para dianas sin sitios de unión conocidos [7].

Grupos independientes han sometido desde entonces a BindCraft a pruebas de estrés en clases de dianas específicas para ver qué tan bien se sostienen estas afirmaciones fuera del artículo original. Para MDM2, BindCraft generó 70 péptidos únicos, se sintetizaron 15 y 7 mostraron unión específica con afinidades nanomolares [12]. Ensayos de competición confirmaron la unión sitio-específica de los péptidos de MDM2 en el sitio diana previsto [12], lo cual es una comprobación importante porque una unión que no es sitio-específica no sería útil para la mayoría de las aplicaciones. Para WDR5, seis de nueve candidatos se unieron al sitio WBM de unión a MYC con afinidad submicromolar [12], y la modificación química racional mejoró la potencia de un binder de WDR5 seis veces hasta una KD de 39 nM [12]. Esto muestra que las salidas de BindCraft pueden servir como punto de partida para una optimización químico-medicinal posterior, no solo como respuesta final. Sin embargo, ninguno de los péptidos generados por BindCraft probados para PD-1 y PD-L1 mostró unión detectable [12], lo que es un contraejemplo directo que muestra que el éxito depende de la diana y no está garantizado. BindCraft puede generar péptidos de alta afinidad únicamente a partir de una estructura diana [12], pero el resultado de PD-1/PD-L1 muestra que esta capacidad no se transfiere uniformemente a todas las dianas.

A mayor escala, el Human Bindome incorpora el método BindCraft evaluado experimentalmente en un marco acelerado y paralelizado con selección automatizada de dianas a nivel de dominio [13]. Usando este marco, se generaron 306,146 candidatos de binder para 8,296 proteínas humanas, cubriendo el 40.9% del proteoma completo [13]. Cada candidato del Human Bindome incluye una secuencia definida, un modelo de estructura binder-diana predicho y métricas de confianza in silico [13], lo que da a un constructor una plantilla de lo que debe contener un registro de candidato al ejecutar un pipeline a escala.

BindCraft alucina estructuras de binder con AlphaFold2 y realiza optimización basada en gradiente de la puntuación TM prevista de la interfaz (ipTM), entre otras pérdidas [5]. En la práctica, esto significa que la secuencia del binder (e implícitamente su estructura, tal como la predice AlphaFold2) se actualiza iterativamente mediante descenso de gradiente para aumentar la puntuación ipTM que AlphaFold2 asigna al complejo binder-diana predicho, junto con otros términos de pérdida. Este es un mecanismo fundamentalmente diferente del de un modelo de difusión que muestrea un esqueleto y luego diseña una secuencia para él: aquí la propia red de predicción de estructura actúa como la función objetivo que se optimiza.

La elección de ipTM como objetivo principal de optimización tiene una debilidad conocida. ipTM no refleja directamente la probabilidad estadística de la interacción completa binder-diana [5]. Esto importa porque el objetivo del diseño de binders es encontrar secuencias que probablemente se plieguen realmente en un complejo estable y correctamente acoplado, y una puntuación que no sigue esta probabilidad puede empujar al optimizador hacia estructuras que parecen confiadas para la puntuación pero que no son necesariamente complejos físicamente favorables.

La razón mecánica específica de esta debilidad está en cómo se calcula ipTM. Debido a que ipTM calcula un máximo sobre índices de residuos de la diana, produce gradientes dispersos concentrados solo en un pequeño subconjunto de pares de residuos de interfaz [5]. En optimización basada en gradiente, un gradiente disperso significa que solo unas pocas posiciones en la estructura reciben una señal de actualización significativa en cada paso, mientras que la mayoría de la interfaz no está directamente moldeada por el objetivo. Esto puede llevar a diseños que satisfacen la puntuación en unos pocos pares de residuos sin que el resto de la interfaz esté bien formado, lo cual es una razón plausible de choques estructurales o mala calidad general del complejo en diseños generados.

Este diagnóstico mecanístico, hecho explícito en el artículo de BindEnergyCraft, es lo que motivó la búsqueda de una función de puntuación alternativa que dé una señal de gradiente más densa en toda la interfaz en lugar de una dispersa. El resto del marco de optimización, el bucle de alucinación basado en AlphaFront2 y el concepto general de actualizaciones de estructura y secuencia basadas en gradiente, se conserva; solo necesita cambiar la puntuación de interfaz que se optimiza.

pTMEnergy reinterpreta los logits del error de alineamiento predicho (pAE) de AlphaFold como un modelo basado en energía sobre complejos binder-diana [5]. En lugar de tomar un único resumen escalar (como hace ipTM, mediante una operación de máximo sobre pares de residuos), pTMEnergy trata la distribución completa de logits de pAE como definición de un paisaje de energía, dando una puntuación que en principio se nutre de información de toda la interfaz predicha en lugar de un pequeño subconjunto de ella.

pTMEnergy proporciona una señal densa y diferenciable destinada a reflejar la probabilidad de un complejo plegado bajo la distribución aprendida de AlphaFold [5]. Debido a que es diferenciable, puede sustituirse directamente en el mismo bucle de optimización basado en gradiente que BindCraft ya usa, sin necesitar un tipo diferente de optimizador. Esto ataca directamente la debilidad de gradiente disperso descrita arriba: una señal densa significa que más pares de residuos de interfaz contribuyen con un gradiente significativo en cada paso de optimización, en contraste con el cálculo de ipTM basado en máximo.

Un detalle de implementación clave para un constructor es que pTMEnergy se deriva de las mismas salidas de pAE usadas para calcular ipTM y no requiere llamadas adicionales al modelo ni modificaciones de arquitectura [5]. Esto significa que adoptar pTMEnergy no requiere reentrenar AlphaFold2 ni añadir nuevos componentes de red: los logits de pAE que AlphaFold2 ya produce simplemente se procesan de manera diferente para producir la nueva puntuación. Este es un punto práctico importante porque mantiene el coste computacional del pipeline modificado esencialmente igual que el del pipeline BindCraft original, ya que no se necesitan pasadas adicionales hacia delante o hacia atrás por un modelo diferente.

El método resultante, BindEnergyCraft, que conserva el marco de optimización de BindCraft mientras reemplaza ipTM por pTMEnergy, logró tasas de éxito in silico de binder más altas y redujo los choques estructurales en comparación con BindCraft, RFDiffusion y ESM3 en múltiples dianas desafiantes [5]. Esta es una comparación in silico, evaluada en las dianas desafiantes usadas en el benchmark de ese artículo; las afirmaciones de la fuente no reportan una comparación directa de laboratorio húmedo entre BindEnergyCraft y BindCraft, RFDiffusion o ESM3 sobre los mismos candidatos sintetizados, así que un constructor debería leer la mejora como un hallazgo computacional a nivel de benchmark más que como una ventaja experimental confirmada sobre estas alternativas específicas.

Debido a que se sabe que las puntuaciones de confianza de los modelos de predicción de estructura son proxies imperfectos de la unión real, y a que su fiabilidad está pobremente caracterizada entre dianas, se necesita un benchmark estandarizado para comparar métodos de diseño de binders y funciones de puntuación. ProtDBench es uno de esos benchmarks, construido específicamente para evaluar esqueletos de binder generados de manera reproducible y con múltiples verificadores.

ProtDBench evalúa esqueletos de binder generados muestreando múltiples secuencias para cada esqueleto, aplicando un verificador y un filtro a cada secuencia, y calculando la tasa de éxito por secuencia [6]. Este procedimiento separa dos etapas de diseño que a menudo se confunden: el paso de generación de esqueleto (que fija el plegamiento) y el paso de diseño de secuencia (que fija las identidades reales de aminoácidos enhebradas en ese plegamiento). Al muestrear varias secuencias por esqueleto, el benchmark puede distinguir esqueletos para los que es fácil diseñar buenas secuencias de esqueletos que solo tienen éxito ocasionalmente.

ProtDBench define el conjunto de esqueletos aprobados como los esqueletos para los que al menos una secuencia muestreada pasa el filtro [6]. Este es un criterio permisivo de mejor de muchos a nivel de esqueleto: un esqueleto cuenta como éxito si produjo al menos una buena secuencia, incluso si la mayoría de las secuencias muestreadas para él fallaron. ProtDBench agrupa solo los esqueletos aprobados por similitud estructural usando FoldSeek o TM-score [6], lo que permite al benchmark reportar no solo un recuento bruto de éxitos sino también cuán estructuralmente diversos son los diseños exitosos, evitando el caso en que todos los éxitos reportados son casi duplicados del mismo plegamiento.

Un hallazgo central de este trabajo de benchmark es una advertencia contra confiar demasiado en cualquier verificador único. ProtDBench reporta un sesgo sustancial dependiente del verificador y una concordancia limitada entre modelos de predicción de estructura usados como verificadores de evaluación [6]. Esto refuerza directamente el punto anterior de que ipTM y métricas de confianza relacionadas tienen correlación validada con unión real solo en conjuntos de datos limitados [6]: si diferentes modelos de predicción de estructura usados como verificadores discrepan sustancialmente entre sí, entonces una tasa de éxito calculada con un verificador (por ejemplo ipTM basado en AlphaFold2) no puede suponerse válida cuando se usa otro verificador (por ejemplo AlphaFold3) en su lugar. Para un constructor, esto significa que reportar resultados de un único verificador sin revelar cuál se usó, o sin contrastar con un segundo verificador, arriesga exagerar la confianza en un diseño.

No todos los pipelines de diseño de binders están basados en alucinación. Un flujo de trabajo separado, basado en estructura, ilustra tanto la promesa como la dificultad práctica de pasar de un diseño computacional a un binder validado. Un flujo de trabajo de diseño de binders dirigido por hotspots integró RFdiffusion, ProteinMPNN, AlphaFold, simulaciones de dinámica molecular y evaluación estructural manual [3]. Este flujo de trabajo combina un paso de difusión de esqueleto (RFdiffusion), un paso de diseño de secuencia (ProteinMPNN), una comprobación de confianza estructural (AlphaFold), un paso de simulación física (dinámica molecular) y revisión humana, lo que es un pipeline más pesado y más supervisado manualmente que el bucle automatizado de una sola red de BindCraft.

El flujo de trabajo dirigido por hotspots generó cuatro diseños de proteína que se sometieron a validación experimental [3]. Este es un número pequeño de diseños en relación con el

Los pipelines de diseño de binders recurren cada vez más a modelos de lenguaje de proteínas (pLM) como herramienta complementaria o alternativa de generación de secuencias. Los modelos de lenguaje de proteínas (pLM) están preentrenados con datos de secuencias evolutivas a gran escala y adaptan modelos de lenguaje grandes para secuencias biológicas [17]. Este es un mecanismo distinto de la alucinación basada en AlphaFold2 o de la generación de esqueletos basada en RFdiffusion: un pLM aprende patrones directamente de grandes bases de datos de secuencias en lugar de datos de entrenamiento estructural, y típicamente se usa para proponer o puntuar secuencias en lugar de coordenadas 3D.

Existen varias arquitecturas específicas dentro de esta familia, y un constructor que elija entre ellas debería conocer sus diferencias estructurales. ESM2 es un modelo transformer codificador estilo BERT, mientras que ProtGPT2 y ProGen2 son modelos transformer decodificadores estilo GPT y ProtT5 es un modelo transformer codificador-decodificador [17]. Un modelo solo codificador como ESM2 se usa típicamente para puntuar o incrustar una secuencia existente, un modelo solo decodificador como ProtGPT2 o ProGen2 se usa típicamente para generar nuevas secuencias de forma autorregresiva, y un modelo codificador-decodificador como ProtT5 puede usarse para tareas que mapean una representación de secuencia a otra. Ninguna de las afirmaciones citadas describe pLMs sustituidos directamente en el bucle de optimización de BindCraft o BindEnergyCraft, así que un constructor debería tratar la generación de secuencias basada en pLM como una herramienta separada y complementaria para proponer o filtrar secuencias candidatas, no como un reemplazo directo documentado de la alucinación basada en AlphaFold2 en estos pipelines específicos.

La limitación central para cualquiera que construya sobre esta literatura es que las puntuaciones de confianza no son prueba de unión. La correlación de métricas de confianza como pLDDT, ipTM e ipAE con resultados experimentales de unión se ha validado solo en conjuntos de datos limitados y sigue siendo poco entendida entre dianas y regímenes de diseño [6]. Esto significa que una puntuación alta de ipTM o pTMEnergy debe leerse como un filtro que aumenta la probabilidad de encontrar un acierto, no como una garantía, y cualquier tasa de éxito reportada está ligada a la clase de diana específica y al conjunto de datos en que se midió.

ipTM en sí mismo conlleva una debilidad mecanística conocida. ipTM no refleja directamente la probabilidad estadística de la interacción completa binder-diana [5], y debido a que calcula un máximo sobre índices de residuos de la diana, produce gradientes dispersos concentrados solo en un pequeño subconjunto de pares de residuos de interfaz [5]. Esta es una razón mecanística específica para preferir pTMEnergy como objetivo de optimización al reproducir pipelines estilo BindCraft, aunque la comparación entre BindEnergyCraft y BindCraft en dianas reales de laboratorio húmedo no se ha reportado en las afirmaciones citadas, solo la comparación in silico entre dianas de benchmark [5].

Diferentes elecciones de benchmark y verificador también complican cualquier comparación entre artículos. ProtDBench reporta un sesgo sustancial dependiente del verificador y una concordancia limitada entre modelos de predicción de estructura usados como verificadores de evaluación [6], así que las tasas de éxito calculadas con diferentes verificadores, o reportadas por diferentes artículos usando diferentes pipelines, no pueden compararse directamente sin saber qué verificador se usó. De manera similar, los resultados en clases de dianas específicas no son uniformes: el mismo método general (BindCraft) tuvo éxito fuerte para MDM2 y WDR5 [12] pero produjo binders no detectables para PD-1 y PD-L1 [12], y un flujo de trabajo separado dirigido por hotspots que usó herramientas totalmente diferentes (RFdiffusion, ProteinMPNN, AlphaFold, dinámica molecular [3]) tuvo éxito solo en uno de cuatro diseños contra el dominio LEDGF PWWP [3], con ese único éxito complicado por homodimerización no deseada [3]. Ninguno de estos resultados debería extrapolarse a dianas o condiciones no probadas directamente.

Finalmente, identificar candidatos de alta afinidad sigue siendo un cuello de botella porque el diseño de binders normalmente requiere generar y cribar virtualmente miles de diseños para recuperar unos pocos aciertos prometedores [5]. Incluso con una función de puntuación mejorada como pTMEnergy, o un esfuerzo de generación a gran escala como el Human Bindome que cubre el 40.9% del proteoma humano [13], la necesidad fundamental de filtrar un gran conjunto de candidatos hasta un pequeño número de diseños testables en laboratorio húmedo no ha sido eliminada por ninguno de los trabajos citados, solo parcialmente mitigada. Un desarrollador debería presupuestar este paso de filtrado y no debería esperar que ninguna puntuación in silico única elimine la necesidad de validación experimental.

1. Configura el entorno base de BindCraft. Instala el pipeline BindCraft de código abierto y automatizado para el diseño de binders proteicos de novo [7], que aprovecha los pesos de AlphaFold2 para generar binders proteicos a partir de estructuras diana [7]. Necesitarás pesos del modelo AlphaFold2 disponibles localmente y una pila de inferencia JAX/AlphaFold2 funcional, ya que el pipeline ejecuta optimización basada en gradiente dentro de esta red en lugar de llamar a una API externa.
2. Prepara la entrada de estructura diana. Obtén un archivo de estructura PDB para tu proteína diana. Si planeas reproducir un diseño dirigido por hotspots en su lugar, ten en cuenta que un flujo de trabajo publicado separado integró RFdiffusion, ProteinMPNN, AlphaFold, simulaciones de dinámica molecular y evaluación estructural manual [3] como alternativa a la alucinación de una sola red; decide de antemano cuál de las dos familias estás construyendo, ya que necesitan pilas de software diferentes.
3. Elige el objetivo de optimización. La pérdida predeterminada de BindCraft es una optimización basada en alucinación y basada en gradiente de la puntuación TM prevista de la interfaz (ipTM), entre otras pérdidas [5]. Si quieres la variante mejorada, reemplaza ipTM por pTMEnergy, que reinterpreta los logits del error de alineamiento predicho (pAE) de AlphaFold como un modelo basado en energía sobre complejos binder-diana [5] y no requiere llamadas adicionales al modelo ni modificaciones de arquitectura [5], ya que se deriva de salidas de pAE que ya calculas.
4. Ejecuta el bucle de optimización. Itera actualizaciones de gradiente sobre la secuencia/estructura del binder para aumentar la puntuación elegida (ipTM o pTMEnergy) contra la diana fija. Ten en cuenta que ipTM produce gradientes dispersos concentrados solo en un pequeño subconjunto de pares de residuos de interfaz [5], así que si observas choques o interfaces mal formadas fuera de unos pocos residuos de contacto, este es un modo de fallo conocido de la optimización basada en ipTM, y pTMEnergy es la mitigación documentada [5].
5. Genera un gran conjunto de candidatos. Debido a que identificar candidatos de alta afinidad sigue siendo un cuello de botella y normalmente requiere generar y cribar virtualmente miles de diseños para recuperar unos pocos aciertos prometedores [5], planifica tu presupuesto de cómputo para un lote de muchos candidatos por diana, no unos pocos.
6. Puntúa y filtra candidatos con modelos de predicción de estructura. Los modelos de predicción de estructura como AlphaFold2 y AlphaFold3 permiten la evaluación de unión sin estructuras cristalinas [5], y las puntuaciones de confianza, particularmente ipTM, correlacionan con la fuerza de unión [5]. Usa estas puntuaciones como filtro inicial, pero recuerda que esta correlación se ha validado solo en conjuntos de datos limitados [6].
7. Haz benchmark con un protocolo por secuencia y con múltiples verificadores. Sigue el enfoque de ProtDBench: muestrea múltiples secuencias por esqueleto generado, aplica un verificador y un filtro a cada secuencia, y calcula la tasa de éxito por secuencia [6]. Define tu conjunto de esqueletos aprobados como los esqueletos con al menos una secuencia que pasa el filtro [6], y agrupa solo los esqueletos aprobados por similitud estructural usando FoldSeek o TM-score [6] para comprobar la diversidad de diseños.
8. Contrasta con más de un verificador. Debido a que ProtDBench reporta un sesgo sustancial dependiente del verificador y una concordancia limitada entre modelos de predicción de estructura usados como verificadores [6], ejecuta tu filtro con al menos dos modelos de predicción de estructura diferentes y reporta ambos resultados en lugar de confiar en uno.
9. Selecciona una lista corta para síntesis. De tus candidatos filtrados y agrupados, elige una lista corta diversa para pruebas de laboratorio húmedo. Espera varianza dependiente de la diana: pruebas independientes encontraron que 7 de 15 péptidos de MDM2 sintetizados se unieron específicamente [12], 6 de 9 candidatos de WDR5 se unieron de forma submicromolar [12], pero ninguno de los péptidos de PD-1/PD-L1 probados se unió en absoluto [12], así que trata tu lista corta in silico como una hipótesis a probar, no como una garantía.
10. Valida experimentalmente. Usa un ensayo de unión biofísica (como el usado para confirmar afinidad baja micromolar para un binder del dominio LEDGF PWWP [3]) y, cuando sea relevante, un ensayo de competición para confirmar especificidad de sitio, como se hizo para los péptidos de MDM2 [3][12]. Vigila comportamientos inesperados como la homodimerización, que en un caso interfirió con la unión en solución pese a que la proteína seguía siendo cocristalizable con su diana a 2.1 Å de resolución [3].
11. Reporta resultados con condiciones completas. Al publicar o registrar tasas de éxito, indica siempre qué verificador, qué benchmark y qué clase de diana produjo el número, ya que tasas de éxito que van del 10% al 100% [7] y el hallazgo de discrepancia entre verificadores [6] significan que un número de tasa de éxito sin cualificar no es informativo por sí solo.

Esbozo de pseudocódigo del bucle central de alucinación con la opción pTMEnergy:

load target_structure from PDB file
initialize binder_sequence randomly
for step in range(num_steps):
    complex_pred = alphafold2_forward(binder_sequence, target_structure)
    if objective == "ipTM":
        loss = -complex_pred.ipTM
    elif objective == "pTMEnergy":
        loss = -pTMEnergy(complex_pred.pae_logits)
    grads = backprop(loss, wrt=binder_sequence)
    binder_sequence = update(binder_sequence, grads)
return binder_sequence, complex_pred.ipTM, complex_pred.pTMEnergy

El script de abajo implementa, sobre nuestros propios datos SQLite, una versión simplificada de las dos ideas de evaluación centrales de esta nota: (1) un cálculo estilo ProtDBench de tasa de éxito por secuencia y conjunto de esqueletos aprobados sobre candidatos generados (claims R and S), usando agrupamiento por similitud estructural de diseños aprobados mediante un proxy tipo TM-score (claim T), y (2) una comparación de dos funciones de puntuación análogas a ipTM frente a pTMEnergy (claims B, I, J, M, N, O, P), calculadas a partir de columnas de nuestra propia tabla `forecasts` (q10, q50, q90, p_up) que hacen las veces de puntuaciones estilo confianza, ya que nuestros datos no contienen logits pAE reales de AlphaFold ni valores ipTM. Debido a que nuestro esquema no tiene tablas de diseño de binders, tratamos cada fila de `forecasts` como un diseño candidato para un símbolo/diana, `p_up` como la puntuación de confianza dispersa estilo ipTM, y una combinación densa de la dispersión q10/q50/q90 como la puntuación densa estilo pTMEnergy (esta sustitución está claramente comentada en el código; es una demostración del método de comparación de puntuaciones, no una afirmación de que nuestros datos de mercado sean datos de proteínas). La línea base a superar es la tasa de éxito del filtro simple estilo ipTM; se espera que la puntuación densa estilo pTMEnergy dé un ranking más estable y menos disperso, lo cual comprobamos comparando cuántas características proxy de pares de residuos distintas (q10, q50, q90) varían realmente frente a cuánto del cambio de puntuación está impulsado por una sola característica (comprobación proxy de gradiente disperso frente a denso, claim J). El script también construye un pequeño informe estilo ProtDBench: tasa de éxito por candidato, tamaño del conjunto de esqueletos aprobados y un agrupamiento de juguete redondeando puntuaciones (proxy del agrupamiento FoldSeek/TM-score, claim T). Imprime sus números y compara con una tasa de éxito de línea base aleatoria. Todo se ejecuta sin conexión contra `data.sqlite` (o QOURAT_DB), termina en bastante menos de tres minutos en CPU, y no lanza excepciones si las tablas existen (crea un pequeño conjunto de datos sintético si el archivo no tiene datos, así que también es ejecutable de forma autónoma).

import os
import sqlite3
import sys
import time
import numpy as np
import pandas as pd

# ---------------------------------------------------------------------------
# Config
# ---------------------------------------------------------------------------
DB_PATH = os.environ.get("QOURAT_DB", "data.sqlite")
RNG = np.random.default_rng(0)


def get_connection(path):
    # Opens (or creates) the sqlite file. No network access needed.
    conn = sqlite3.connect(path)
    return conn


def ensure_tables(conn):
    # Creates the required tables if they do not exist yet, so the script
    # is runnable even against a fresh empty file. Schema matches the spec.
    cur = conn.cursor()
    cur.execute("""CREATE TABLE IF NOT EXISTS bars (
        symbol TEXT, tf TEXT, ts TEXT, open REAL, high REAL, low REAL,
        close REAL, volume REAL)""")
    cur.execute("""CREATE TABLE IF NOT EXISTS forecasts (
        symbol TEXT, horizon TEXT, made_at TEXT, q10 REAL, q50 REAL,
        q90 REAL, p_up REAL)""")
    cur.execute("""CREATE TABLE IF NOT EXISTS trades (
        symbol TEXT, ts TEXT, price REAL, size REAL, side TEXT)""")
    cur.execute("""CREATE TABLE IF NOT EXISTS book (
        symbol TEXT, ts TEXT, level INTEGER, bid_price REAL,
        bid_size REAL, ask_price REAL, ask_size REAL)""")
    conn.commit()


def maybe_seed_forecasts(conn):
    # If the forecasts table is empty, populate it with a small synthetic
    # set of "candidate designs" so the pipeline below has something to
    # score. This stands in for generated binder candidates: each row is
    # one candidate for one "target" (symbol), analogous to one sampled
    # sequence for one backbone in ProtDBench (claim R).
    df = pd.read_sql_query("SELECT COUNT(*) AS n FROM forecasts", conn)
    if df["n"].iloc[0] > 0:
        return
    symbols = ["AAPL", "MSFT", "BTC-USD"]
    rows = []
    for sym in symbols:
        for i in range(60):
            q50 = RNG.normal(0, 1)
            spread = abs(RNG.normal(0.5, 0.2)) + 0.01
            q10 = q50 - spread
            q90 = q50 + spread
            p_up = float(np.clip(RNG.normal(0.5, 0.2), 0, 1))
            rows.append((sym, "1d", f"2024-01-{(i % 28) + 1:02d}T00:00:00",
                         q10, q50, q90, p_up))
    conn.executemany(
        "INSERT INTO forecasts (symbol, horizon, made_at, q10, q50, q90, p_up) "
        "VALUES (?,?,?,?,?,?,?)", rows)
    conn.commit()


# ---------------------------------------------------------------------------
# Scoring functions
# ---------------------------------------------------------------------------

def sparse_score(row):
    # Proxy for ipTM-style scoring: BindCraft optimizes ipTM, a score that
    # computes a max over target residue indices and gives sparse
    # gradients concentrated on a small subset of interface pairs
    # (claims B and J). Here we proxy this by taking the single most
    # extreme of the three quantile-derived features, i.e. a max-like
    # operation over a small set of "residue pair" proxies (q10, q50, q90).
    feats = np.array([abs(row["q10"]), abs(row["q50"]), abs(row["p_up"] - 0.5)])
    return float(feats.max())


def dense_score(row):
    # Proxy for pTMEnergy-style scoring: pTMEnergy is derived from the same
    # underlying outputs (here: q10, q50, q90, p_up) but combines them into
    # a dense signal rather than taking a single max (claims M, N, O).
    # We use a simple mean of the same features, so every feature
    # contributes to the score, not just the largest one.
    feats = np.array([abs(row["q10"]), abs(row["q50"]), abs(row["q90"]),
                       abs(row["p_up"] - 0.5)])
    return float(feats.mean())


def gradient_sparsity(row):
    # Checks how much of the sparse score is driven by a single feature
    # versus spread across features, as a numeric illustration of claim J
    # (sparse gradients concentrated on a small subset of interface pairs).
    # Returns the fraction of total feature magnitude held by the largest
    # single feature: close to 1.0 means very sparse, close to 1/n means
    # evenly dense.
    feats = np.array([abs(row["q10"]), abs(row["q50"]), abs(row["q90"]),
                       abs(row["p_up"] - 0.5)])
    total = feats.sum()
    if total = threshold
    per_seq_success_rate = float(df["passes"].mean())

    backbone_groups = df.groupby("symbol")
    passing_backbones = []
    for symbol, group in backbone_groups:
        if group["passes"].any():
            passing_backbones.append(symbol)
    passing_backbone_set = set(passing_backbones)

    return per_seq_success_rate, passing_backbone_set, df


def cluster_passing_backbones(df, passing_backbone_set):
    # Proxy for claim T: ProtDBench clusters only passing backbones by
    # structural similarity using FoldSeek or TM-score. We do not have
    # real structures, so we use a simple proxy: cluster passing backbones
    # by rounding their mean score to one decimal place, as a stand-in
    # for a structural-similarity bucket.
    passing_df = df[df["symbol"].isin(passing_backbone_set)]
    if len(passing_df) == 0:
        return {}
    means = passing_df.groupby("symbol")["score"].mean()
    clusters = {}
    for symbol, m in means.items():
        key = round(m, 1)
        clusters.setdefault(key, []).append(symbol)
    return clusters


# ---------------------------------------------------------------------------
# Baseline: random scoring, to check the two methods beat pure chance
# ---------------------------------------------------------------------------

def random_baseline_success_rate(n_rows, threshold, n_trials=200):
    # A simple baseline: if scores were pure random noise in [0, 1.5],
    # what fraction would pass the threshold? This is the number to beat.
    rates = []
    for _ in range(n_trials):
        fake_scores = RNG.uniform(0, 1.5, size=n_rows)
        rates.append(float((fake_scores >= threshold).mean()))
    return float(np.mean(rates))


def main():
    start = time.time()
    conn = get_connection(DB_PATH)
    ensure_tables(conn)
    maybe_seed_forecasts(conn)

    df = pd.read_sql_query(
        "SELECT symbol, horizon, made_at, q10, q50, q90, p_up FROM forecasts",
        conn)
    conn.close()

    if len(df) == 0:
        print("No forecast rows found even after seeding, aborting.")
        sys.exit(1)

    threshold = 0.5  # fixed filter threshold for both scoring functions

    sparse_rate, sparse_passing, sparse_df = protdbench_style_eval(
        df, sparse_score, threshold)
    dense_rate, dense_passing, dense_df = protdbench_style_eval(
        df, dense_score, threshold)

    sparsity_values = df.apply(gradient_sparsity, axis=1)
    mean_sparsity = float(sparsity_values.mean())

    sparse_clusters = cluster_passing_backbones(sparse_df, sparse_passing)
    dense_clusters = cluster_passing_backbones(dense_df, dense_passing)

    baseline_rate = random_baseline_success_rate(len(df), threshold)

    print("=== BindCraft-style scoring comparison (proxy data) ===")
    print(f"Rows (candidate designs) evaluated: {len(df)}")
    print(f"Backbones (symbols) evaluated: {df['symbol'].nunique()}")
    print()
    print("-- ipTM-style (sparse, max-based) scoring --")
    print(f"Per-sequence success rate: {sparse_rate:.3f}")
    print(f"Passing backbone set size: {len(sparse_passing)} "
          f"of {df['symbol'].nunique()}")
    print(f"Structural-similarity clusters (proxy): {sparse_clusters}")
    print()
    print("-- pTMEnergy-style (dense, mean-based) scoring --")
    print(f"Per-sequence success rate: {dense_rate:.3f}")
    print(f"Passing backbone set size: {len(dense_passing)} "
          f"of {df['symbol'].nunique()}")
    print(f"Structural-similarity clusters (proxy): {dense_clusters}")
    print()
    print(f"Mean gradient sparsity of ipTM-style score (1.0 = fully "
          f"sparse, 0.25 = fully dense over 4 features): {mean_sparsity:.3f}")
    print()
    print(f"Random baseline success rate to beat: {baseline_rate:.3f}")
    print()
    if dense_rate >= sparse_rate and dense_rate > baseline_rate:
        print("RESULT: dense (pTMEnergy-style) scoring matched or beat "
              "sparse (ipTM-style) scoring, and both beat the random baseline.")
    else:
        print("RESULT: dense scoring did not clearly beat sparse scoring "
              "on this data; inspect thresholds and feature scaling.")

    elapsed = time.time() - start
    print(f"\nElapsed time: {elapsed:.2f} seconds")


if __name__ == "__main__":
    main()